A procurement analyst asks an assistant to check purchase order PO-20418. The current status is not included in the user's message, so the assistant needs information from an enterprise integration before providing an answer. The model must receive enough context to understand the question, recognise the available business capabilities and determine whether one of those capabilities should be requested.
For an Oracle Integration developer, this raises an important runtime question: what exactly does the agent send to the Large Language Model (LLM), and how does it interpret the response? A normal text response, a structured tool request and the result returned by an integration represent different events. Neither a model-generated response nor its finish metadata independently proves that the business operation completed successfully.
In this tutorial, we will examine these boundaries using the OCI-specific ReAct thinking pattern in Oracle Integration 3. We will distinguish the documented OIC agent configuration from the OCI Generative AI Chat API contract and identify which implementation details require evidence from the actual system-generated integration.
1. What You Will Trace
This is a focused runtime and request/response inspection tutorial for an Oracle Integration 3 Project AI Agent using the ReAct for OCI GenAI thinking pattern.
Oracle provides separate thinking-pattern recipes for OCI Generative AI models and non-OCI models. This article specifically concerns the ReAct for OCI GenAI recipe, not the ordinary ReAct recipe documented for non-OCI LLM connections.
We will follow one synthetic procurement request:
The example request
"Check the current status of purchase order PO-20418."
Available business capability:
A registered, read-only OIC agentic AI tool that retrieves the current status of one purchase order.
By the end, you should be able to:
- Understand how messages and registered tool information contribute to a model request.
- Read the important fields in the OCI Generic Chat request and response structures.
- Distinguish assistant text, a structured function call and an integration result.
- Understand how a tool result can become input to another model invocation.
- Distinguish configured pattern settings from values actually serialized into an OCI request.
- Explain why
finishReason, the OIC iteration limit and successful business completion are different concepts.
Completion evidence: You can identify important request fields, interpret the model response, correlate a tool call with its result and explain which runtime implementation evidence is needed before claiming that OIC executed a particular branch.
2. In This Post
- Before You Begin — Identify the Runtime Participants
- How the Agent Builds the Model Request
- Read the OCI GenAI Request Structure
- Understand the Model Response Structures
- Worked Trace: From PO Question to Next Runtime Decision
- Configured Settings, Runtime Values and Temperature
- Finish Metadata Is Not the Same as Agent Stopping
- Tests, Evidence and Troubleshooting
- Completion Checklist
- Five Useful FAQs
- Official Oracle References
- Finally — Summary
3. Before You Begin — Identify the Runtime Participants
3.1 The LLM is one participant, not the complete agent
A Large Language Model (LLM) processes language input and generates an output. It can interpret a request, work with supplied context and propose an action.
However, an LLM does not automatically have access to an OIC integration, an ERP database or a supplier system simply because a user mentions one.
An AI agent combines model-based decision-making with an execution environment that makes approved capabilities available, processes model responses, invokes the appropriate operations and provides their results for further processing.
In OIC Project AI Agents, the selected thinking pattern and registered agentic AI tools are important components of this arrangement.
Kid-friendly analogy
Imagine a sports coach preparing a team for a match. The coach receives the problem, knows which players are available and decides who should take the next action. The coach does not become the player who performs every action.
In this OCI AI integration, this means: The LLM helps select a possible next action, while the OIC agent runtime coordinates the available integration tools and processes their results.
This distinction is essential when examining a runtime trace. A model can return a structured request to call a tool, but that response alone is not evidence that the integration ran.
The agent runtime must interpret the request and dispatch the corresponding registered capability. The integration must then execute and return its result before the agent can use that result in another model interaction.
3.2 Understand the OCI-specific ReAct pattern
Oracle Integration provides different thinking-pattern recipes for different LLM providers and service integrations.
In the Oracle Integration documentation, the available recipes are distinguished as follows:
| Pattern recipe | Purpose |
|---|---|
ReAct for OCI GenAI |
Reasoning and action pattern for OCI Generative AI models. |
ReAct |
Reasoning and action pattern for non-OCI LLM connections. |
Plan GenAI |
Planner for the OCI Generative AI plan-and-react approach. |
Plan |
Planner for non-OCI models in the plan-and-execute approach. |
Oracle describes a pattern recipe as the value supplied to the LLM as a system prompt to define how the agent reasons. The pattern itself is implemented through an integration.
Naming qualification: The general configuration page uses Plan GenAI, whereas the supported-model page uses Plan for OCI GenAI. These are documentation labels, not a verified selector value for a particular tenant. This tutorial selects only ReAct for OCI GenAI.
For ReAct, the conceptual sequence is:
- Reason: Interpret the current request and context.
- Act: Request an appropriate tool operation when additional information or an action is required.
- Observe: Process the tool result.
- Repeat: Continue the cycle when another decision or action is necessary.
These are conceptual steps in the ReAct approach. They should not be interpreted as a promise that the runtime exposes the model's private reasoning trace as a readable execution log.
For this tutorial, the selected recipe is specifically ReAct for OCI GenAI.
See Oracle's Configure the Agentic AI Thinking Pattern and Add the ReAct for OCI GenAI Agentic AI Pattern documentation.
3.3 What is specific to ReAct for OCI GenAI in OIC?
The dedicated Oracle instructions for ReAct for OCI GenAI contain OIC-specific configuration details that should not be inferred from the generic ReAct setup instructions.
The documented pattern creation sequence is:
- In Oracle Integration, select Projects and open the project.
- In the left navigation pane, select AI Agents.
- In the Agent patterns section, click Add.
- In Create pattern, complete Name, Identifier and the displayed version information. Select
ReAct for OCI GenAIfor Pattern recipe, then click Create. - On the Pattern details page, configure Max iterations, Guidelines and Model type.
- Click Save. Oracle Integration automatically creates the system-generated integration named
ReAct Pattern Intg for OCI GenAIin the project.
The dedicated setup page then instructs you to configure the OCIGenAI_Properties lookup:
- Return to the AI Agents page.
- In the left toolbar, select Integration.
- In the Lookups section, select
OCIGenAI_Properties. - For
Compartment_OCID, setPropertyValueto the OCID of the compartment in which Oracle Integration is installed. - For
Region, ensure thatPropertyValuecontains the correct region. - Click Save.
These are documented OIC configuration steps. They are not fields that should be invented in the native OCI Chat JSON request. The actual mapping from the lookup values to the generated integration's outbound request still needs to be established from the exported integration if a mapper-level statement is required.
Model compatibility needs a current check
Oracle's general Supported Large Language Models page lists OpenAI, xAI and Google Gemini model families for the OCI GenAI pattern family. However, the dedicated ReAct for OCI GenAI setup page explicitly lists OpenAI and xAI models. Verify the selected model in the current OIC tenant and the relevant regional model catalogue rather than assuming that every model family is supported by this recipe.
There is also an OCI access prerequisite. Oracle's OIC prerequisites page instructs customers to use identity domains and configure a dynamic group and policy that allow the Oracle Integration instance to access OCI Generative AI. The documented approach uses the OAuth application client ID for the OIC instance as the dynamic-group matching rule and grants the required Generative AI service permissions.
For OCI Generative AI, Oracle documents this policy pattern:
Allow dynamic-group OIC_DYNAMIC_GROUP to manage generative-ai-family in compartment OIC_COMPARTMENT
Use the actual dynamic-group and compartment names for the environment. The compartment in the documented policy is the compartment containing the Oracle Integration instance.
Terms: An OCID is an Oracle Cloud Identifier, which identifies a resource and is not a credential. A compartment groups OCI resources. IAM is Identity and Access Management. The dynamic group identifies the OIC caller; the policy grants that caller permission.
The dynamic-group rule documented for this OIC prerequisite uses resource.id = 'OIC_OAUTH_APPLICATION_CLIENT_ID'. Replace the placeholder with the client ID of the OIC instance’s OAuth application, not a Compute instance OCID. Oracle also documents domain-qualified dynamic-group names when needed. The policy above is Oracle’s broad prerequisite template, not a statement that it is the minimum permission set for every production design.
Identity boundary: The policy grants the OIC instance access to the OCI Generative AI service. It is separate from the OAuth authentication configured on the REST trigger of an integration registered as an agentic AI tool. Tool guidelines do not grant IAM permissions.
See Oracle's OCI AI Services prerequisites for Oracle Integration.
3.4 Understand what OIC makes available to the model
An OIC integration can be registered as an agentic AI tool. This makes a defined integration capability available for an AI agent to use.
The integration must meet Oracle's documented prerequisites:
- The integration must be part of a project.
- The integration must be Active.
- The first connection in the integration must be a REST trigger connection using the REST Adapter.
- The REST trigger must use OAuth authentication and a JSON payload.
- The REST trigger can use a verb supported by the REST Adapter: GET, POST, PUT, DELETE or PATCH. This does not mean that a GET request should carry a JSON body. For the illustrative lookup, a POST trigger can accept a JSON order-number input while its implemented business operation remains read-only.
Oracle's registration process is documented as follows:
- In the navigation pane, select Projects.
- Open the project containing the integration.
- In the Integrations section, locate the integration.
- Confirm that it is Active.
- From the integration's Actions menu, select Create agentic AI tool.
- Enter the required tool details and create the tool.
- Configure the additional description, guidelines and parameter settings on the tool details page, then save.
Oracle's Register an Integration as an Agentic AI Tool documentation distinguishes the following fields:
| OIC tool detail | Documented behaviour | Why it matters |
|---|---|---|
Name |
Automatically populated from the integration name and not sent to the LLM. | Do not assume that the displayed OIC Name is the model-facing tool identifier. |
Identifier |
Uniquely identifies the tool in the project and is sent to the LLM as tool metadata. | Helps the LLM identify the available business capability. |
Description |
Sent to the LLM as part of the system prompt. | Explains what the integration does and when to use it. |
Guidelines |
Optional instructions sent as part of the system prompt. | Influences the LLM's decision about tool usage and constraints. |
| Visible parameters | Parameters marked Visible are sent to the LLM. Unmarked parameters are not sent. | Controls which integration inputs are exposed for model-generated values. |
| Required, Constant and Default | Configure required input assignment, fixed values and default values. | Helps define how integration inputs are supplied. |
There are a few additional parameter settings worth understanding:
- Required: Indicates to the LLM that it must assign a value to the parameter. Oracle's documentation states that configuring it as required ensures a value is present when the agent calls the tool. Presence does not establish that the value is non-empty, correctly formatted, authorized or meaningful; the receiving integration should validate it before use.
- Constant: Supplies a specific value that the LLM is not expected to decide.
- Default Values: Specifies a value to use when no value is assigned, provided the configured default is appropriate.
- Enum Values: Provides a comma-separated set of allowed choices.
- Description: Explains each parameter so that the LLM can understand its purpose.
Kid-friendly analogy
A school library has a catalogue containing books students are allowed to request. Each book has a title, description and borrowing rules. A student might ask for an unlisted book, but the librarian must check the catalogue before lending anything.
In this OCI AI integration, this means: Registered tool metadata and visible parameters describe the integration capabilities available to the model. They do not prove that the model will select a tool or that its generated arguments will be valid.
For our example, imagine a registered, read-only integration that retrieves purchase-order status. Its model-facing Identifier might be something like GET_PO_STATUS, and its visible input might be purchaseOrder.
These are illustrative values. The actual identifier, input names and parameter settings must come from the relevant project's tool configuration.
Important security boundary: Tool descriptions and guidelines influence model behaviour. They do not enforce authorization. The integration and target system must independently validate the purchase order, enforce access controls and protect the read-only business operation.
3.5 Associate the tool with an active agent
Registering an integration does not automatically attach it to every agent. Oracle’s Add and Configure the AI Agent documents the association process.
- Ensure the thinking pattern is Active before selecting it. The thinking-pattern guide documents Agent patterns → Actions → Activate.
- Open the project’s AI Agents page. In the agents section, click Add. Complete the agent details and select the thinking pattern, then click Create.
- Configure the agent’s Role and Guidelines. For this example, instruct it to retrieve current status through the registered lookup, ask for missing order numbers and report lookup failures without inventing a status.
- In Tools, click +, select the registered lookup and click Add. Click Save.
- Return to the agents list and use the agent’s Actions → Activate.
Practical prerequisite: The PO lookup integration must already implement and independently pass its backend read. Its ERP endpoint, mappings and credentials are tenant-specific and were not supplied. The examples in this article do not create that backend integration.
4. How the Agent Builds the Model Request
4.1 A request combines model selection, messages and available tools
The model cannot make an appropriate next-action decision from the user's latest sentence alone when the decision depends on additional business information.
It needs a request context: the information supplied for a particular model invocation.
For this tutorial, consider three related components:
- Selected model: The model that receives the inference request.
- Conversation messages: The instructions, user request and relevant preceding context supplied to the model.
- Available tools: The business capabilities and input structures the model may be allowed to request.
The model processes this supplied information and generates an assistant response. It does not automatically receive every field in an OIC project, every integration input or every application record.
Kid-friendly analogy
Imagine giving a student a notebook, a question and a list of people they are allowed to ask for help. The student uses all three to decide what to do next. Without the list, the student may not know who can provide the missing information.
In this OCI AI integration, this means: Messages provide context, the model processes that context, and tool definitions describe the capabilities that it may request.
OIC-specific qualification: Oracle documents which registered-tool fields are made available to the LLM, including the Identifier, Description, Guidelines and Visible parameters. However, the exact serialization of those fields by the ReAct for OCI GenAI system-generated integration must be confirmed from that integration's implementation. Do not assume that the native OCI tools JSON shown later is a literal copy of the OIC runtime payload.
4.2 Messages carry context across model invocations
A message is one item in the conversation context. Its role identifies the type of participant that supplied the content.
The OCI Generic Chat message-role definitions include:
SYSTEM: Instructions that define the model's operating context.DEVELOPER: Developer-provided instructions.USER: The user's request or supplied input.ASSISTANT: Content generated by the model.TOOL: The result returned by a tool operation.
These are native OCI Generic Chat message-role definitions. Do not assume that every provider-specific Chat format uses the same message structure or that OIC exposes these exact roles directly in its generated integration.
For our example, a native Generic Chat request could contain a system instruction and a user message asking for the current status of PO-20418.
When continuing a tool interaction, the relevant assistant tool-call message and tool response can also become part of the subsequent model context.
These message types must not be confused with tool definitions:
- A message records an instruction, request, response or observation.
- A tool definition describes a capability the model may request.
- A tool result records the output of an executed capability.
OCI's Generic Chat contract represents messages in the messages array, with typed content such as text. The exact message structure is format-dependent.
4.3 Tool definitions describe possible actions
A tool definition tells the model about a function it may request. In the OCI Generic Chat format, a function definition contains:
name: The function name.description: What the function does and when it is useful.parameters: A JSON Schema object describing its inputs.
For the PO example, the conceptual native OCI function definition could look like this:
{
"type": "FUNCTION",
"name": "get_purchase_order_status",
"description": "Read the current status of one purchase order.",
"parameters": {
"type": "object",
"properties": {
"purchaseOrder": {
"type": "string",
"description": "The exact purchase order number."
}
},
"required": [
"purchaseOrder"
]
}
}
Contract detail: In native OCI Generic Chat, type, name, description and parameters belong to the same function-definition object. A nested function wrapper would mix in another API’s shape.
This is an illustrative OCI Generic Chat function definition. It is not a claim that OIC exposes these exact JSON properties in its tool configuration screen or that the generated OIC ReAct integration serializes its registered tool using this exact structure.
The JSON Schema describes the expected input structure. It does not guarantee that the model will always produce valid arguments.
Oracle's SDK documentation explicitly warns that model-generated function arguments may contain invalid JSON or parameters that were not defined in the function schema. The receiving application must validate the arguments before invoking the function.
4.4 Model, region and compartment belong to different parts of the request
It is important not to treat model, region and compartment as three interchangeable properties of one request object.
In the native OCI Generative AI Chat API contract illustrated in this article, the request has the following structure:
- Region: Identified through the regional service endpoint.
- Compartment: Supplied through
compartmentId. - Model serving configuration: Supplied through
servingMode. - Conversation context: Supplied through
chatRequest.
| Setting | OCI Chat contract location | Purpose |
|---|---|---|
| Region | Regional endpoint hostname | Determines the regional inference endpoint that receives the request. |
| Compartment | compartmentId |
Identifies the compartment used for the Generative AI inference request. |
| On-demand model | servingMode.modelId |
Identifies the model selected for inference. |
| Conversation context | chatRequest.messages |
Contains the messages for the invocation. |
| Function definitions | chatRequest.tools |
Describes the functions the model may request in the Generic Chat format. |
Important OIC distinction: For the dedicated ReAct for OCI GenAI pattern, Oracle specifically instructs you to set Compartment_OCID in the OCIGenAI_Properties lookup to the compartment in which Oracle Integration is installed. This is an OIC pattern configuration instruction. Do not replace it with an arbitrary compartment based only on the native API field name.
The native OCI Chat API uses compartmentId in its request envelope. The exact mapping from the OIC lookup value to that outbound property should be confirmed from the generated integration export before asserting a particular source-to-target mapper relationship.
Supplying a compartment OCID does not itself grant permission to invoke the service. The request's authentication identity and required IAM authorization remain separate concerns.
5. Read the OCI GenAI Request Structure
5.1 Understand which OCI API contract is being illustrated
Before examining the JSON, one API distinction is important.
OCI has more than one interface for model interaction. This article's native OCI Chat request example uses the Chat operation with API version 20231130. It is not the same contract as OCI's OpenAI-compatible Chat Completions API or Responses API.
| OCI interface | Endpoint pattern | Important distinction |
|---|---|---|
| Native OCI Chat operation | /20231130/actions/chat |
Uses the OCI ChatDetails request envelope and format-specific chat schemas. |
| OCI Chat Completions API | /openai/v1/chat/completions |
Uses an OpenAI-compatible Chat Completions structure. |
| OCI Responses API | /openai/v1/responses |
Provides a separate interface for model interaction and agentic workflows. |
Oracle recommends the Responses API for most new OCI applications requiring agentic capabilities. It supports supported tools, multi-step workflows, structured outputs and OCI-managed conversation history. The Chat Completions API is positioned for applications that need its simpler, stateless interface and existing compatibility.
That recommendation concerns OCI API selection. It does not establish that OIC Project AI Agents use the Responses API internally.
Likewise, the use of the ReAct for OCI GenAI pattern does not establish which exact native OCI endpoint, API format or payload mapper is used by the generated OIC integration. That must be verified separately.
For the following request example, we are deliberately studying the documented native OCI Chat API contract. We are not claiming that it is an observed payload from the OIC-generated ReAct integration.
5.2 The representative request
The OCI native Chat API request is represented by ChatDetails. Its required top-level components are:
compartmentIdservingModechatRequest
The following is a representative, non-streaming request using OCI's GENERIC Chat format and on-demand serving mode. The explicit isStream: false matches the complete-response examples below; streamed responses require event handling.
The model identifier and compartment OCID are placeholders. A real request must use a model supported in the selected region and compatible with the required API format and function-calling capability.
{
"compartmentId": "ocid1.compartment.oc1..REPLACE_WITH_COMPARTMENT_OCID",
"servingMode": {
"servingType": "ON_DEMAND",
"modelId": "REPLACE_WITH_SUPPORTED_MODEL_ID"
},
"chatRequest": {
"apiFormat": "GENERIC",
"messages": [
{
"role": "SYSTEM",
"content": [
{
"type": "TEXT",
"text": "You are a read-only procurement assistant. Use the available purchase-order lookup function when current order data is required. Do not invent order status values."
}
]
},
{
"role": "USER",
"content": [
{
"type": "TEXT",
"text": "Check the current status of purchase order PO-20418."
}
]
}
],
"tools": [
{
"type": "FUNCTION",
"name": "get_purchase_order_status",
"description": "Read the current status of one purchase order.",
"parameters": {
"type": "object",
"properties": {
"purchaseOrder": {
"type": "string",
"description": "The exact purchase order number to look up."
}
},
"required": [
"purchaseOrder"
]
}
}
],
"isStream": false
}
}
Read the request from the outside inward:
compartmentIdidentifies the compartment for the inference request.servingModespecifies the model serving configuration. This example usesON_DEMANDand a model identifier.chatRequestcontains the actual model interaction.apiFormatselects the request/response representation.messagessupplies the context for the invocation.toolsdescribes the function the model may request.
For the native OCI Chat API, the documented format values include:
GENERICCOHERECOHEREV2
The corresponding request and response structures are different. For example, the Cohere Chat contract uses provider-specific message and history fields, whereas Generic Chat uses the Generic message structure. Do not copy a Generic response parser into a Cohere request simply because both operations use the same Chat endpoint.
The example intentionally omits the optional temperature property. We will return to that field when examining how a configured OIC value might flow into an outbound OCI request.
5.3 Region and authentication are not interchangeable with request fields
The native OCI Chat endpoint follows this regional URL pattern:
POST https://inference.generativeai.<region>.oci.oraclecloud.com/20231130/actions/chat
The API version 20231130 is part of the service endpoint. It is not an OIC release number, OCI region identifier or model version.
For the native OCI API operation, use the OCI request-signing scheme and the required signed headers. Do not assume that a bearer token copied from an OpenAI-compatible endpoint example is interchangeable with the authentication mechanism for this native API operation.
The OpenAI-compatible OCI endpoints document their own authentication options, including OCI Generative AI API keys and IAM-based authentication. They are separate endpoints and should be configured against their respective contracts.
See Oracle's Request Signatures, OCI Responses API and OCI Chat Completions API documentation.
OIC implementation boundary: The endpoint and payload above illustrate an OCI service contract. They do not prove that the system-generated OIC ReAct integration uses this exact URL, authentication configuration or body. Confirm those details from the actual generated integration and its associated configuration.
5.4 Configured values and runtime values are different
A configured value is established during pattern or model configuration. A runtime value is supplied or assembled for a particular invocation.
They can meet in the final request, but they do not have the same source or lifecycle.
| Value category | Example | Question to verify |
|---|---|---|
| OIC pattern configuration | Pattern recipe, Max iterations, Guidelines and Model type | Which values are configured for the OCI-specific pattern? |
| OIC lookup configuration | OCIGenAI_Properties fields Compartment_OCID and Region |
Which compartment and region values are configured for the pattern? |
| Native OCI request | compartmentId, servingMode and chatRequest |
Which values are serialized into the actual OCI request? |
| Conversation runtime data | Current request, previous messages and tool observations | What information is included in this invocation? |
| Tool-call arguments | Purchase order number returned by the model | Are arguments parsed, validated and mapped before execution? |
The dedicated OIC page for ReAct for OCI GenAI documents Max iterations, Guidelines and Model type as the pattern settings. It also documents the OCIGenAI_Properties lookup. It does not document a temperature setting in that OCI-specific configuration sequence.
The general thinking-pattern documentation contains a screenshot showing a temperature value for its ReAct example. That screenshot must not be treated as proof that the OCI-specific recipe exposes the same temperature field or uses the same default.
In particular, do not assume that a value displayed in one pattern UI has been forwarded to the OCI request without inspecting its actual mapping.
Similarly, Max iterations is a runtime limit on reasoning/action steps. It is not the same as the maximum number of generated LLM tokens. A token is a unit used to represent text and may be a word, part of a word or punctuation.
6. Understand the Model Response Structures
After receiving the request, the model returns a response. For runtime analysis, distinguish an assistant message containing ordinary text from an assistant message requesting a structured function call.
The following structures illustrate OCI Generic Chat. They are not a guarantee that every model or provider-specific API format returns identical content.
6.1 Response A — Assistant text only
A text-only response contains assistant content without a structured tool call.
For example, a representative native OCI Generic Chat response could look like this:
{
"modelId": "MODEL_OCID_RETURNED_BY_SERVICE",
"modelVersion": "MODEL_VERSION_RETURNED_BY_SERVICE",
"chatResponse": {
"timeCreated": "2026-11-07T08:30:00Z",
"choices": [
{
"index": 0,
"message": {
"role": "ASSISTANT",
"content": [
{
"type": "TEXT",
"text": "I can help check the purchase order. I need the live order record to confirm its current status."
}
]
},
"finishReason": "REPLACE_WITH_RETURNED_VALUE"
}
],
"apiFormat": "GENERIC"
}
}
The outer response contains model information and a chatResponse object. The nested apiFormat: GENERIC identifies the Generic response subtype. The Generic Chat response contains a list of choices. Each choice includes a message and a finish reason. The timeCreated field is part of the Generic Chat response structure.
The placeholder REPLACE_WITH_RETURNED_VALUE is illustrative, not an actual OCI finish-reason value. The model metadata and timestamp are synthetic too; the example is a schema-reading template, not a captured execution.
What does this response establish?
- The model generated assistant text.
- The illustrated message does not contain a structured
toolCallsentry. - No purchase-order integration execution is established by this response.
A runtime must evaluate the response according to its implemented pattern logic. It may accept a response, continue the process or follow another supported branch. The exact decision in the generated OIC integration must be inspected rather than inferred from the presence or absence of text alone.
This is a useful failure scenario: the model might produce a confident-sounding response without actually retrieving the enterprise data needed to answer the question.
A syntactically successful model response is not proof that the business question was resolved.
6.2 Response B — Structured tool request
A tool call is a structured request from the model asking the application or agent runtime to invoke a named function with supplied arguments.
It is not the execution of that function.
For the PO example, the following synthetic response template illustrates a function call containing the requested purchase order. The model metadata, timestamp, call ID and finish-reason placeholder are illustrative, not values observed in a live service response:
{
"modelId": "MODEL_OCID_RETURNED_BY_SERVICE",
"modelVersion": "MODEL_VERSION_RETURNED_BY_SERVICE",
"chatResponse": {
"timeCreated": "2026-11-07T08:31:00Z",
"choices": [
{
"index": 0,
"message": {
"role": "ASSISTANT",
"content": null,
"toolCalls": [
{
"id": "call_po_20418_01",
"name": "get_purchase_order_status",
"arguments": "{\"purchaseOrder\":\"PO-20418\"}",
"type": "FUNCTION"
}
]
},
"finishReason": "REPLACE_WITH_RETURNED_VALUE"
}
],
"apiFormat": "GENERIC"
}
}
The type: FUNCTION discriminator identifies the function-call subtype. This illustrates the OCI Generic Chat function-call structure. The Generic Chat SDK represents a function call with an identifier, function name and arguments. The actual finish reason must be taken from the model response. Do not invent or assume its literal value.
Read the tool-call fields separately:
ididentifies this particular tool request.nameidentifies the function the model is requesting.argumentscontains the model-generated function inputs, represented as JSON text.
Kid-friendly analogy
A student writes a request slip saying, "Please ask the librarian for book PO-20418." The slip tells the helper what to ask for, but the book has not been collected yet.
In this OCI AI integration, this means: A structured tool call is a request for the OIC runtime to invoke a registered capability. It is not evidence that the integration has already run.
OCI's Generic Chat function-call contract documents the call identifier, function name and arguments.
Oracle also warns that the generated arguments may be invalid JSON or contain parameters that are not in the declared function schema.
Therefore, never treat model-generated arguments as trusted business input. They must be validated before a real operation is invoked.
6.3 Do not assume that text and tool calls form a third supported response branch
The OCI Generic Chat assistant message model has separate optional content and tool-call properties. However, Oracle's SDK documentation gives an important instruction for multi-step tool interactions: when responding with a tool call, set the assistant message's content to null, not an empty string.
For that reason, the normal tool-request example in this tutorial uses:
"content": null
"toolCalls": [ ... ]
Do not rely on a model always returning explanatory text and a structured function request together. Nor should you assume that the OIC-generated ReAct pattern will process such a mixed message in a particular way.
If mixed content is encountered in an actual response, inspect the selected API format's contract and the generated OIC runtime implementation before making claims about its handling.
6.4 The tool result must match the call identifier
After a tool request is accepted and the OIC runtime dispatches the registered integration, the integration returns its result.
In an OCI Generic Chat multi-step interaction, the tool result is associated with the original call through its identifier.
For the illustrative PO example, suppose the integration returns:
{
"role": "TOOL",
"toolCallId": "call_po_20418_01",
"content": [
{
"type": "TEXT",
"text": "{\"purchaseOrder\":\"PO-20418\",\"status\":\"SHIPPED\"}"
}
]
}
There are two identifiers that deserve particular attention:
ididentifies the assistant's original tool call.toolCallIdidentifies the call to which the tool result responds.
The value of toolCallId must correspond to the original tool-call id.
It is not the user conversation ID, integration instance ID or purchase order number.
In this example, the business result reports that the order is SHIPPED. This is an application-defined synthetic result, not a standard Oracle purchase-order response contract. The runtime can supply this observation in a subsequent model invocation.
The model can then generate a user-facing answer based on the returned data.
7. Worked Trace: From PO Question to Next Runtime Decision
Now connect the request and response structures into one end-to-end reasoning/action trace.
This is a conceptual walkthrough using the synthetic PO record. It demonstrates which evidence to inspect. It is not an observed execution from a live OIC tenant.
7.1 Step 1 — Assemble the request context
The agent receives the user's request:
User input: "Check the current status of purchase order PO-20418."
The request context must contain the information necessary for the model to determine an appropriate next action.
For the example, that means:
- Relevant system-level instructions.
- The user's purchase-order question.
- The available purchase-order lookup capability.
- The information needed to provide the function's input.
The actual message set and function definitions must come from the real outbound request or generated pattern integration. They must not be reconstructed from assumptions about how another agent implementation works.
7.2 Step 2 — Inspect the model request
At the request boundary, inspect the following information:
| Question | Evidence to inspect | Why it matters |
|---|---|---|
| Which model received the request? | Configured OIC Model type and actual outbound serving configuration, where available. | Different models may have different supported capabilities and response structures. |
| Which region is configured? | The Region value in OCIGenAI_Properties and the actual outbound endpoint, where available. |
Model availability and endpoint routing can vary by region. |
| Which compartment is configured? | Compartment_OCID in OCIGenAI_Properties; native compartmentId if the native OCI Chat operation is being used. |
The OIC setup page identifies the compartment in which Oracle Integration is installed. |
| What context did the model receive? | The actual message collection and message content. | Missing or stale context can lead to an unsuitable answer. |
| Which capabilities were offered? | Registered OIC tools and their model-facing information; native tools field if the Generic Chat API is actually used. |
Only capabilities made available to the runtime should be dispatchable; a model can still generate an unknown tool name. |
If the actual request is not exposed by the OIC monitoring interface, do not claim that a field was sent merely because it appears on a configuration screen.
Use the system-generated integration export, mapper definitions and approved request telemetry to establish the value flow.
A design-time mapping and a runtime payload answer different questions.
7.3 Step 3 — Interpret a tool request as a proposed action
Assume that the model returns the structured function call illustrated earlier:
Requested function: get_purchase_order_status
Call identifier: call_po_20418_01
Argument: {"purchaseOrder":"PO-20418"}
The model has requested a function. The runtime must now process that request according to the registered tool configuration and the executable pattern logic.
From an integration-design perspective, the following checks are important:
- Confirm that the requested function corresponds to a registered capability.
- Parse the model-generated argument string.
- Validate the argument structure and required values.
- Reject unexpected fields, unsupported values and unsafe inputs.
- Dispatch the operation only after the required validation.
These checks describe the engineering requirements for safe dispatch. The precise branches and validation activities implemented by the system-generated OIC pattern must be confirmed from the actual export.
The distinction is crucial:
- Model decision: The response contains a request for a named function.
- Runtime dispatch: The agent runtime processes the returned request.
- Integration execution: The registered OIC integration actually runs.
- Business result: The integration returns information that must be interpreted and validated.
These are separate events. A model response does not prove that the runtime dispatched the request, that the integration succeeded or that the returned data is complete.
7.4 Step 4 — Correlate and validate the tool result
Suppose the read-only integration returns SHIPPED.
The result must be associated with the original function call. In the illustrated Generic Chat contract, this relationship is represented by toolCallId.
Before treating the result as suitable for another model request, verify:
- The returned record refers to
PO-20418, not another purchase order. - The status was returned by the integration rather than inferred by the model.
- A not-found response, integration fault or incomplete response remains distinguishable from a successful status lookup.
- The result is correlated with the correct function-call identifier.
A tool result is an observation. It must not automatically be treated as a correct final answer before the business workflow has established that the observation is sufficient for the user's question.
7.5 Step 5 — Include the tool observation in the next model context
When the runtime continues the ReAct cycle, the subsequent model request can include the original question, the assistant's function call and the corresponding tool result.
This allows the model to interpret the newly available business information rather than answer solely from the initial user request.
At a conceptual level, the message sequence looks like this:
[
{
"role": "USER",
"content": [
{
"type": "TEXT",
"text": "Check the current status of PO-20418."
}
]
},
{
"role": "ASSISTANT",
"content": null,
"toolCalls": [
{
"id": "call_po_20418_01",
"name": "get_purchase_order_status",
"arguments": "{\"purchaseOrder\":\"PO-20418\"}",
"type": "FUNCTION"
}
]
},
{
"role": "TOOL",
"toolCallId": "call_po_20418_01",
"content": [
{
"type": "TEXT",
"text": "{\"purchaseOrder\":\"PO-20418\",\"status\":\"SHIPPED\"}"
}
]
}
]
This is a conceptual conversation excerpt. To continue the native JSON exercise, retain the request envelope, serving configuration and tool definition from section 5; use this array as the next chatRequest.messages collection and retain the relevant system instructions. In a real interaction, carry forward the assistant message actually returned by the service and its real call ID.
A real request may also include system or developer messages, previous turns and other relevant context. The exact structure depends on the API format and selected model. This example does not define an undocumented OIC input: the OIC-managed agent assembles its own continuation.
The model might now generate a response such as:
"Purchase order PO-20418 is currently marked as SHIPPED."
That sentence is still model-generated text. The authoritative business evidence in this example is the integration result and its correlation with the requested purchase order.
Before calling a status “current,” also establish the backend’s data freshness or as-of time. SHIPPED does not imply delivered, paid or otherwise complete. A real acceptance test needs an independently known test record and a final answer that agrees with its returned status.
8. Configured Settings, Runtime Values and Temperature
8.1 What temperature controls
Temperature is a model-generation setting that influences variation in generated output.
A lower value generally produces less random output, while a higher value permits more variation. It influences generation; it does not determine integration authorization, validate a function argument or enforce a procurement business rule.
The native OCI Generic Chat request schema exposes temperature as an optional request property.
Oracle's SDK documentation describes lower temperatures as useful for tasks such as question answering and summarization, while higher temperatures can produce more varied output and may increase the risk of factually incorrect responses. The exact accepted values and model behaviour must be checked against the selected model's current contract.
Kid-friendly analogy
Imagine a drawing game where a dial changes how freely a student varies the next pencil stroke. A low setting allows less variation; it does not make every stroke correct. The dial is separate from the teacher’s instructions about what to draw.
In this OCI AI integration, this means: Temperature influences generated output variation. It does not validate a tool argument, guarantee factual correctness or replace business validation in an OIC integration.
A temperature setting displayed in one OIC pattern configuration screen is not sufficient evidence that the same value was serialized into the native OCI request.
Public documentation establishes supported configuration fields. A claim about a particular invocation additionally needs runtime evidence; a response’s writing style is not evidence of a request parameter.
8.2 A field in a schema is not necessarily a field in the request
The native OCI Generic Chat contract documents the optional request field chatRequest.temperature. The OCI-specific OIC pattern setup page documents Max iterations, Guidelines and Model type; it does not establish a public temperature setting for that recipe.
A temperature value in the general ReAct screenshot belongs to that documented example. It does not establish a corresponding OCI-specific configuration field, default or generated source-to-target assignment.
Correction: an unverified internal name is not a public setting
The inspected official setup and native API references do not establish patternTemperature as a public OCI ReAct configuration field. No generated integration export was supplied to establish it as an internal input either. Instructions to locate, change or map that supposed field have therefore been removed. This does not prove that the internal name never occurs in any release; its existence and behavior are simply not established by the supplied evidence.
The general evidence distinction remains useful without introducing a speculative source name:
| Stage | Field or evidence | What it establishes |
|---|---|---|
| Input schema | An artifact-specific input, if declared | The particular artifact declares an input; this alone does not establish its use or a supported public configuration field. |
| Mapper or assignment | An assignment reaching chatRequest.temperature |
The design explicitly connects the source value to the target request field. |
| Serialized request | "temperature": 0.2 |
The value appears in the actual outbound payload for that invocation. |
| Service response | Returned model metadata and generated response | Evidence of the model response, but not by itself proof of the temperature value supplied. |
Read the table from top to bottom. A schema describes what can be represented. An assignment describes a design-time value flow. A serialized request shows the values actually sent for one invocation. A generated answer is not a substitute for any of those forms of evidence.
A mapping can also use constants, intermediate values or expressions. Therefore, the absence of a direct line between two similarly named fields does not establish that a request parameter is omitted. The effective request is the relevant runtime evidence when that specific question matters.
Implementation inspection is appropriate for an implementation-specific question. It should not replace checking the official public contract before recommending a configuration field to a reader.
If a native request omits optional temperature, the service and selected model determine the omitted-value behavior. Do not describe omission as explicitly setting zero, and do not invent a universal numeric default or accepted range.
Lower temperature generally reduces sampling variation. It does not guarantee identical outputs, correct facts, appropriate tool selection or valid JSON. For a model that does not support a particular sampling control, follow that model’s documented API restrictions.
Practical conclusion
Use documented OIC configuration for the managed pattern. Use the native API’s temperature only in a native request or supported configuration that actually exposes it. Do not modify the system-generated integration to implement an inferred setting.
9. Finish Metadata Is Not the Same as Agent Stopping
9.1 What finishReason tells you
The OCI Generic Chat response includes a finishReason field for a response choice.
It describes why the model stopped generating tokens. The documented response structure describes conditions such as reaching a natural stopping point, encountering a supplied stop sequence or reaching the configured maximum token length.
For Generic Chat, the SDK represents the finish reason as a string. Therefore, do not assume that every model, provider-specific API format or runtime uses an identical fixed set of literal values.
Most importantly, this metadata describes the model-generation event. It does not independently establish that a tool ran, an integration succeeded or the user's business request was completed.
Kid-friendly analogy
A school bell tells students that a lesson period has ended. It does not prove that every student completed the exercise or that the teacher checked the answers. The teacher still needs to inspect the work.
In this OCI AI integration, this means: finishReason reports a model-generation stopping condition. The OIC pattern's executable logic must still determine whether to dispatch a tool, continue the loop, return a response or exit.
9.2 OIC's iteration limit is a separate control
Oracle documents the Max iterations setting in the agentic thinking-pattern configuration.
It limits the reasoning/action steps an agent can take before providing a final answer or exiting. Oracle describes this setting as a protection against uncontrolled or infinite loops.
This is not the same as finishReason.
| Control or metadata | What it governs | What it does not prove |
|---|---|---|
finishReason |
Why model token generation stopped for a response choice. | That the agent task or business process succeeded. |
Max iterations |
The configured limit for reasoning/action steps in the OIC thinking pattern. | That a required integration ran or that its result was correct. |
| Runtime branch condition | The executable decision about what happens next. | That the model output was factually reliable. |
| Business completion check | Whether the requested business outcome has sufficient verified evidence. | That the model or runtime reached a particular stopping state. |
9.3 Inspect the executable stopping decision
Oracle documents that the selected thinking pattern is implemented through an integration. When the OCI-specific pattern is saved, Oracle Integration creates the system-generated integration named ReAct Pattern Intg for OCI GenAI.
The documentation identifies this system-generated integration as part of the pattern implementation. It should not be treated as an ordinary integration that needs to be edited to configure the model or the pattern.
For an architecture review, inspect an exported copy of the generated integration rather than modifying the active system-generated artifact.
The relevant evidence includes:
- How the response's structured tool-call collection is detected.
- How the selected function name is resolved to a registered integration.
- How returned arguments are parsed and mapped to integration inputs.
- How the integration result is correlated with the original tool call.
- How the iteration counter is updated and compared with its configured limit.
- Which branch handles text-only output, invalid arguments, an unavailable tool or an integration failure.
- Whether and how
finishReasonparticipates in the executable decision.
Artifact-specific status: The generated OIC integration export needed to establish these exact branches was not available for independent inspection. Consequently, the precise condition that determines whether this particular integration continues, dispatches a tool or exits remains unverified because no generated export or correlated execution evidence was supplied.
Do not infer that OIC branches on finishReason merely because that field exists in the OCI response schema.
The engineering lesson is that a model-generation event, an agent-runtime loop decision and a successful business outcome represent different state transitions. A reliable design observes and verifies each separately.
10. Tests, Evidence and Troubleshooting
10.1 Run a request/response inspection exercise
For a configured and active agent, Oracle’s Run and Test the AI Agent documents this sequence:
- Select Projects, open the project and select AI Agents.
- In the agents section, select the agent’s Actions → Run.
- On Test Agent, enter the synthetic PO question and click Send prompt to agent.
- Inspect the displayed System, User, Tool and Assistant actions. Retain the available agent instance and conversation identifiers for correlation.
- Go Back, select Observe and inspect Integrations. Check the lookup execution and any errors.
- For an errored run, Oracle documents opening the Errored count and then Instances → View Details.
Oracle illustrates the controls with an expense agent. Use your PO agent and lookup names; do not expect the expense example’s integration names. Displayed agent actions do not automatically expose the exact outbound HTTP body.
Acceptance criteria: The table below specifies desired checks, not guarantees about built-in runtime validation. Malformed arguments, mismatched call IDs and controlled native parameter changes may require a separate test harness; the OIC chat UI is not assumed to expose those injection controls.
Use a redacted request and response from an approved test environment, or use the illustrative structures in this article to perform a schema-reading exercise.
The purpose is to verify the interpretation of the data and runtime control flow, not to certify model quality.
| Case | Expected behaviour | Evidence to inspect |
|---|---|---|
| Current PO status request | An appropriate tool request is returned, validated, executed and correlated with its result. | Tool name, arguments, call ID, integration tracking and returned PO status. |
| General question that does not require live data | The model may respond with text without requesting a tool. | Assistant content and absence of a structured tool-call entry. |
| Unknown purchase order | The integration returns a distinguishable not-found result; the assistant must not invent a status. | Validated input, integration response and final answer. |
| Invalid or unexpected argument | The receiving runtime or integration rejects the input before an unsafe request is sent. | Parsed JSON, validation result and absence of an unintended target call. |
| Tool response ID mismatch | The result must not be associated with the wrong tool call. | Assistant call ID compared with tool result toolCallId. |
| Output reaches a generation limit | The response is handled according to its generation metadata and runtime policy, not silently treated as a complete business answer. | finishReason, response content, runtime branch and business completion check. |
Compare native requests with and without optional temperature |
In a native API test harness, verify the explicit request values and the selected model’s support. This is not an instruction to change an undocumented OIC input. | Redacted native requests and the selected model’s documented parameter support. |
| Multiple tool calls in one response | Calls are handled only if the selected model, API contract and actual runtime implementation support the returned structure and dispatch behaviour. | Number of calls, identifiers, dispatch branches and integration executions. |
Execution status: These are prescribed inspection tests, not tests executed against a live tenant. No OIC test run or OCI model invocation was supplied as evidence.
10.2 Troubleshoot by the layer that failed
| Symptom | Possible layer | Targeted check |
|---|---|---|
| Model answers without using a required business lookup. | Request context, tool definition or model capability. | Verify that the tool was available, its Identifier and description were configured, relevant inputs were Visible and the selected model/API format supports the expected function-calling behaviour. |
| Tool call contains malformed JSON. | Model-generated arguments. | Inspect the raw argument string, parse it safely and reject invalid or unexpected properties before dispatch. |
| The model names an unavailable tool. | Tool metadata or runtime resolution. | Compare the returned name with registered tool metadata and the actual runtime resolution logic. |
| Tool result is attached to the wrong call. | Correlation handling. | Compare the original function-call identifier with the returned toolCallId. |
A native request changes temperature, but the answer appears similar. |
Request configuration or sampling behavior. | Verify the explicit native request and model support. Similar answers do not prove that a parameter was ignored; low temperature is not a determinism guarantee. |
| Agent exits even though the user request is unresolved. | Runtime stopping branch or iteration limit. | Inspect tool-call detection, finish metadata handling, iteration updates and exit branches in the generated integration. |
When inspecting request and response evidence, protect business data. Avoid logging secrets, raw credentials or unnecessary personal information. Use synthetic purchase orders and redact request payloads before sharing traces.
11. Completion Checklist
The learning outcome is complete when you can explain and verify the following points:
- The selected model receives a request context; it is not given automatic access to every OIC resource.
- OIC tool registration distinguishes Name, Identifier, Description, Guidelines and Visible parameters.
- Tool registration has REST trigger, OAuth, JSON payload, project and activation prerequisites.
- The OCI-specific pattern uses its documented
OCIGenAI_Propertieslookup configuration. - Messages carry instructions, user input and relevant conversation observations.
- A tool definition describes a capability the model may request.
- A structured function call contains a function name, arguments and a call identifier; it is not itself an integration execution.
- Function-call arguments are validated before dispatch.
- The tool result is correlated with the original call and can become part of a subsequent model context.
- Configured settings, schema inputs, mapper assignments and serialized request fields are verified separately.
- The native OCI Chat API, Chat Completions API and Responses API are treated as separate contracts.
finishReason, the OIC iteration limit, executable stopping logic and business completion are treated as different concepts.
Outstanding implementation evidence: Two OIC-specific questions remain unresolved without the system-generated ReAct integration export:
- Which outbound API contract and effective generation settings the generated integration uses in this particular environment.
- The exact branches that detect tool calls, dispatch registered integrations, process tool results and terminate or continue the ReAct loop.
There is also a model-compatibility documentation discrepancy: Oracle's general supported-model page lists Google Gemini alongside OpenAI and xAI for OCI GenAI patterns, while the dedicated ReAct for OCI GenAI setup page explicitly lists OpenAI and xAI. Confirm the selected model's current compatibility and regional availability before implementing it.
These are deliberately marked as evidence gaps rather than presented as verified implementation facts.
12. Five Useful FAQs
1. Does the LLM execute an OIC integration when it returns a tool call?
No. A tool call is a structured request identifying a capability and its arguments. The OIC agent runtime must resolve and dispatch the registered integration. Only integration execution evidence can establish that the operation actually ran.
2. Is the OIC tool Name the same as the function name sent to the LLM?
Do not assume that. Oracle's registration documentation distinguishes Name from Identifier. Name is not sent to the LLM, while Identifier is sent as tool metadata. The precise translation of that metadata into an OCI API function definition must be confirmed from the actual generated pattern implementation.
3. Does a schema input prove that a model setting was applied?
No. A schema establishes a declared interface, not the effective value in a service request. Public documentation establishes which settings are supported; design-time value flow and runtime request evidence establish what a particular implementation uses. The native API field is temperature; the OCI-specific OIC setup page does not establish a public temperature field for that recipe.
4. Does a normal finishReason mean that the agent completed the task?
No. It describes why model generation stopped. The OIC runtime has separate tool-dispatch and stopping logic, and the business workflow needs its own completion check. A generated answer can still be incomplete or unsupported by actual business data.
5. Can every OCI GenAI model return the same tool-call structure?
No. The supported request format, model and region matter. OCI documents Generic, Cohere and Cohere V2 Chat formats with different message and tool structures. Validate the selected model's current capabilities and inspect the API format used by the actual implementation.
13. Official Oracle References
The following Oracle documentation was inspected for the OIC product behaviour and OCI request/response contracts discussed in this article.
-
Oracle Integration 3 — Add the ReAct for OCI GenAI Agentic AI Pattern.
OCI-specific pattern creation, Model type, Max iterations, Guidelines, generated integration and the
OCIGenAI_Propertieslookup. - Oracle Integration 3 — Configure the Agentic AI Thinking Pattern. Pattern recipes, ReAct and Plan variants, Max iterations, guidelines and the generic pattern implementation.
- Oracle Integration 3 — Supported Large Language Models. Documented model-provider compatibility for the OIC pattern families.
- Oracle Integration 3 — Register an Integration as an Agentic AI Tool. REST trigger prerequisites, Name, Identifier, description, guidelines and parameter configuration.
- Oracle Integration 3 — OCI AI Services Prerequisites. Identity domains, dynamic groups and service policies that allow the OIC instance to access OCI AI services.
- Oracle Integration 3 — Build the AI Agent. Overview of the documented agent-building process and prerequisites.
- OCI Generative AI Inference SDK Reference. ChatDetails, serving modes, Generic Chat request and response models, function definitions, function calls, tool messages, message roles and finish metadata.
- OCI Generative AI Inference — Chat SDK Example. Oracle SDK example for invoking the native Chat operation.
- OCI — Request Signatures. OCI request-signing scheme and required signed headers.
- Oracle — Migrate to the Chat Models. Native OCI Chat endpoint example and request envelope. Consult the current SDK reference for the current request and response model schemas.
- OCI — Chat Completions API. The separate OpenAI-compatible Chat Completions endpoint and its relationship to the Responses API.
- OCI — Responses API. The separate OpenAI-compatible interface for agentic workflows, supported tools, conversation history and background responses.
- OCI — Generative AI Models by Region. Current model availability by OCI region and serving mode.
- OCI Generative AI Inference — ChatDetails. Native model contract; Python property names correspond to the camelCase wire names verified in the Go reference.
- OCI Generative AI Inference — OnDemandServingMode. Native model contract; Python property names correspond to the camelCase wire names verified in the Go reference.
- OCI Generative AI Inference — GenericChatRequest. Native model contract; Python property names correspond to the camelCase wire names verified in the Go reference.
- OCI Generative AI Inference — FunctionDefinition. Native model contract; Python property names correspond to the camelCase wire names verified in the Go reference.
- OCI Generative AI Inference — FunctionCall. Native model contract; Python property names correspond to the camelCase wire names verified in the Go reference.
- OCI Generative AI Inference — AssistantMessage. Native model contract; Python property names correspond to the camelCase wire names verified in the Go reference.
- OCI Generative AI Inference — ToolMessage. Native model contract; Python property names correspond to the camelCase wire names verified in the Go reference.
- OCI Generative AI Inference — GenericChatResponse. Native model contract; Python property names correspond to the camelCase wire names verified in the Go reference.
- OCI Generative AI Inference — ChatChoice. Native model contract; Python property names correspond to the camelCase wire names verified in the Go reference.
- Oracle Integration 3 — Add and Configure the AI Agent. Documented agent configuration or testing controls used in this article.
- Oracle Integration 3 — Run and Test the AI Agent. Documented agent configuration or testing controls used in this article.
Documentation review date: 7 November 2026. The references establish public documentation behaviour. They do not establish the active OIC release, tenant feature availability, selected model, regional support or generated integration implementation in a particular environment.
Link and execution limitations: The supplied illustration URLs were inaccessible to the browsing tool and are retained without a broken-link finding or visual-verification claim. No live OIC run, generated export or raw request was available. The public source pages establish documented behavior, not tenant execution.
14. Finally — Summary
An OIC ReAct agent uses an LLM to help determine the next action by supplying context about the user's request and the available business capabilities. The model can generate an ordinary assistant response or a structured function request. These represent different runtime outcomes and must not be confused with integration execution.
A function request identifies the requested capability and its arguments. The runtime must process that request and invoke the appropriate registered integration. The resulting tool output is correlated with the original call and can become part of a subsequent model request.
For reliable runtime analysis, trace information through the request, response, dispatch and tool-result stages. Treat schema declarations, mapper assignments and serialized payloads as separate evidence. Also remember that finishReason describes model generation, whereas the OIC iteration limit and executable runtime branches govern the agent's workflow.
For the OCI-specific ReAct pattern, also distinguish the documented OIC configuration from the native OCI API contract. Oracle documents the pattern recipe, the generated integration, and the OCIGenAI_Properties lookup. The exact internal payload mapping and control-flow branches still require inspection of the generated integration.
Finally, never assume that a documented OCI API structure is automatically the internal structure of an OIC-generated integration. Inspect the actual artifact when making implementation-specific claims.
That is how an apparently simple model response becomes a verifiable next runtime decision.

Comments
Post a Comment