The agent step and tool calling

The agent step runs a model and its tools in a loop as one step of a route: the model asks for tools, Cameleer runs them through the ai-tool envelope (argument checks, deduplication, approvals, timeouts, audit), and the loop stops on the model's answer or a limit. The same loop runs inside every model component with tags. Recorded model responses let cameleer test check an agent route without a model.

Cargo feature: ai for the tools; the model components are in saas (openai, llm, anthropic, gemini) and cloud (azure-openai, aws-bedrock, google-vertexai) · Apache Camel: no agent EIP; the tags options mirror Camel 4.23's openai/llm component

The agent step

- route:
    from:
      uri: direct:support
      steps:
        - agent:
            model: "openai:chat-completion?model=gpt-5.4-mini"
            tools: support                 # ai-tool routes with this tag
            systemMessage: You are a support agent. Look orders up before you refund them.
            maxTurns: 8
            maxTokens: 40000
            deadline: 60s
            memory: memory                 # keep conversations (CamelAiConversationId)
            onApproval: direct:approvals   # told when a tool call waits for approval

The body is the user's message: text, or a list of {"role", "content"} messages. After the step the body is the model's answer.

In the Rust DSL:

use cameleer_core::processor::agent::AgentDefinition;
b.from("direct:support").agent(
    AgentDefinition::new("openai:chat-completion?model=gpt-5.4-mini").tools("support").memory("memory").max_turns(8),
);

What the loop guarantees

• Every tool call goes through the ai-tool envelope: the arguments are validated, a retried call with the same call id runs once, destructive calls wait for approval, slow calls are cancelled, and each call is audited.
• Every tool call gets a result in the conversation, including calls to tools that don't exist and calls that failed. Every provider requires one result per call id.
• The loop stops on the model's answer, maxTurns, maxTokens, deadline, the same call failing three times, or a rejected approval.

Approvals pause the conversation

When a tool call needs approval (a destructiveHint tool, or an approval rule on the ai-tool), the agent stops with approval-required. onApproval receives the handle (CamelAiApprovalHandle), the tool's name and its arguments. With memory, the conversation waits: calling the agent again answers approval-pending until a person decides. Once they do, the next call resumes the conversation with the tool's result.

A person approves or rejects with an ai-tool producer:

- route:
    from:
      uri: platform-http:/approvals/approve
      steps:
        - setHeader:
            name: CamelAiToolApprovalHandle
            simple: "${header.handle}"
        - setHeader:
            name: CamelAiToolApprovedBy
            simple: "${header.user}"
        - to: ai-tool:refund?operation=approve    # operation=deny rejects (the body is the reason)

Tool calling in the model components

Every model component takes the same tool options, Camel's names on openai/llm. With tags it offers those tools and runs the loop itself. The body is the answer, as with the agent step, but nothing is remembered between calls.

- route:
    from:
      uri: direct:ask
      steps:
        - to: "aws-bedrock://claude?modelId=anthropic.claude-sonnet-4-5-v1:0&operation=converse&tags=support&maxToolIterations=10"

Testing without a model

Record a conversation once (record: file:support.jsonl), or write the responses by hand: one JSON line per model response. Then replay it in a test with cameleer test:

# support-agent.test.yaml
- test:
    name: a refund waits for approval, runs once, and the agent answers
    routes: [support-agent.camel.yaml]
    properties:
      agent.replay: file:refund.jsonl     # the route has  replay: "{{agent.replay:}}"
      payments.endpoint: mock:payments
    steps:
      - send:
          to: direct:support
          body: My order A1 arrived broken. Please refund it.
          headers: {CamelAiConversationId: case-1}
        expect:
          headers: {CamelAiAgentStopReason: approval-required}
          mocks: {"mock:payments": 0}
      - approve: {tool: refund, by: alice}
        expect: {mocks: {"mock:payments": 1}}
      - send:
          to: direct:support
          body: continue
          headers: {CamelAiConversationId: case-1}
        expect:
          body: Order A1 arrived damaged, so I refunded it in full.
      - callTool: {name: refund, arguments: {orderId: B7}, callId: retry-1, approvedBy: alice}
      - callTool: {name: refund, arguments: {orderId: B7}, callId: retry-1, approvedBy: alice}
        expect: {duplicate: true, mocks: {"mock:payments": 2}}

cameleer test support-agent.test.yaml

Steps are send (to, body, headers), callTool (name, arguments, callId, conversation, principal, approvedBy), approve / deny (tool, by, reason) and compensate (conversation). expect checks body, bodyContains, headers, error, status, isError, duplicate and mocks (messages per mock endpoint). Test files end in .test.yaml, so cameleer run and cameleer validate skip them. file: paths are relative to the test file. The command exits 1 when a test fails. The complete example is examples/agents/support-agent.camel.yaml with its test.

Not supported yet

• Streaming with Ollama's native API (apiFormat=ollama); stream from Ollama through its OpenAI-compatible /v1 API (the default format) instead.
• Streaming in the tool loop of azure-openai, aws-bedrock, google-vertexai, gemini and anthropic: with tags they wait for each complete answer. openai/llm stream every turn with streaming=true.
• Server-side conversation state of the Responses API (previous_response_id): Cameleer sends the whole conversation each turn.

Related

• ai-tool: what a tool is and the envelope every call goes through
• MCP server: the same tools for MCP clients
• MCP client: tools of other MCP servers in the loop
• Model providers and call optimizations
• Cameleer for AI agents

Found a problem?

If something on this page doesn't match what Cameleer does, please open an issue, or fork the repository, fix it, add a test, run cargo test --workspace and open a pull request.