@asap-protocol/openai-agents 2.3.1

package/README.md

@@ -0,0 +1,53 @@
+# `@asap-protocol/openai-agents`
+
+## ⚠️ This is **not** `@asap-protocol/client/adapters/openai`
+
+[`@asap-protocol/client/adapters/openai`](https://github.com/adriannoes/asap-protocol/tree/main/packages/typescript/client/src/adapters/openai.ts) exposes **`asapToolsForOpenAI`**, producing **static `ChatCompletionTool[]`** for the **OpenAI Chat Completions API** (`openai` npm package, no Agents runtime).
+
+**`@asap-protocol/openai-agents`** integrates with the **`@openai/agents` SDK** (`Agent`, `tool()`, handoffs, `run()`). Different consumer and lifecycle — **both packages coexist**.
+
+## Overview
+
+Maps ASAP **capabilities** to OpenAI Agents **`tool()`** definitions (using **`executeCapability`** from **`@asap-protocol/client`**), optionally wraps an **`Agent`** intended as a **handoff** target against an ASAP gateway, and bridges ASAP **`task_stream`** payloads into incremental **text deltas**.
+
+## Peer dependencies
+
+| Package | Range |
+|---------|-------|
+| `@asap-protocol/client` | `^2.3.0` |
+| `@openai/agents` | `^0.11.0` (patch drift tolerated; CI pins **`0.11.4`** + **`latest`**) |
+| `zod` | `^4.1.8` (aligned with `@openai/agents`; Zod 3 is not supported) |
+
+Node **≥ 18**.
+
+!!! warning "Pre-1.0 `@openai/agents` API drift"
+
+    **`@openai/agents` is pre-1.0.** Minor/patch releases may change `Agent` constructor options, `tool()` parameter shapes, or default tool error handling. Pin your dependency and re-run tests after upgrades; CI exercises **`latest`** and **`0.11.4`**.
+
+## Usage
+
+See [`docs/integrations/openai-agents.md`](../../../docs/integrations/openai-agents.md) and [`apps/example-openai-agents/`](../../../apps/example-openai-agents/).
+
+```typescript
+import { Agent, run, setDefaultOpenAIKey } from "@openai/agents";
+import type { AsapExecuteClient } from "@asap-protocol/client";
+import { asapToolsForOpenAIAgents } from "@asap-protocol/openai-agents";
+
+declare const client: AsapExecuteClient;
+
+setDefaultOpenAIKey(process.env.OPENAI_API_KEY ?? "");
+
+const tools = await asapToolsForOpenAIAgents(client);
+const agent = new Agent({
+  name: "demo",
+  instructions: "Use ASAP tools when helpful.",
+  model: "gpt-4o-mini",
+  tools: [...tools],
+});
+
+await run(agent, "Echo hello via ASAP.");
+```
+
+## Status
+
+Pre-release **`0.0.0`** workspace package until publish workflow promotes a semver tag.

package/dist/commonjs/asap-as-remote-agent.d.ts

@@ -0,0 +1,44 @@
+import { Agent, type AgentInputItem } from "@openai/agents";
+import type { AsapExecuteClient } from "@asap-protocol/client/adapters/shared";
+import { type AsapToolsForOpenAIAgentsOptions } from "./asap-to-openai-tool.js";
+export type AsapRemoteAgentMode = "delegated" | "autonomous";
+/** Mutable bag carried through {@link RunContext} when using {@link asapAsRemoteAgent}. */
+export interface AsapRemoteRunContext {
+    /** Latest draft ASAP envelope captured when this agent starts (including after an SDK handoff). */
+    lastAsapHandoffEnvelope?: Record<string, unknown>;
+}
+export interface AsapAsRemoteAgentOptions {
+    readonly mode?: AsapRemoteAgentMode;
+    readonly name?: string;
+    readonly instructions?: string | undefined;
+    readonly handoffDescription?: string;
+    readonly model?: string;
+    readonly toolsOptions?: AsapToolsForOpenAIAgentsOptions;
+    /**
+     * Agent JWT scoped to `providerUrl` when it differs from `client.provider`.
+     * Required for cross-provider handoffs when `client.agentJwt` is set.
+     */
+    readonly remoteAgentJwt?: string;
+}
+/**
+ * Returns whether two provider URLs refer to the same ASAP host path (origin + pathname).
+ */
+export declare function sameProviderOrigin(a: URL, b: URL): boolean;
+/**
+ * Draft `task.request`-style envelope metadata used when delegating from OpenAI Agents handoffs to ASAP.
+ *
+ * The gateway still performs authorization and routing; this object mirrors how adapters attach agent mode.
+ */
+export declare function draftTaskRequestEnvelopeForRemoteAgent(params: {
+    readonly mode: AsapRemoteAgentMode;
+    readonly providerUrl: URL;
+    readonly turnInput?: string | AgentInputItem[];
+}): Record<string, unknown>;
+/**
+ * Returns an OpenAI Agents {@link Agent} backed by ASAP capability tools on `providerUrl`.
+ *
+ * Subscribes to `agent_start` so {@link AsapRemoteRunContext.lastAsapHandoffEnvelope} captures draft envelope metadata
+ * and POSTs a real `task.request` via JSON-RPC `asap.send` whenever this agent begins a turn—including after an SDK handoff.
+ */
+export declare function asapAsRemoteAgent(client: AsapExecuteClient, providerUrl: string | URL, options?: AsapAsRemoteAgentOptions): Promise<Agent<AsapRemoteRunContext>>;
+//# sourceMappingURL=asap-as-remote-agent.d.ts.map

package/dist/commonjs/asap-as-remote-agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asap-as-remote-agent.d.ts","sourceRoot":"","sources":["../../src/asap-as-remote-agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,KAAK,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAE5D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uCAAuC,CAAC;AAE/E,OAAO,EACL,KAAK,+BAA+B,EAErC,MAAM,0BAA0B,CAAC;AAGlC,MAAM,MAAM,mBAAmB,GAAG,WAAW,GAAG,YAAY,CAAC;AAE7D,2FAA2F;AAC3F,MAAM,WAAW,oBAAoB;IACnC,mGAAmG;IACnG,uBAAuB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnD;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,IAAI,CAAC,EAAE,mBAAmB,CAAC;IACpC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3C,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,YAAY,CAAC,EAAE,+BAA+B,CAAC;IACxD;;;OAGG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC;AAgBD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,OAAO,CAE1D;AAED;;;;GAIG;AACH,wBAAgB,sCAAsC,CAAC,MAAM,EAAE;IAC7D,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;IACnC,QAAQ,CAAC,WAAW,EAAE,GAAG,CAAC;IAC1B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,cAAc,EAAE,CAAC;CAChD,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAmB1B;AAgDD;;;;;GAKG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,iBAAiB,EACzB,WAAW,EAAE,MAAM,GAAG,GAAG,EACzB,OAAO,CAAC,EAAE,wBAAwB,GACjC,OAAO,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC,CAgCtC"}

package/dist/commonjs/asap-as-remote-agent.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sameProviderOrigin = sameProviderOrigin;
+exports.draftTaskRequestEnvelopeForRemoteAgent = draftTaskRequestEnvelopeForRemoteAgent;
+exports.asapAsRemoteAgent = asapAsRemoteAgent;
+const agents_1 = require("@openai/agents");
+const asap_to_openai_tool_js_1 = require("./asap-to-openai-tool.js");
+const send_asap_envelope_js_1 = require("./send-asap-envelope.js");
+function serializeTurnInput(turnInput) {
+    if (turnInput === undefined) {
+        return "";
+    }
+    if (typeof turnInput === "string") {
+        return turnInput;
+    }
+    try {
+        return JSON.stringify(turnInput);
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * Returns whether two provider URLs refer to the same ASAP host path (origin + pathname).
+ */
+function sameProviderOrigin(a, b) {
+    return a.origin === b.origin && a.pathname === b.pathname;
+}
+/**
+ * Draft `task.request`-style envelope metadata used when delegating from OpenAI Agents handoffs to ASAP.
+ *
+ * The gateway still performs authorization and routing; this object mirrors how adapters attach agent mode.
+ */
+function draftTaskRequestEnvelopeForRemoteAgent(params) {
+    const delegatedInput = serializeTurnInput(params.turnInput);
+    return {
+        asap_version: "2.2",
+        sender: "urn:asap:agent:openai-agents-adapter",
+        recipient: params.providerUrl.href,
+        payload_type: "task.request",
+        payload: {
+            conversation_id: "openai-agents-handoff",
+            skill_id: "asap-remote-handoff",
+            input: {
+                query: delegatedInput,
+                asap_agent_mode: params.mode,
+            },
+        },
+        extensions: {
+            asap_agent_mode: params.mode,
+        },
+    };
+}
+function defaultInstructions(mode, capabilities) {
+    const list = capabilities.length > 0 ? capabilities.join(", ") : "(none configured)";
+    return [
+        "You are an ASAP-backed specialist agent invoked via OpenAI Agents SDK handoffs.",
+        `Operate in ${mode} mode with respect to host policy.`,
+        `Use the ASAP capability tools wired for this agent (deterministic keys). Capability URNs: ${list}.`,
+        "Pass structured JSON arguments that satisfy each capability schema.",
+    ].join(" ");
+}
+function resolveProvider(providerUrl) {
+    return typeof providerUrl === "string" ? new URL(providerUrl) : providerUrl;
+}
+function resolveHandoffJwt(client, providerUrl, options) {
+    if (options?.remoteAgentJwt !== undefined) {
+        return options.remoteAgentJwt;
+    }
+    if (client.agentJwt !== undefined && !sameProviderOrigin(client.provider, providerUrl)) {
+        throw new Error(`client.agentJwt is scoped to ${client.provider.href}; pass remoteAgentJwt when providerUrl (${providerUrl.href}) differs`);
+    }
+    return client.agentJwt;
+}
+function buildMergedClient(client, resolvedProvider, handoffJwt) {
+    const merged = {
+        ...client,
+        provider: resolvedProvider,
+    };
+    if (handoffJwt !== undefined) {
+        return { ...merged, agentJwt: handoffJwt };
+    }
+    const { agentJwt: _omit, ...withoutJwt } = merged;
+    return withoutJwt;
+}
+/**
+ * Returns an OpenAI Agents {@link Agent} backed by ASAP capability tools on `providerUrl`.
+ *
+ * Subscribes to `agent_start` so {@link AsapRemoteRunContext.lastAsapHandoffEnvelope} captures draft envelope metadata
+ * and POSTs a real `task.request` via JSON-RPC `asap.send` whenever this agent begins a turn—including after an SDK handoff.
+ */
+async function asapAsRemoteAgent(client, providerUrl, options) {
+    const mode = options?.mode ?? "delegated";
+    const resolvedProvider = resolveProvider(providerUrl);
+    const handoffJwt = resolveHandoffJwt(client, resolvedProvider, options);
+    const mergedClient = buildMergedClient(client, resolvedProvider, handoffJwt);
+    const tools = await (0, asap_to_openai_tool_js_1.asapToolsForOpenAIAgents)(mergedClient, options?.toolsOptions);
+    const agent = new agents_1.Agent({
+        name: options?.name ?? `asap-remote-${resolvedProvider.hostname}`,
+        instructions: options?.instructions ?? defaultInstructions(mode, mergedClient.capabilities),
+        handoffDescription: options?.handoffDescription ??
+            `Delegates to ASAP capabilities at ${resolvedProvider.href} (${mode} mode).`,
+        model: options?.model ?? "gpt-4o-mini",
+        tools: [...tools],
+    });
+    agent.on("agent_start", (runContext, _self, turnInput) => {
+        const draft = draftTaskRequestEnvelopeForRemoteAgent({
+            mode,
+            providerUrl: resolvedProvider,
+            turnInput,
+        });
+        runContext.context.lastAsapHandoffEnvelope = draft;
+        void (0, send_asap_envelope_js_1.sendAsapEnvelope)(resolvedProvider, draft, {
+            fetch: mergedClient.fetch,
+            agentJwt: mergedClient.agentJwt,
+        });
+    });
+    return agent;
+}

package/dist/commonjs/asap-to-openai-tool.d.ts

@@ -0,0 +1,34 @@
+import { tool } from "@openai/agents";
+import { type AsapExecuteClient } from "@asap-protocol/client/adapters/shared";
+export interface AsapToolsForOpenAIAgentsOptions {
+    /**
+     * Invoked when the provider returns `403` with `error.code === "capability_not_granted"`.
+     */
+    readonly requestCapability?: (requiredCapability: string) => void | Promise<void>;
+    readonly inputSchemas?: Readonly<Record<string, unknown>>;
+    readonly outputSchemas?: Readonly<Record<string, unknown>>;
+    /**
+     * Called when {@link describeCapability} fails for a capability. The error is rethrown unless
+     * {@link allowPermissiveDescribeFallback} is `true`.
+     */
+    readonly onDescribeError?: (capabilityId: string, error: unknown) => void;
+    /**
+     * When `true`, failed describe calls fall back to generic tool metadata instead of failing
+     * tool construction. Defaults to `false`.
+     */
+    readonly allowPermissiveDescribeFallback?: boolean;
+    /** Passed to {@link describeCapability} and {@link executeCapability} fetch calls. */
+    readonly signal?: AbortSignal;
+}
+/**
+ * Build OpenAI Agents SDK {@link tool} instances for each ASAP capability on the client.
+ *
+ * Uses top-level {@link executeCapability} from `@asap-protocol/client` on each execution path.
+ */
+export declare function asapToolsForOpenAIAgents(client: AsapExecuteClient, options?: AsapToolsForOpenAIAgentsOptions): Promise<readonly ReturnType<typeof tool>[]>;
+/**
+ * Synchronous variant when {@link AsapToolsForOpenAIAgentsOptions.inputSchemas} / `outputSchemas`
+ * are already materialized (skips describe round-trips).
+ */
+export declare function asapToolsForOpenAIAgentsSync(client: AsapExecuteClient, options?: AsapToolsForOpenAIAgentsOptions): readonly ReturnType<typeof tool>[];
+//# sourceMappingURL=asap-to-openai-tool.d.ts.map

package/dist/commonjs/asap-to-openai-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asap-to-openai-tool.d.ts","sourceRoot":"","sources":["../../src/asap-to-openai-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAEtC,OAAO,EAGL,KAAK,iBAAiB,EACvB,MAAM,uCAAuC,CAAC;AAiC/C,MAAM,WAAW,+BAA+B;IAC9C;;OAEG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,CAAC,kBAAkB,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClF,QAAQ,CAAC,YAAY,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC1D,QAAQ,CAAC,aAAa,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC3D;;;OAGG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IAC1E;;;OAGG;IACH,QAAQ,CAAC,+BAA+B,CAAC,EAAE,OAAO,CAAC;IACnD,sFAAsF;IACtF,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;CAC/B;AAuID;;;;GAIG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,iBAAiB,EACzB,OAAO,CAAC,EAAE,+BAA+B,GACxC,OAAO,CAAC,SAAS,UAAU,CAAC,OAAO,IAAI,CAAC,EAAE,CAAC,CA4C7C;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,iBAAiB,EACzB,OAAO,CAAC,EAAE,+BAA+B,GACxC,SAAS,UAAU,CAAC,OAAO,IAAI,CAAC,EAAE,CAepC"}

package/dist/commonjs/asap-to-openai-tool.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asapToolsForOpenAIAgents = asapToolsForOpenAIAgents;
+exports.asapToolsForOpenAIAgentsSync = asapToolsForOpenAIAgentsSync;
+const agents_1 = require("@openai/agents");
+const client_1 = require("@asap-protocol/client");
+const shared_1 = require("@asap-protocol/client/adapters/shared");
+const zod_1 = require("zod");
+const errors_js_1 = require("./errors.js");
+const schema_bridge_js_1 = require("./schema-bridge.js");
+function buildToolParameters(inputJson) {
+    const props = inputJson.properties;
+    const hasProps = inputJson.type === "object" &&
+        typeof props === "object" &&
+        props !== null &&
+        !Array.isArray(props) &&
+        Object.keys(props).length > 0;
+    if (hasProps) {
+        const zSch = (0, schema_bridge_js_1.zodFromJsonSchema)(inputJson);
+        if (zSch instanceof zod_1.z.ZodObject) {
+            return { mode: "zod", schema: zSch.strict() };
+        }
+    }
+    return { mode: "json", schema: inputJson };
+}
+const DESCRIBE_CONCURRENCY = 5;
+async function mapInBatches(items, batchSize, fn) {
+    const results = [];
+    for (let i = 0; i < items.length; i += batchSize) {
+        const batch = items.slice(i, i + batchSize);
+        const batchResults = await Promise.all(batch.map(fn));
+        results.push(...batchResults);
+    }
+    return results;
+}
+function isRecord(x) {
+    return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+function wrapFetchWithCapabilityErrors(base, options) {
+    const impl = base ?? globalThis.fetch;
+    return async (input, init) => {
+        const res = await impl(input, init);
+        if (res.status !== 403) {
+            return res;
+        }
+        const text = await res.clone().text();
+        let parsed;
+        try {
+            parsed = text.length === 0 ? {} : JSON.parse(text);
+        }
+        catch {
+            return new Response(text, { status: res.status, statusText: res.statusText, headers: res.headers });
+        }
+        if (!isRecord(parsed)) {
+            return new Response(text, { status: res.status, statusText: res.statusText, headers: res.headers });
+        }
+        if (parsed.error === "constraint_violated") {
+            return new Response(text, { status: res.status, statusText: res.statusText, headers: res.headers });
+        }
+        const errObj = parsed.error;
+        if (!isRecord(errObj)) {
+            return new Response(text, { status: res.status, statusText: res.statusText, headers: res.headers });
+        }
+        const code = errObj.code;
+        if (code === "capability_not_granted") {
+            const data = isRecord(errObj.data) ? errObj.data : undefined;
+            const required = typeof data?.required_capability === "string" ? data.required_capability : "";
+            const msg = typeof errObj.message === "string" ? errObj.message : undefined;
+            throw new errors_js_1.CapabilityNotGrantedError(required, options?.requestCapability, msg);
+        }
+        if (code === "approval_required") {
+            const msg = typeof errObj.message === "string" ? errObj.message : "Capability execution requires approval";
+            throw new errors_js_1.ApprovalRequiredError(msg, errObj.data);
+        }
+        return new Response(text, { status: res.status, statusText: res.statusText, headers: res.headers });
+    };
+}
+function buildTools(client, fetchFn, describedByCapability, options) {
+    const tools = [];
+    const seenToolNames = new Map();
+    for (const capabilityId of client.capabilities) {
+        const id = (0, shared_1.capabilityToolKey)(capabilityId);
+        const existingCapabilityId = seenToolNames.get(id);
+        if (existingCapabilityId !== undefined && existingCapabilityId !== capabilityId) {
+            throw new Error(`OpenAI Agents tool name collision: "${id}" maps to both "${existingCapabilityId}" and "${capabilityId}". ` +
+                "Use distinct capability identifiers or provide inputSchemas to skip describe.");
+        }
+        seenToolNames.set(id, capabilityId);
+        const described = describedByCapability.get(capabilityId);
+        const inputJson = (0, shared_1.jsonSchemaForCapabilityInput)(options?.inputSchemas?.[capabilityId] ?? described?.input_schema);
+        const built = buildToolParameters(inputJson);
+        const exec = async (input) => {
+            const ctx = isRecord(input) ? input : {};
+            return (0, client_1.executeCapability)(client.provider, capabilityId, ctx, {
+                agentJwt: client.agentJwt,
+                fetch: fetchFn,
+                signal: options?.signal,
+            });
+        };
+        if (built.mode === "zod") {
+            tools.push((0, agents_1.tool)({
+                name: id,
+                description: described?.description ?? `ASAP capability: ${capabilityId}`,
+                parameters: built.schema,
+                strict: true,
+                errorFunction: null,
+                execute: exec,
+            }));
+        }
+        else {
+            tools.push((0, agents_1.tool)({
+                name: id,
+                description: described?.description ?? `ASAP capability: ${capabilityId}`,
+                parameters: built.schema,
+                strict: false,
+                errorFunction: null,
+                execute: exec,
+            }));
+        }
+    }
+    return tools;
+}
+/**
+ * Build OpenAI Agents SDK {@link tool} instances for each ASAP capability on the client.
+ *
+ * Uses top-level {@link executeCapability} from `@asap-protocol/client` on each execution path.
+ */
+async function asapToolsForOpenAIAgents(client, options) {
+    const fetchFn = wrapFetchWithCapabilityErrors(client.fetch, options);
+    const describedByCapability = new Map();
+    const toDescribe = client.capabilities.filter((capabilityId) => options?.inputSchemas?.[capabilityId] === undefined);
+    for (const capabilityId of client.capabilities) {
+        if (options?.inputSchemas?.[capabilityId] !== undefined) {
+            describedByCapability.set(capabilityId, undefined);
+        }
+    }
+    await mapInBatches(toDescribe, DESCRIBE_CONCURRENCY, async (capabilityId) => {
+        try {
+            const described = await (0, client_1.describeCapability)(client.provider, capabilityId, {
+                fetch: fetchFn,
+                agentJwt: client.agentJwt,
+                signal: options?.signal,
+            });
+            describedByCapability.set(capabilityId, {
+                description: described.description,
+                input_schema: described.input_schema,
+                output_schema: described.output_schema,
+            });
+        }
+        catch (error) {
+            options?.onDescribeError?.(capabilityId, error);
+            if (options?.allowPermissiveDescribeFallback === true) {
+                describedByCapability.set(capabilityId, undefined);
+                return;
+            }
+            throw error;
+        }
+    });
+    return buildTools(client, fetchFn, describedByCapability, options);
+}
+/**
+ * Synchronous variant when {@link AsapToolsForOpenAIAgentsOptions.inputSchemas} / `outputSchemas`
+ * are already materialized (skips describe round-trips).
+ */
+function asapToolsForOpenAIAgentsSync(client, options) {
+    const fetchFn = wrapFetchWithCapabilityErrors(client.fetch, options);
+    const describedByCapability = new Map();
+    for (const capabilityId of client.capabilities) {
+        describedByCapability.set(capabilityId, undefined);
+    }
+    return buildTools(client, fetchFn, describedByCapability, options);
+}

package/dist/commonjs/errors.d.ts

@@ -0,0 +1,27 @@
+export { FatalError, RecoverableError, RemoteFatalRPCError, RemoteRecoverableRPCError, } from "@asap-protocol/client";
+/**
+ * Structured `approval_required` payload (`error.data`) from an ASAP provider JSON body.
+ */
+export interface ApprovalRequiredDetail {
+    readonly reason?: string;
+    readonly approval_url?: string;
+}
+/**
+ * Raised when the provider indicates an approval step is required before the capability can run.
+ */
+export declare class ApprovalRequiredError extends Error {
+    readonly name = "ApprovalRequiredError";
+    readonly detail?: ApprovalRequiredDetail;
+    constructor(message?: string, detail?: unknown);
+}
+/**
+ * Raised when the agent JWT is valid but the capability is not granted (HTTP 403 `capability_not_granted`).
+ */
+export declare class CapabilityNotGrantedError extends Error {
+    readonly name = "CapabilityNotGrantedError";
+    readonly requiredCapability: string;
+    private readonly hook?;
+    constructor(requiredCapability: string, requestCapability?: (capability: string) => void | Promise<void>, message?: string);
+    requestCapability(): void | Promise<void>;
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/commonjs/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,gBAAgB,EAChB,mBAAmB,EACnB,yBAAyB,GAC1B,MAAM,uBAAuB,CAAC;AAE/B;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC;AAmBD;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,SAAkB,IAAI,2BAA2B;IAEjD,QAAQ,CAAC,MAAM,CAAC,EAAE,sBAAsB,CAAC;gBAE7B,OAAO,SAA2C,EAAE,MAAM,CAAC,EAAE,OAAO;CAIjF;AAED;;GAEG;AACH,qBAAa,yBAA0B,SAAQ,KAAK;IAClD,SAAkB,IAAI,+BAA+B;IAErD,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IAEpC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAA+C;gBAGnE,kBAAkB,EAAE,MAAM,EAC1B,iBAAiB,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,EAChE,OAAO,CAAC,EAAE,MAAM;IAOlB,iBAAiB,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;CAG1C"}

package/dist/commonjs/errors.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CapabilityNotGrantedError = exports.ApprovalRequiredError = exports.RemoteRecoverableRPCError = exports.RemoteFatalRPCError = exports.RecoverableError = exports.FatalError = void 0;
+var client_1 = require("@asap-protocol/client");
+Object.defineProperty(exports, "FatalError", { enumerable: true, get: function () { return client_1.FatalError; } });
+Object.defineProperty(exports, "RecoverableError", { enumerable: true, get: function () { return client_1.RecoverableError; } });
+Object.defineProperty(exports, "RemoteFatalRPCError", { enumerable: true, get: function () { return client_1.RemoteFatalRPCError; } });
+Object.defineProperty(exports, "RemoteRecoverableRPCError", { enumerable: true, get: function () { return client_1.RemoteRecoverableRPCError; } });
+function approvalDetailFromUnknown(data) {
+    if (!data || typeof data !== "object" || Array.isArray(data)) {
+        return undefined;
+    }
+    const rec = data;
+    const reason = rec.reason;
+    const approval_url = rec.approval_url;
+    const detail = {};
+    if (typeof reason === "string") {
+        detail.reason = reason;
+    }
+    if (typeof approval_url === "string") {
+        detail.approval_url = approval_url;
+    }
+    return Object.keys(detail).length > 0 ? detail : undefined;
+}
+/**
+ * Raised when the provider indicates an approval step is required before the capability can run.
+ */
+class ApprovalRequiredError extends Error {
+    name = "ApprovalRequiredError";
+    detail;
+    constructor(message = "Capability execution requires approval", detail) {
+        super(message);
+        this.detail = approvalDetailFromUnknown(detail);
+    }
+}
+exports.ApprovalRequiredError = ApprovalRequiredError;
+/**
+ * Raised when the agent JWT is valid but the capability is not granted (HTTP 403 `capability_not_granted`).
+ */
+class CapabilityNotGrantedError extends Error {
+    name = "CapabilityNotGrantedError";
+    requiredCapability;
+    hook;
+    constructor(requiredCapability, requestCapability, message) {
+        super(message ?? `Capability not granted: ${requiredCapability}`);
+        this.requiredCapability = requiredCapability;
+        this.hook = requestCapability;
+    }
+    requestCapability() {
+        return this.hook?.(this.requiredCapability);
+    }
+}
+exports.CapabilityNotGrantedError = CapabilityNotGrantedError;

package/dist/commonjs/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * OpenAI Agents SDK (`@openai/agents`) integration: ASAP capabilities as `tool()` and related helpers.
+ *
+ * For static `ChatCompletionTool[]` against the Chat Completions HTTP API, use `@asap-protocol/client/adapters/openai` instead.
+ */
+export { asapToolsForOpenAIAgents, asapToolsForOpenAIAgentsSync, type AsapToolsForOpenAIAgentsOptions, } from "./asap-to-openai-tool.js";
+export { asapAsRemoteAgent, draftTaskRequestEnvelopeForRemoteAgent, sameProviderOrigin, type AsapAsRemoteAgentOptions, type AsapRemoteAgentMode, type AsapRemoteRunContext, } from "./asap-as-remote-agent.js";
+export { sendAsapEnvelope, type SendAsapEnvelopeOptions, type SendAsapFetch, } from "./send-asap-envelope.js";
+export { zodFromJsonSchema } from "./schema-bridge.js";
+export { asapStreamToOpenAIAgentsRunStreamChunks, asapStreamToOpenAIAgentsTextStream, type OpenAIAgentsStreamTextDelta, } from "./streaming.js";
+export * from "./errors.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/commonjs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,wBAAwB,EACxB,4BAA4B,EAC5B,KAAK,+BAA+B,GACrC,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,iBAAiB,EACjB,sCAAsC,EACtC,kBAAkB,EAClB,KAAK,wBAAwB,EAC7B,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,GAC1B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,gBAAgB,EAChB,KAAK,uBAAuB,EAC5B,KAAK,aAAa,GACnB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EACL,uCAAuC,EACvC,kCAAkC,EAClC,KAAK,2BAA2B,GACjC,MAAM,gBAAgB,CAAC;AACxB,cAAc,aAAa,CAAC"}

package/dist/commonjs/index.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * OpenAI Agents SDK (`@openai/agents`) integration: ASAP capabilities as `tool()` and related helpers.
+ *
+ * For static `ChatCompletionTool[]` against the Chat Completions HTTP API, use `@asap-protocol/client/adapters/openai` instead.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asapStreamToOpenAIAgentsTextStream = exports.asapStreamToOpenAIAgentsRunStreamChunks = exports.zodFromJsonSchema = exports.sendAsapEnvelope = exports.sameProviderOrigin = exports.draftTaskRequestEnvelopeForRemoteAgent = exports.asapAsRemoteAgent = exports.asapToolsForOpenAIAgentsSync = exports.asapToolsForOpenAIAgents = void 0;
+var asap_to_openai_tool_js_1 = require("./asap-to-openai-tool.js");
+Object.defineProperty(exports, "asapToolsForOpenAIAgents", { enumerable: true, get: function () { return asap_to_openai_tool_js_1.asapToolsForOpenAIAgents; } });
+Object.defineProperty(exports, "asapToolsForOpenAIAgentsSync", { enumerable: true, get: function () { return asap_to_openai_tool_js_1.asapToolsForOpenAIAgentsSync; } });
+var asap_as_remote_agent_js_1 = require("./asap-as-remote-agent.js");
+Object.defineProperty(exports, "asapAsRemoteAgent", { enumerable: true, get: function () { return asap_as_remote_agent_js_1.asapAsRemoteAgent; } });
+Object.defineProperty(exports, "draftTaskRequestEnvelopeForRemoteAgent", { enumerable: true, get: function () { return asap_as_remote_agent_js_1.draftTaskRequestEnvelopeForRemoteAgent; } });
+Object.defineProperty(exports, "sameProviderOrigin", { enumerable: true, get: function () { return asap_as_remote_agent_js_1.sameProviderOrigin; } });
+var send_asap_envelope_js_1 = require("./send-asap-envelope.js");
+Object.defineProperty(exports, "sendAsapEnvelope", { enumerable: true, get: function () { return send_asap_envelope_js_1.sendAsapEnvelope; } });
+var schema_bridge_js_1 = require("./schema-bridge.js");
+Object.defineProperty(exports, "zodFromJsonSchema", { enumerable: true, get: function () { return schema_bridge_js_1.zodFromJsonSchema; } });
+var streaming_js_1 = require("./streaming.js");
+Object.defineProperty(exports, "asapStreamToOpenAIAgentsRunStreamChunks", { enumerable: true, get: function () { return streaming_js_1.asapStreamToOpenAIAgentsRunStreamChunks; } });
+Object.defineProperty(exports, "asapStreamToOpenAIAgentsTextStream", { enumerable: true, get: function () { return streaming_js_1.asapStreamToOpenAIAgentsTextStream; } });
+__exportStar(require("./errors.js"), exports);

package/dist/commonjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/commonjs/schema-bridge.d.ts

@@ -0,0 +1,8 @@
+import { type ZodType } from "zod";
+/**
+ * Minimal JSON Schema → Zod bridge for adapter tool schemas (subset only).
+ *
+ * Lossy for `$ref` / complex `oneOf`; mirrors `@asap-protocol/mastra` / legacy Chat Completions adapter patterns.
+ */
+export declare function zodFromJsonSchema(schema: Record<string, unknown>): ZodType<unknown>;
+//# sourceMappingURL=schema-bridge.d.ts.map

package/dist/commonjs/schema-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-bridge.d.ts","sourceRoot":"","sources":["../../src/schema-bridge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAK,KAAK,OAAO,EAAE,MAAM,KAAK,CAAC;AAqDtC;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CA4DnF"}