agent-contracts-runtime/dist/adapters/openai-agents-sdk.d.ts

Runtime bridge for executing agent-contracts workflows on Agent SDKs

import { S as SdkAdapter, C as CacheConfig, A as AdapterSendOptions, a as AgentExecutionRequest, M as MemoryRef } from '../task-runner-Bo37lS9q.js';
import { G as GuardrailHooks } from '../guardrail-hooks-C8G5NGsj.js';
import 'zod';

/**
 * OpenAI Agents SDK Adapter — implements SdkAdapter for @openai/agents
 *
 * Uses the `run()` function (or `Runner`) from the OpenAI Agents SDK to execute
 * an Agent with instructions derived from the contract prompt.
 *
 * Supports:
 * - send()          — create a fresh Agent + run() and return finalOutput
 * - followUp()      — resume the same conversation via previousResponseId
 * - sendExecution() — rich path using full contract context
 *
 * The SDK's `run()` returns a RunResult with `finalOutput` (the model's final
 * text output) and `lastResponseId` for continuation.
 *
 * GuardrailHooks are mapped to the SDK's InputGuardrail system.
 */

type RunResult = {
    finalOutput?: string | unknown;
    lastResponseId?: string;
    newItems?: Array<{
        type: string;
        rawItem?: {
            type?: string;
            content?: unknown;
        };
        [key: string]: unknown;
    }>;
    state?: unknown;
};
type AgentOptions = {
    name: string;
    model?: string;
    instructions: string | ((ctx: unknown) => string);
    tools?: unknown[];
    inputGuardrails?: unknown[];
    outputType?: unknown;
    [key: string]: unknown;
};
type AgentInstance = AgentOptions & {
    [key: string]: unknown;
};
type RunOptions = {
    maxTurns?: number | null;
    signal?: AbortSignal;
    previousResponseId?: string;
    stream?: boolean;
    context?: unknown;
    [key: string]: unknown;
};
type AgentConstructor = new (options: AgentOptions) => AgentInstance;
type RunFn = (agent: AgentInstance, input: string | unknown[], options?: RunOptions) => Promise<RunResult>;
type StreamedRunResult = RunResult & {
    streamEvents(): AsyncIterable<RunStreamEvent>;
};
type RunStreamEvent = {
    type: string;
    name?: string;
    item?: {
        type: string;
        toolName?: string;
        agent?: {
            name?: string;
        };
        [key: string]: unknown;
    };
    [key: string]: unknown;
};
type StreamRunFn = (agent: AgentInstance, input: string | unknown[], options?: RunOptions) => Promise<StreamedRunResult>;
interface OpenAIAgentsSdkAdapterConfig {
    /** Model identifier (e.g. "gpt-4.1", "gpt-5.5"). Uses SDK default if omitted. */
    model?: string;
    /** Maximum conversation turns per run. Defaults to 10 (SDK default). */
    maxTurns?: number;
    /** Runtime guardrail hooks enforced via InputGuardrail. */
    guardrailHooks?: GuardrailHooks;
    /** Additional tools to pass to the Agent. */
    tools?: unknown[];
    /** Agent name prefix. Defaults to "contract-agent". */
    agentName?: string;
    /** AbortSignal for cancellation. */
    signal?: AbortSignal;
    /** Prompt caching configuration. Enabled by default. */
    cacheConfig?: CacheConfig;
}
declare class OpenAIAgentsSdkAdapter implements SdkAdapter {
    private model;
    private maxTurns;
    private guardrailHooks;
    private tools;
    private agentName;
    private signal;
    private cacheConfig;
    private lastResponseId;
    private lastAgent;
    private lastMemoryRef;
    private AgentClass;
    private runFn;
    private streamRunFn;
    constructor(config?: OpenAIAgentsSdkAdapterConfig);
    private resolveSdk;
    private createAgent;
    private buildRunOptions;
    private extractOutput;
    private runWithProgress;
    send(prompt: string, options: AdapterSendOptions): Promise<string>;
    followUp(message: string): Promise<string>;
    sendExecution(request: AgentExecutionRequest): Promise<string>;
    getLastMemoryRef(): MemoryRef | null;
    isCompatible(compat: string): boolean;
    /**
     * Inject custom Agent constructor and run function for testing.
     * Bypasses the dynamic import of @openai/agents.
     */
    static withRunFn(AgentClass: AgentConstructor, runFn: RunFn, config?: OpenAIAgentsSdkAdapterConfig, streamRunFn?: StreamRunFn): OpenAIAgentsSdkAdapter;
}

export { OpenAIAgentsSdkAdapter, type OpenAIAgentsSdkAdapterConfig };