Durable execution.
No replay.

agent = Agent("openai:gpt-5.2", instructions="You help customers with their orders.")
# @agent.tool find_order, refund_order, email_customer: unchanged

flow = pydantic_ai_session_flow(
    agent,
    flow_type="OrderAgent",
    tool_policies={
        "find_order": ToolPolicy(ToolEffect.READ),
        "refund_order": ToolPolicy(ToolEffect.IDEMPOTENT_WRITE, requires_approval=True),
        "email_customer": ToolPolicy(ToolEffect.NON_IDEMPOTENT_WRITE),
    },
)

def build_support_agent():
    return create_agent(
        init_chat_model("openai:gpt-5-mini"),
        tools=[search_orders, refund_order],
        system_prompt="You help customers with their orders.",
        middleware=[DurableToolCallMiddleware()],
    )

support_agent = langchain_agent_session_flow(
    build_support_agent,
    flow_type="SupportAgent",
    tool_policies={
        "search_orders": ToolPolicy(ToolEffect.READ),
        "refund_order": ToolPolicy(ToolEffect.IDEMPOTENT_WRITE, requires_approval=True),
    },
)

agent = Agent(
    name="Support",
    instructions="Help the customer with their orders.",
    tools=[search_orders, create_refund],
)
flow = openai_agents_session_flow(
    agent,
    flow_type="SupportAgent",
    tool_policies={
        "search_orders": ToolPolicy(ToolEffect.READ),
        "create_refund": ToolPolicy(ToolEffect.NON_IDEMPOTENT_WRITE),
    },
)

export const supportAgentFlow = createVercelAiAgentSessionFlow(
  {
    model: openai("gpt-5"),
    instructions: "You help customers with their orders. Ask before refunding.",
    tools: { get_order, refund_order }, // tool({ ... }) as usual
    toolPolicies: {
      get_order: { effect: "read" },
      refund_order: { effect: "idempotent_write", requiresApproval: true },
    },
  },
  "SupportAgent",
  { interruptDeadlineMs: 24 * 60 * 60 * 1000 },
);

const supportAgent = new Agent({
  id: "support",
  name: "Support",
  instructions: "Help customers with their orders. Refund only when asked.",
  model: "openai/gpt-5",
  tools: { search_orders: searchOrders, refund_order: refundOrder },
});

const flow = createMastraAgentSessionFlow(supportAgent, "SupportAgent", {
  toolPolicies: { refund_order: { effect: "idempotent_write", requiresApproval: true } },
  interruptDeadlineMs: 24 * 60 * 60 * 1000,
});

agent = LlmAgent(
    name="support",
    model="gemini-2.5-flash",
    instruction="Help customers with their orders.",
    tools=[search_orders, refund_order, send_email],
)
flow = adk_agent_session_flow(
    agent,
    flow_type="SupportAgent",
    tool_policies={
        "search_orders": ToolPolicy(ToolEffect.READ),
        "refund_order": ToolPolicy(ToolEffect.IDEMPOTENT_WRITE, requires_approval=True),
        # send_email has no policy: unclassified, it runs once after approval.
    },
)

def build_options(context: ClaudeAgentOptionsContext) -> ClaudeAgentOptions:
    return ClaudeAgentOptions(
        model="claude-sonnet-5",
        system_prompt="You resolve order problems.",
        tools=["Read", "Grep", "Bash"],
        cwd=f"/srv/agents/{context.flow_id}",
    )

flow = claude_agent_session_flow(
    build_options,
    [lookup_order, create_refund],
    flow_type="SupportAgent",
    tool_policies={"create_refund": ToolPolicy(ToolEffect.NON_IDEMPOTENT_WRITE)},
)

func (CallModel) GetStepOptions() *dex.StepOptions {
	return &dex.StepOptions{
		ExecuteMethodTimeout: 2 * time.Minute,
		HeartbeatTimeout:     2 * time.Minute,
		ExecuteDurability:    dex.StepDurabilitySync,
		ExecuteRetry:         &dex.RetryPolicy{MaximumAttempts: 3, MaximumInterval: 5 * time.Second},
		ExecuteFailure:       dex.ProceedToOnExecuteFailure(RecordModelFailure{}, recoveryStepOptions),
	}
}