@alvin0/ai-agent-sdk-core 0.1.0

package/dist/agent/team/types.d.ts

@@ -0,0 +1,170 @@
+import { ContentBlock } from "../../message/content.js";
+import { SdkLogger } from "../../logging/types.js";
+import { AgentMessageSource } from "../../message/message.js";
+import { AgentRunEvent } from "../mode/run-agent.js";
+import { AgentTeamMemberOptions } from "../define/session/types.js";
+//#region src/agent/team/types.d.ts
+/** A quiet delivery adds context; a wakeup delivery also schedules a turn. */
+type AgentMessageDelivery = 'quiet' | 'wakeup';
+/**
+ * How a member's last run ended.
+ *
+ * Carries the member's own answer, which is what a coordinator needs once it no
+ * longer receives that answer as a tool return value: an agent started
+ * concurrently reports here instead.
+ */
+type AgentMemberOutcome = {
+  readonly kind: 'completed';
+  readonly text: string;
+} | {
+  readonly kind: 'failed';
+  readonly message: string;
+};
+/** Detached runtime view of one addressable member. */
+interface AgentTeamMember {
+  readonly name: string;
+  readonly agentId: string;
+  readonly kind: 'local' | 'remote';
+  readonly conversationId?: string;
+  readonly role: 'lead' | 'peer';
+  /**
+   * `pending` is a member the host has created but deliberately not started
+   * yet — it is waiting on another member. Reporting it as `idle` would tell a
+   * coordinator its work was over before it had begun.
+   */
+  readonly status: 'pending' | 'running' | 'idle' | 'failed';
+  readonly protocol?: string;
+  readonly deliveries: readonly AgentMessageDelivery[];
+  readonly description?: string;
+  readonly error?: string;
+  /** Absent until the member has finished a run at least once. */
+  readonly outcome?: AgentMemberOutcome;
+}
+/** Transport-neutral result returned by an externally linked agent. */
+interface LinkedAgentResult {
+  readonly kind: 'message' | 'task';
+  readonly succeeded: boolean;
+  readonly text: string;
+  readonly contextId: string;
+  readonly taskId?: string;
+  readonly state?: string;
+}
+interface LinkedAgentSendInput {
+  readonly teamId: string;
+  readonly messageId: string;
+  readonly sender: string;
+  readonly senderAgentId: string;
+  readonly content: readonly ContentBlock[];
+  readonly signal?: AbortSignal;
+  /** Runtime-bound integration logger when the link is used through AgentRuntime. */
+  readonly logger?: SdkLogger;
+}
+/** A remote protocol transport that can be linked into an AgentTeam roster. */
+interface LinkedAgentTransport {
+  readonly protocol: string;
+  readonly agentId: string;
+  send(input: LinkedAgentSendInput): Promise<LinkedAgentResult>;
+}
+interface LinkAgentOptions {
+  readonly name: string;
+  readonly description?: string;
+  readonly transport: LinkedAgentTransport;
+}
+interface SendAgentMessageRequest {
+  /** Sender name registered in the same team. */
+  readonly from: string;
+  /** Target member name. */
+  readonly target: string;
+  readonly message: string | readonly ContentBlock[];
+  readonly delivery?: AgentMessageDelivery;
+  readonly signal?: AbortSignal;
+}
+/** Immutable mailbox record retained by the control plane. */
+interface AgentMessageRecord {
+  readonly id: string;
+  readonly teamId: string;
+  readonly sender: string;
+  readonly senderAgentId: string;
+  readonly target: string;
+  readonly targetAgentId: string;
+  readonly delivery: AgentMessageDelivery;
+  readonly content: readonly ContentBlock[];
+  readonly status: 'accepted';
+  readonly createdAt: string;
+  readonly result?: LinkedAgentResult;
+}
+interface SendAgentMessageResult {
+  readonly messageId: string;
+  /** Local history owns the message, or the remote protocol call returned successfully. */
+  readonly status: 'accepted';
+  readonly delivery: AgentMessageDelivery;
+  readonly target: string;
+  readonly result?: LinkedAgentResult;
+}
+type AgentTeamEvent = {
+  readonly type: 'member-attached';
+  readonly member: AgentTeamMember;
+} | {
+  readonly type: 'member-linked';
+  readonly member: AgentTeamMember;
+} | {
+  readonly type: 'message-accepted';
+  readonly message: AgentMessageRecord;
+} | {
+  readonly type: 'member-run-start';
+  readonly member: string;
+} | {
+  readonly type: 'member-run-end';
+  readonly member: string;
+} | {
+  readonly type: 'member-run-cancelled';
+  readonly member: string;
+} | {
+  readonly type: 'member-run-error';
+  readonly member: string;
+  readonly error: string;
+} | {
+  readonly type: 'team-disposed';
+  readonly teamId: string;
+};
+interface AgentTeamOptions {
+  readonly id?: string;
+  readonly maxMembers?: number;
+  /** Maximum number of accepted messages retained for audit. Defaults to 10,000. */
+  readonly maxMessages?: number;
+  readonly maxMessageBytes?: number;
+  /** Maximum serialized result retained from one linked transport. Defaults to 1 MiB. */
+  readonly maxLinkedResultBytes?: number;
+  /** Maximum cumulative serialized content/result bytes retained by the mailbox. Defaults to 64 MiB. */
+  readonly maxMailboxBytes?: number;
+  /** Maximum serialized bytes for descriptions and collaboration instructions. Defaults to 8 KiB. */
+  readonly maxMetadataBytes?: number;
+  /** Maximum time dispose waits for cooperative transports/providers. Defaults to 30 seconds. */
+  readonly disposeTimeoutMs?: number;
+  /** End-to-end bound for one remote dispatch or local wake-up batch. Defaults to 10 minutes. */
+  readonly operationTimeoutMs?: number;
+  /** Maximum wait per asynchronous agent-event observer. Defaults to 1 second. */
+  readonly observerTimeoutMs?: number;
+  /**
+   * How long `wait_agents` waits before reporting back. Defaults to 30 seconds.
+   *
+   * The tool call can ask for less. It cannot wait forever, because a
+   * coordinator that never regains control cannot tell a slow agent from a
+   * stuck one, and neither can the person watching it.
+   */
+  readonly waitTimeoutMs?: number;
+  /**
+   * Shortest wait one `wait_agents` call may ask for. Defaults to 5 seconds.
+   *
+   * A lead that asks for a second gets the roster back unchanged and has spent
+   * a model round learning nothing. A request below the floor is raised to it,
+   * not rejected, and the response reports the budget actually used.
+   */
+  readonly minWaitTimeoutMs?: number;
+  readonly onEvent?: (event: AgentTeamEvent) => void;
+  /** Observe model/tool/compaction events from local wake-up runs. */
+  readonly onAgentEvent?: (member: string, event: AgentRunEvent) => void | Promise<void>;
+}
+//#endregion
+export { AgentMemberOutcome, AgentMessageDelivery, AgentMessageRecord, type AgentMessageSource, AgentTeamEvent, AgentTeamMember, type AgentTeamMemberOptions, AgentTeamOptions, LinkAgentOptions, LinkedAgentResult, LinkedAgentSendInput, LinkedAgentTransport, SendAgentMessageRequest, SendAgentMessageResult };
+//# sourceMappingURL=types.d.ts.map

package/dist/agent/team/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/agent/team/types.ts"],"mappings":";;;;;;;KAWY;;;;;;;;KASA;WACG;WAA4B;;WAC5B;WAAyB;;;UAGvB;WACN;WACA;WACA;WACA;WACA;;;;;;WAMA;WACA;WACA,qBAAqB;WACrB;WACA;;WAEA,UAAU;;;UAIJ;WACN;WACA;WACA;WACA;WACA;WACA;;UAGM;WACN;WACA;WACA;WACA;WACA,kBAAkB;WAClB,SAAS;;WAET,SAAS;;;UAIH;WACN;WACA;EACT,KAAK,OAAO,uBAAuB,QAAQ;;UAG5B;WACN;WACA;WACA,WAAW;;UAGL;;WAEN;;WAEA;WACA,2BAA2B;WAC3B,WAAW;WACX,SAAS;;;UAIH;WACN;WACA;WACA;WACA;WACA;WACA;WACA,UAAU;WACV,kBAAkB;WAClB;WACA;WACA,SAAS;;UAGH;WACN;;WAEA;WACA,UAAU;WACV;WACA,SAAS;;KAGR;WACG;WAAkC,QAAQ;;WAC1C;WAAgC,QAAQ;;WACxC;WAAmC,SAAS;;WAC5C;WAAmC;;WACnC;WAAiC;;WACjC;WAAuC;;WACvC;WAAmC;WAAyB;;WAC5D;WAAgC;;UAE9B;WACN;WACA;;WAEA;WACA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;;;;;;;WAQA;;;;;;;;WAQA;WACA,WAAW,OAAO;;WAElB,gBAAgB,gBAAgB,OAAO,yBAAyB"}

package/dist/agent/tool/approval.d.ts

@@ -0,0 +1,106 @@
+import { ToolCallId } from "../../primitives/brand.js";
+//#region src/agent/tool/approval.d.ts
+declare function createApprovalRequest(input: Omit<ApprovalRequest, 'approvalRequestId' | 'providerCallId'>): ApprovalRequest;
+/** What the approver decided. */
+type ApprovalDecision =
+/** Run it. */
+'allow' |
+/** Refuse this call; the model is told and may try something else. */
+'deny' |
+/** Withdraw the turn entirely. */
+'abort';
+/** One request for permission. */
+interface ApprovalRequest {
+  /** SDK-generated, single-use identity. Never resolve using the provider call id. */
+  readonly approvalRequestId: string;
+  readonly providerCallId: ToolCallId;
+  readonly runId?: string;
+  readonly conversationId?: string;
+  /** Provider-issued id of the call awaiting a decision. */
+  readonly callId: ToolCallId;
+  readonly toolName: string;
+  /** Parsed arguments, so an approver can show what is about to happen. */
+  readonly args: unknown;
+  /** Why permission is being asked, when an interceptor said. */
+  readonly reason?: string;
+  readonly turn: number;
+  readonly step: number;
+}
+/** Decides whether a call may proceed. */
+interface ApprovalBroker {
+  /**
+   * Ask for permission.
+   * @param request - what is about to run.
+   * @param signal - cancellation; an abort must settle the promise, not leak it.
+   * @returns the decision.
+   */
+  readonly request: (request: ApprovalRequest, signal?: AbortSignal) => Promise<ApprovalDecision>;
+}
+/**
+ * A broker that answers every request the same way, without asking anyone.
+ *
+ * For headless runs and tests. `deny` is a useful default for a sandbox that wants
+ * approval-requiring tools reported to the model as unavailable rather than
+ * silently executed.
+ * @param decision - the fixed answer.
+ * @returns the broker.
+ */
+declare function fixedApprovalBroker(decision: ApprovalDecision): ApprovalBroker;
+/**
+ * A broker that publishes requests and waits to be answered by approval request id.
+ *
+ * This is the interactive one. Wire {@link InteractiveApprovalBroker.onRequest} to
+ * a UI, and call {@link InteractiveApprovalBroker.resolve} when the human answers.
+ */
+interface InteractiveApprovalBroker extends ApprovalBroker {
+  /** Requests still awaiting an answer, in the order they were asked. */
+  pending(): readonly ApprovalRequest[];
+  /**
+   * Observe requests.
+   *
+   * Listeners are invoked AFTER the waiter is registered, so resolving
+   * synchronously from inside a listener is safe.
+   * @param listener - receives each request.
+   * @returns a disposer.
+   */
+  onRequest(listener: (request: ApprovalRequest) => void): () => void;
+  /**
+   * Answer a pending request.
+   * @param approvalRequestId - the SDK-issued request identity to answer.
+   * @param decision - the answer.
+   * @returns true when a pending request was answered; false when the id is
+   *   unknown, which happens legitimately if the turn was already cancelled.
+   */
+  resolve(approvalRequestId: string, decision: ApprovalDecision): boolean;
+  /** Abort only pending requests belonging to this run. */
+  abortRun(runId: string): void;
+  /** Abort only pending requests belonging to this conversation. */
+  abortSession(conversationId: string): void;
+  /**
+   * Answer every outstanding request with `abort`.
+   *
+   * Call this when a turn is torn down: a parked promise with no answer coming
+   * would keep the run alive forever.
+   */
+  abortAll(): void;
+}
+interface InteractiveApprovalBrokerOptions {
+  /** Maximum requests parked across concurrent sessions. Defaults to 1,024. */
+  readonly maxPending?: number;
+}
+/**
+ * Create an interactive approval broker.
+ * @returns the broker.
+ */
+declare function createApprovalBroker(options?: InteractiveApprovalBrokerOptions): InteractiveApprovalBroker;
+/** Optional durable approval journal, separate from conversation snapshots.
+ * The host owns loading pending records and reissuing a fresh approval on recovery;
+ * saved decisions are never automatically applied to a new request. */
+interface ApprovalStateStore {
+  savePending(request: ApprovalRequest, signal?: AbortSignal): Promise<void>;
+  saveDecision(request: ApprovalRequest, decision: ApprovalDecision, signal?: AbortSignal): Promise<void>;
+}
+declare function withApprovalPersistence(broker: ApprovalBroker, store: ApprovalStateStore): ApprovalBroker;
+//#endregion
+export { ApprovalBroker, ApprovalDecision, ApprovalRequest, ApprovalStateStore, InteractiveApprovalBroker, InteractiveApprovalBrokerOptions, createApprovalBroker, createApprovalRequest, fixedApprovalBroker, withApprovalPersistence };
+//# sourceMappingURL=approval.d.ts.map

package/dist/agent/tool/approval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"approval.d.ts","names":[],"sources":["../../../src/agent/tool/approval.ts"],"mappings":";;iBA4BgB,sBAAsB,OAAO,KAAK,2DAA2D;;KAOjG;;;;;;;;UASK;;WAEN;WACA,gBAAgB;WAChB;WACA;;WAEA,QAAQ;WACR;;WAEA;;WAEA;WACA;WACA;;;UAIM;;;;;;;WAON,UAAU,SAAS,iBAAiB,SAAS,gBAAgB,QAAQ;;;;;;;;;;;iBAYhE,oBAAoB,UAAU,mBAAmB;;;;;;;UAUhD,kCAAkC;;EAEjD,oBAAoB;;;;;;;;;EASpB,UAAU,WAAW,SAAS;;;;;;;;EAQ9B,QAAQ,2BAA2B,UAAU;;EAE7C,SAAS;;EAET,aAAa;;;;;;;EAOb;;UAGe;;WAEN;;;;;;iBAYK,qBAAqB,UAAS,mCAAwC;;;;UAmFrE;EACf,YAAY,SAAS,iBAAiB,SAAS,cAAc;EAC7D,aAAa,SAAS,iBAAiB,UAAU,kBAAkB,SAAS,cAAc;;iBAG5E,wBAAwB,QAAQ,gBAAgB,OAAO,qBAAqB"}

package/dist/agent/tool/approval.js

@@ -0,0 +1,2 @@
+import{detachedFrozen as e}from"../../primitives/snapshot.js";import{systemRandomId as t}from"../../platform/adapter.js";const n=new WeakSet;function r(r){let i=e({...r,approvalRequestId:t(),providerCallId:r.callId});return n.add(i),i}function i(e){return{request:()=>Promise.resolve(e)}}function a(t={}){let r=o(t.maxPending??1024,`approval maxPending`),i=new Map,a=new Set;return{request(t,o){if(!n.delete(t))return Promise.reject(Error(`approval request must be fresh and SDK-issued`));if(o?.aborted===!0)return Promise.resolve(`abort`);if(i.has(t.approvalRequestId))return Promise.reject(Error(`approval request '${t.approvalRequestId}' is already pending`));if(i.size>=r)return Promise.reject(Error(`approval broker reached its ${r}-request limit`));let s=e(t);return new Promise(e=>{let n=!1,r=r=>{n||(n=!0,i.delete(t.approvalRequestId),o?.removeEventListener(`abort`,c),e(r))};function c(){r(`abort`)}i.set(t.approvalRequestId,{request:s,settle:r}),o?.addEventListener(`abort`,c,{once:!0});for(let e of[...a])try{e(s)}catch{}})},pending(){return[...i.values()].map(e=>e.request)},onRequest(e){return a.add(e),()=>void a.delete(e)},resolve(e,t){if(t!==`allow`&&t!==`deny`&&t!==`abort`)return!1;let n=i.get(e);return n!==void 0&&(n.settle(t),!0)},abortRun(e){for(let t of[...i.values()])t.request.runId===e&&t.settle(`abort`)},abortSession(e){for(let t of[...i.values()])t.request.conversationId===e&&t.settle(`abort`)},abortAll(){for(let e of[...i.values()])e.settle(`abort`)}}}function o(e,t){if(!Number.isSafeInteger(e)||e<1)throw RangeError(`${t} must be a positive safe integer`);return e}function s(e,t){let n=e.request.bind(e),r=t.savePending.bind(t),i=t.saveDecision.bind(t);return Object.freeze({async request(e,t){let a=new AbortController,o=t===void 0?a.signal:AbortSignal.any([t,a.signal]),s=n(e,o);s.catch(()=>void 0);try{await r(e,o);let t=await s;return await i(e,t,o),t}catch(e){throw a.abort(e),e}}})}export{a as createApprovalBroker,r as createApprovalRequest,i as fixedApprovalBroker,s as withApprovalPersistence};
+//# sourceMappingURL=approval.js.map

package/dist/agent/tool/approval.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"approval.js","names":[],"sources":["../../../src/agent/tool/approval.ts"],"sourcesContent":["/**\n * Asking permission before a tool runs.\n *\n * The shape is the one both reference implementations arrived at: the loop does\n * not pause, the *tool call* pauses. A pending promise is parked in a map keyed by\n * approval request id, a request is published, and whoever is watching resolves it later by\n * that id. Everything else in the turn — other tool calls in the same batch,\n * streaming, cancellation — keeps working.\n *\n * Two details are load-bearing and easy to get wrong:\n *\n * 1. **The waiter is registered BEFORE the request is published.** A listener that\n *    resolves synchronously (a policy engine, a test) would otherwise answer a\n *    question nobody is holding, and the call would hang forever.\n * 2. **`deny` and `abort` are different outcomes.** Denial is a normal answer that\n *    the model should see and can work around. Abort is the user withdrawing the\n *    whole turn. Collapsing them either strands a cancelled run waiting for the\n *    model to react, or teaches the model that \"no\" means \"stop everything\".\n *\n * @module ai-agent-sdk/agent/tool/approval\n */\n\nimport { systemRandomId } from '../../platform/adapter.ts'\nimport type { ToolCallId } from '../../primitives/index.ts'\nimport { detachedFrozen } from '../../primitives/index.ts'\n\nconst issuedRequests = new WeakSet<object>()\n\nexport function createApprovalRequest(input: Omit<ApprovalRequest, 'approvalRequestId' | 'providerCallId'>): ApprovalRequest {\n  const request = detachedFrozen({ ...input, approvalRequestId: systemRandomId(), providerCallId: input.callId })\n  issuedRequests.add(request)\n  return request\n}\n\n/** What the approver decided. */\nexport type ApprovalDecision =\n  /** Run it. */\n  | 'allow'\n  /** Refuse this call; the model is told and may try something else. */\n  | 'deny'\n  /** Withdraw the turn entirely. */\n  | 'abort'\n\n/** One request for permission. */\nexport interface ApprovalRequest {\n  /** SDK-generated, single-use identity. Never resolve using the provider call id. */\n  readonly approvalRequestId: string\n  readonly providerCallId: ToolCallId\n  readonly runId?: string\n  readonly conversationId?: string\n  /** Provider-issued id of the call awaiting a decision. */\n  readonly callId: ToolCallId\n  readonly toolName: string\n  /** Parsed arguments, so an approver can show what is about to happen. */\n  readonly args: unknown\n  /** Why permission is being asked, when an interceptor said. */\n  readonly reason?: string\n  readonly turn: number\n  readonly step: number\n}\n\n/** Decides whether a call may proceed. */\nexport interface ApprovalBroker {\n  /**\n   * Ask for permission.\n   * @param request - what is about to run.\n   * @param signal - cancellation; an abort must settle the promise, not leak it.\n   * @returns the decision.\n   */\n  readonly request: (request: ApprovalRequest, signal?: AbortSignal) => Promise<ApprovalDecision>\n}\n\n/**\n * A broker that answers every request the same way, without asking anyone.\n *\n * For headless runs and tests. `deny` is a useful default for a sandbox that wants\n * approval-requiring tools reported to the model as unavailable rather than\n * silently executed.\n * @param decision - the fixed answer.\n * @returns the broker.\n */\nexport function fixedApprovalBroker(decision: ApprovalDecision): ApprovalBroker {\n  return { request: () => Promise.resolve(decision) }\n}\n\n/**\n * A broker that publishes requests and waits to be answered by approval request id.\n *\n * This is the interactive one. Wire {@link InteractiveApprovalBroker.onRequest} to\n * a UI, and call {@link InteractiveApprovalBroker.resolve} when the human answers.\n */\nexport interface InteractiveApprovalBroker extends ApprovalBroker {\n  /** Requests still awaiting an answer, in the order they were asked. */\n  pending(): readonly ApprovalRequest[]\n  /**\n   * Observe requests.\n   *\n   * Listeners are invoked AFTER the waiter is registered, so resolving\n   * synchronously from inside a listener is safe.\n   * @param listener - receives each request.\n   * @returns a disposer.\n   */\n  onRequest(listener: (request: ApprovalRequest) => void): () => void\n  /**\n   * Answer a pending request.\n   * @param approvalRequestId - the SDK-issued request identity to answer.\n   * @param decision - the answer.\n   * @returns true when a pending request was answered; false when the id is\n   *   unknown, which happens legitimately if the turn was already cancelled.\n   */\n  resolve(approvalRequestId: string, decision: ApprovalDecision): boolean\n  /** Abort only pending requests belonging to this run. */\n  abortRun(runId: string): void\n  /** Abort only pending requests belonging to this conversation. */\n  abortSession(conversationId: string): void\n  /**\n   * Answer every outstanding request with `abort`.\n   *\n   * Call this when a turn is torn down: a parked promise with no answer coming\n   * would keep the run alive forever.\n   */\n  abortAll(): void\n}\n\nexport interface InteractiveApprovalBrokerOptions {\n  /** Maximum requests parked across concurrent sessions. Defaults to 1,024. */\n  readonly maxPending?: number\n}\n\ninterface Waiter {\n  readonly request: ApprovalRequest\n  readonly settle: (decision: ApprovalDecision) => void\n}\n\n/**\n * Create an interactive approval broker.\n * @returns the broker.\n */\nexport function createApprovalBroker(options: InteractiveApprovalBrokerOptions = {}): InteractiveApprovalBroker {\n  const maxPending = positiveSafeInteger(options.maxPending ?? 1_024, 'approval maxPending')\n  const waiters = new Map<string, Waiter>()\n  const listeners = new Set<(request: ApprovalRequest) => void>()\n\n  return {\n    request(request, signal) {\n      if (!issuedRequests.delete(request)) return Promise.reject(new Error('approval request must be fresh and SDK-issued'))\n      if (signal?.aborted === true) return Promise.resolve('abort')\n      if (waiters.has(request.approvalRequestId)) {\n        return Promise.reject(new Error(`approval request '${request.approvalRequestId}' is already pending`))\n      }\n      if (waiters.size >= maxPending) {\n        return Promise.reject(new Error(`approval broker reached its ${maxPending}-request limit`))\n      }\n      const published = detachedFrozen(request)\n\n      return new Promise<ApprovalDecision>((resolve) => {\n        let settled = false\n        const settle = (decision: ApprovalDecision): void => {\n          if (settled) return\n          settled = true\n          waiters.delete(request.approvalRequestId)\n          signal?.removeEventListener('abort', onAbort)\n          resolve(decision)\n        }\n        function onAbort(): void {\n          settle('abort')\n        }\n\n        // Registered first, deliberately: a listener below may answer\n        // synchronously, and there has to be somewhere for that answer to land.\n        waiters.set(request.approvalRequestId, { request: published, settle })\n        signal?.addEventListener('abort', onAbort, { once: true })\n\n        for (const listener of [...listeners]) {\n          try {\n            listener(published)\n          } catch {\n            // A broken observer must not strand the call. If nobody else answers,\n            // cancellation or `abortAll` still settles it.\n          }\n        }\n      })\n    },\n\n    pending() {\n      return [...waiters.values()].map(waiter => waiter.request)\n    },\n\n    onRequest(listener) {\n      listeners.add(listener)\n      return () => void listeners.delete(listener)\n    },\n\n    resolve(callId, decision) {\n      if (decision !== 'allow' && decision !== 'deny' && decision !== 'abort') return false\n      const waiter = waiters.get(callId)\n      if (waiter === undefined) return false\n      waiter.settle(decision)\n      return true\n    },\n\n    abortRun(runId) {\n      for (const waiter of [...waiters.values()]) if (waiter.request.runId === runId) waiter.settle('abort')\n    },\n    abortSession(conversationId) {\n      for (const waiter of [...waiters.values()]) if (waiter.request.conversationId === conversationId) waiter.settle('abort')\n    },\n    abortAll() {\n      for (const waiter of [...waiters.values()]) waiter.settle('abort')\n    },\n  }\n}\n\nfunction positiveSafeInteger(value: number, label: string): number {\n  if (!Number.isSafeInteger(value) || value < 1) throw new RangeError(`${label} must be a positive safe integer`)\n  return value\n}\n\n/** Optional durable approval journal, separate from conversation snapshots.\n * The host owns loading pending records and reissuing a fresh approval on recovery;\n * saved decisions are never automatically applied to a new request. */\nexport interface ApprovalStateStore {\n  savePending(request: ApprovalRequest, signal?: AbortSignal): Promise<void>\n  saveDecision(request: ApprovalRequest, decision: ApprovalDecision, signal?: AbortSignal): Promise<void>\n}\n\nexport function withApprovalPersistence(broker: ApprovalBroker, store: ApprovalStateStore): ApprovalBroker {\n  const request = broker.request.bind(broker)\n  const pendingRecord = store.savePending.bind(store), decisionRecord = store.saveDecision.bind(store)\n  return Object.freeze({\n    async request(value: ApprovalRequest, signal?: AbortSignal): Promise<ApprovalDecision> {\n      const owned = new AbortController()\n      const combined = signal === undefined ? owned.signal : AbortSignal.any([signal, owned.signal])\n      // Install the interactive waiter before any asynchronous storage operation.\n      const pending = request(value, combined)\n      void pending.catch(() => undefined)\n      try {\n        await pendingRecord(value, combined)\n        const decision = await pending\n        await decisionRecord(value, decision, combined)\n        return decision\n      } catch (error) {\n        owned.abort(error)\n        throw error\n      }\n    },\n  })\n}\n"],"mappings":"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"}

package/dist/agent/tool/capture.js

@@ -0,0 +1,2 @@
+import{AgentSdkError as e}from"../../errors/agent-sdk-error.js";import{snapshotJsonObject as t}from"../../primitives/json-snapshot.js";import{TOOL_DEFINITION_LIMITS as n,TOOL_REGISTRY_ERROR_CODES as r}from"./config.js";function i(i){try{(typeof i!=`object`&&typeof i!=`function`||i===null)&&u();let e=i,r=c(e,`name`,n.nameBytes),a=c(e,`description`,n.descriptionBytes),d=t(o(e,`parameters`),{maxObjectFields:n.schemaFields,maxArrayItems:n.schemaArrayItems,maxDepth:n.schemaDepth,maxNodes:n.schemaNodes,maxKeyBytes:n.schemaKeyBytes,maxBytes:n.schemaBytes}),f=l(e,`execute`,!0),p=l(e,`parse`,!1),m=l(e,`render`,!1),h=l(e,`meta`,!1),g=l(e,`isConcurrencySafe`,!1),_=s(e,`timeoutMs`);_!==void 0&&(typeof _!=`number`||!Number.isFinite(_)||_<=0)&&u();let v=s(e,`budgetExempt`);v!==void 0&&v!==!0&&u();let y=s(e,`completionExempt`);y!==void 0&&y!==!0&&u();let b=s(e,`maxOutputTokens`);return b!==void 0&&(!Number.isSafeInteger(b)||Number(b)<1)&&u(),Object.freeze({name:r,description:a,parameters:d,...p===void 0?{}:{parse:p},execute:f,...m===void 0?{}:{render:m},...h===void 0?{}:{meta:h},..._===void 0?{}:{timeoutMs:Number(_)},...g===void 0?{}:{isConcurrencySafe:g},...v===void 0?{}:{budgetExempt:!0},...y===void 0?{}:{completionExempt:!0},...b===void 0?{}:{maxOutputTokens:Number(b)}})}catch(t){throw t instanceof e&&t.code===r.INVALID_TOOL?t:new e(`tool definition is invalid`,r.INVALID_TOOL,{cause:t})}}function a(t){try{Array.isArray(t)||u();let e=o(t,`length`);(!Number.isSafeInteger(e)||Number(e)<0||Number(e)>n.tools)&&u();let r=[];for(let n=0;n<Number(e);n++)r.push(i(o(t,String(n))));return Object.freeze(r)}catch(t){throw t instanceof e&&t.code===r.INVALID_TOOL?t:new e(`tool definition list is invalid`,r.INVALID_TOOL,{cause:t})}}function o(e,t){let n=Object.getOwnPropertyDescriptor(e,t);return(n===void 0||!(`value`in n))&&u(),n.value}function s(e,t){let n=Object.getOwnPropertyDescriptor(e,t);if(n!==void 0)return`value`in n||u(),n.value}function c(e,t,n){let r=o(e,t);return(typeof r!=`string`||r.length===0||r.trim()!==r||new TextEncoder().encode(r).byteLength>n)&&u(),r}function l(e,t,n){let r=Reflect.get(e,t);if(!(r===void 0&&!n))return typeof r!=`function`&&u(),(...t)=>Reflect.apply(r,e,t)}function u(){throw new e(`tool definition is invalid`,r.INVALID_TOOL)}export{i as captureToolDefinition,a as captureToolDefinitions};
+//# sourceMappingURL=capture.js.map

package/dist/agent/tool/capture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capture.js","names":[],"sources":["../../../src/agent/tool/capture.ts"],"sourcesContent":["import { AgentSdkError } from '../../errors/agent-sdk-error.ts'\nimport { snapshotJsonObject } from '../../primitives/json-snapshot.ts'\nimport type { JsonObject, JsonValue } from '../../primitives/json.ts'\nimport type { ContentBlock } from '../../message/content.ts'\nimport type { ToolRunContext, ToolDefinition } from './definition.ts'\nimport { TOOL_DEFINITION_LIMITS, TOOL_REGISTRY_ERROR_CODES } from './config.ts'\n\ntype ToolMethod<Args extends readonly unknown[], Result> = (...args: Args) => Result\n\n/** Capture one stable tool generation while preserving the caller object's receiver. */\nexport function captureToolDefinition<Args>(input: ToolDefinition<Args>): ToolDefinition<Args> {\n  try {\n    if ((typeof input !== 'object' && typeof input !== 'function') || input === null) invalid()\n    const receiver = input as object\n    const name = boundedOwnText(receiver, 'name', TOOL_DEFINITION_LIMITS.nameBytes)\n    const description = boundedOwnText(receiver, 'description', TOOL_DEFINITION_LIMITS.descriptionBytes)\n    const parameters = snapshotJsonObject(ownData(receiver, 'parameters'), {\n      maxObjectFields: TOOL_DEFINITION_LIMITS.schemaFields,\n      maxArrayItems: TOOL_DEFINITION_LIMITS.schemaArrayItems,\n      maxDepth: TOOL_DEFINITION_LIMITS.schemaDepth,\n      maxNodes: TOOL_DEFINITION_LIMITS.schemaNodes,\n      maxKeyBytes: TOOL_DEFINITION_LIMITS.schemaKeyBytes,\n      maxBytes: TOOL_DEFINITION_LIMITS.schemaBytes,\n    })\n    const execute = method<[Args, ToolRunContext], Promise<JsonValue | void> | JsonValue | void>(receiver, 'execute', true)!\n    const parse = method<[unknown], Args>(receiver, 'parse', false)\n    const render = method<[JsonValue | undefined, Args], readonly ContentBlock[]>(receiver, 'render', false)\n    const meta = method<[JsonValue | undefined, Args], JsonObject | undefined>(receiver, 'meta', false)\n    const isConcurrencySafe = method<[Args], boolean>(receiver, 'isConcurrencySafe', false)\n    const timeoutMs = optionalOwnData(receiver, 'timeoutMs')\n    if (timeoutMs !== undefined && (typeof timeoutMs !== 'number' || !Number.isFinite(timeoutMs) || timeoutMs <= 0)) invalid()\n    // Fail-closed like every other flag here: only an exact `true` exempts a\n    // tool from the turn budget, so a truthy accident cannot quietly widen it.\n    const budgetExempt = optionalOwnData(receiver, 'budgetExempt')\n    if (budgetExempt !== undefined && budgetExempt !== true) invalid()\n    const completionExempt = optionalOwnData(receiver, 'completionExempt')\n    if (completionExempt !== undefined && completionExempt !== true) invalid()\n    const maxOutputTokens = optionalOwnData(receiver, 'maxOutputTokens')\n    if (maxOutputTokens !== undefined\n      && (!Number.isSafeInteger(maxOutputTokens) || Number(maxOutputTokens) < 1)) invalid()\n    return Object.freeze({ name, description, parameters,\n      ...(parse === undefined ? {} : { parse }), execute,\n      ...(render === undefined ? {} : { render }),\n      ...(meta === undefined ? {} : { meta }),\n      ...(timeoutMs === undefined ? {} : { timeoutMs: Number(timeoutMs) }),\n      ...(isConcurrencySafe === undefined ? {} : { isConcurrencySafe }),\n      ...(budgetExempt === undefined ? {} : { budgetExempt: true as const }),\n      ...(completionExempt === undefined ? {} : { completionExempt: true as const }),\n      ...(maxOutputTokens === undefined ? {} : { maxOutputTokens: Number(maxOutputTokens) }),\n    })\n  } catch (error) {\n    if (error instanceof AgentSdkError && error.code === TOOL_REGISTRY_ERROR_CODES.INVALID_TOOL) throw error\n    throw new AgentSdkError('tool definition is invalid', TOOL_REGISTRY_ERROR_CODES.INVALID_TOOL, { cause: error })\n  }\n}\n\n/** Capture a dense bounded tool list atomically. */\nexport function captureToolDefinitions(value: unknown): readonly ToolDefinition[] {\n  try {\n    if (!Array.isArray(value)) invalid()\n    const length = ownData(value, 'length')\n    if (!Number.isSafeInteger(length) || Number(length) < 0 || Number(length) > TOOL_DEFINITION_LIMITS.tools) invalid()\n    const captured: ToolDefinition[] = []\n    for (let index = 0; index < Number(length); index++) {\n      captured.push(captureToolDefinition(ownData(value, String(index)) as ToolDefinition))\n    }\n    return Object.freeze(captured)\n  } catch (error) {\n    if (error instanceof AgentSdkError && error.code === TOOL_REGISTRY_ERROR_CODES.INVALID_TOOL) throw error\n    throw new AgentSdkError('tool definition list is invalid', TOOL_REGISTRY_ERROR_CODES.INVALID_TOOL, { cause: error })\n  }\n}\n\nfunction ownData(source: object, key: string): unknown {\n  const descriptor = Object.getOwnPropertyDescriptor(source, key)\n  if (descriptor === undefined || !('value' in descriptor)) invalid()\n  return descriptor.value\n}\n\nfunction optionalOwnData(source: object, key: string): unknown {\n  const descriptor = Object.getOwnPropertyDescriptor(source, key)\n  if (descriptor === undefined) return undefined\n  if (!('value' in descriptor)) invalid()\n  return descriptor.value\n}\n\nfunction boundedOwnText(source: object, key: string, maxBytes: number): string {\n  const value = ownData(source, key)\n  if (typeof value !== 'string' || value.length === 0 || value.trim() !== value\n    || new TextEncoder().encode(value).byteLength > maxBytes) invalid()\n  return value\n}\n\nfunction method<Args extends readonly unknown[], Result>(\n  receiver: object,\n  key: string,\n  required: boolean,\n): ToolMethod<Args, Result> | undefined {\n  const value: unknown = Reflect.get(receiver, key)\n  if (value === undefined && !required) return undefined\n  if (typeof value !== 'function') invalid()\n  return (...args: Args): Result => Reflect.apply(value, receiver, args) as Result\n}\n\nfunction invalid(): never {\n  throw new AgentSdkError('tool definition is invalid', TOOL_REGISTRY_ERROR_CODES.INVALID_TOOL)\n}\n"],"mappings":"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"}

package/dist/agent/tool/config.js

@@ -0,0 +1,2 @@
+const e=Object.freeze({tools:1024,nameBytes:256,descriptionBytes:16384,schemaBytes:262144,schemaDepth:32,schemaNodes:16384,schemaFields:512,schemaArrayItems:1024,schemaKeyBytes:256}),t=Object.freeze({DUPLICATE_TOOL:`DUPLICATE_TOOL`,INVALID_TOOL:`INVALID_TOOL`,UNKNOWN_TOOL_FILTER:`UNKNOWN_TOOL_FILTER`});export{e as TOOL_DEFINITION_LIMITS,t as TOOL_REGISTRY_ERROR_CODES};
+//# sourceMappingURL=config.js.map

package/dist/agent/tool/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","names":[],"sources":["../../../src/agent/tool/config.ts"],"sourcesContent":["export const TOOL_DEFINITION_LIMITS = Object.freeze({\n  tools: 1_024,\n  nameBytes: 256,\n  descriptionBytes: 16 * 1024,\n  schemaBytes: 256 * 1024,\n  schemaDepth: 32,\n  schemaNodes: 16_384,\n  schemaFields: 512,\n  schemaArrayItems: 1_024,\n  schemaKeyBytes: 256,\n})\n\nexport const TOOL_REGISTRY_ERROR_CODES = Object.freeze({\n  DUPLICATE_TOOL: 'DUPLICATE_TOOL',\n  INVALID_TOOL: 'INVALID_TOOL',\n  UNKNOWN_TOOL_FILTER: 'UNKNOWN_TOOL_FILTER',\n} as const)\n"],"mappings":"AAAA,MAAa,EAAyB,OAAO,OAAO,CAClD,MAAO,KACP,UAAW,IACX,iBAAkB,MAClB,YAAa,OACb,YAAa,GACb,YAAa,MACb,aAAc,IACd,iBAAkB,KAClB,eAAgB,GAClB,CAAC,EAEY,EAA4B,OAAO,OAAO,CACrD,eAAgB,iBAChB,aAAc,eACd,oBAAqB,qBACvB,CAAU"}

package/dist/agent/tool/definition.d.ts

@@ -0,0 +1,227 @@
+import { ToolCallId } from "../../primitives/brand.js";
+import { JsonObject, JsonValue } from "../../primitives/json.js";
+import { ContentBlock } from "../../message/content.js";
+import { SdkLogger } from "../../logging/types.js";
+import { ToolSchema } from "../../contract/tool.js";
+//#region src/agent/tool/definition.d.ts
+type ReadonlyToolBehavior<Args extends readonly unknown[], Result> = {
+  bivarianceHack(...args: Args): Result;
+}['bivarianceHack'];
+/** Where a tool call sits in the run, for logging and diagnostics. */
+interface ToolCallPosition {
+  readonly runId?: string;
+  readonly conversationId?: string;
+  /** 1-based turn number within the conversation. */
+  readonly turn: number;
+  /** 1-based step number within the turn. */
+  readonly step: number;
+}
+/** What a tool body receives besides its arguments. */
+interface ToolRunContext extends ToolCallPosition {
+  /** Provider-issued id of this call. */
+  readonly callId: ToolCallId;
+  /** The tool's own name, so shared helpers can report which tool called them. */
+  readonly toolName: string;
+  /**
+   * Cancellation for this call.
+   *
+   * A tool that declares `timeoutMs` is ASSERTING that it forwards this signal;
+   * the timeout is cooperative and cannot interrupt code that ignores it.
+   */
+  readonly signal: AbortSignal;
+  /** Always present on AgentRuntime execution paths; optional for legacy callers. */
+  readonly logger?: SdkLogger;
+  /**
+   * End the turn after this batch of tool calls commits.
+   *
+   * For a tool that IS the answer — submitting a final result, handing off to a
+   * human. The loop still commits every call in the current batch first, so a
+   * parallel sibling's work is never discarded.
+   */
+  concludeTurn(): void;
+  /**
+   * Inject extra context for the next step, beyond this call's result.
+   *
+   * The blocks become a user message the model sees on the following request. Use
+   * it for information the model needs but did not ask for — a reminder that it
+   * has repeated itself, a warning that a file changed underneath it.
+   */
+  addContext(content: string | readonly ContentBlock[]): void;
+}
+/**
+ * How a tool call may be scheduled relative to its siblings.
+ *
+ * Both reference implementations default to `exclusive` and require an explicit
+ * opt-in, because the failure mode of guessing wrong is silent data corruption
+ * from two tools mutating the same state, not a visible error.
+ */
+type ToolExecutionMode = 'parallel' | 'exclusive';
+/** A tool the model can call. */
+interface ToolDefinition<Args = unknown> extends ToolSchema {
+  /**
+   * Validate and narrow raw arguments before {@link execute} sees them.
+   *
+   * The hook exists so this package needs no schema library of its own: plug in
+   * zod, valibot, ajv, or hand-written checks. Throwing here produces an
+   * `INVALID_ARGUMENTS` result the model can correct.
+   *
+   * Omitting it means `execute` receives the parsed JSON UNVALIDATED, typed as
+   * `Args` on trust. That is fine for a tool whose body checks its own inputs.
+   */
+  readonly parse?: ReadonlyToolBehavior<[raw: unknown], Args>;
+  /**
+   * Do the work.
+   * @param args - validated arguments.
+   * @param ctx - call identity, cancellation, and the side channels.
+   * @returns a lossless-JSON value, or nothing.
+   */
+  readonly execute: ReadonlyToolBehavior<[args: Args, ctx: ToolRunContext], Promise<JsonValue | void> | JsonValue | void>;
+  /**
+   * Turn the returned value into what the model reads.
+   *
+   * Defaults to {@link renderJsonValue}: a string is passed through verbatim,
+   * anything else is pretty-printed JSON. Override to give the model prose, or to
+   * return an image block.
+   */
+  readonly render?: ReadonlyToolBehavior<[value: JsonValue | undefined, args: Args], readonly ContentBlock[]>;
+  /**
+   * Metadata for a UI, kept out of what the model sees.
+   *
+   * Must be lossless JSON — it is persisted with the result.
+   */
+  readonly meta?: ReadonlyToolBehavior<[value: JsonValue | undefined, args: Args], JsonObject | undefined>;
+  /**
+   * Wall-clock bound for one call, enforced cooperatively.
+   *
+   * NEVER sent to the model. Declaring it is a promise that {@link execute}
+   * forwards `ctx.signal`, because the pipeline aborts the signal and waits — it
+   * does not abandon the promise, since an orphaned tool would keep mutating state
+   * behind the loop's back.
+   */
+  readonly timeoutMs?: number;
+  /**
+   * Whether this call may run alongside its siblings.
+   *
+   * Fail-closed: only an exact `true` opts in. A throwing or absent classifier
+   * means `exclusive`. Return `true` only when the call cannot observe or mutate
+   * state another concurrent call touches — a pure read of an immutable source
+   * qualifies, "probably fine" does not.
+   */
+  readonly isConcurrencySafe?: ReadonlyToolBehavior<[args: Args], boolean>;
+  /**
+   * Exempt this tool from the turn's tool-call budget and its loop guards.
+   *
+   * For the calls that END work rather than do it: submitting a final result,
+   * asking the user a blocking question, handing a task to another agent. A
+   * budget exists to stop exploration, and a spent budget that also blocks the
+   * only remaining useful action leaves the model with no legal move — the run
+   * then dies mid-plan instead of finishing. Both reference harnesses avoid
+   * that by never failing a call for a limit at all; this flag is the narrow
+   * version of the same rule.
+   *
+   * Exempt calls still count toward the RUN-level ledger limits, so this
+   * cannot be used to escape accounting — only to reach a terminal action.
+   */
+  readonly budgetExempt?: true;
+  /**
+   * Progress/reporting only: calling this tool does not invalidate an accepted
+   * deep-mode completion submission. Examples include updating a visible todo
+   * list after the work has been verified. Never set this for tools that edit
+   * work, obtain new evidence, delegate, or change the user's requirements.
+   * This is independent of budgetExempt and is never sent to the model.
+   */
+  readonly completionExempt?: true;
+  /**
+   * Estimated tokens of text this tool's result may put in front of the model.
+   *
+   * For a tool that knows its own shape: a file reader can ask for room a
+   * one-line status check has no use for. The turn's budget still applies, and
+   * the STRICTER of the two wins — Codex resolves a model-requested
+   * `max_output_tokens` against its deployment policy the same way — so this
+   * can lower a tool's share but never raise it past what the host allows.
+   *
+   * Never sent to the model.
+   */
+  readonly maxOutputTokens?: number;
+}
+/** A tool call that succeeded. */
+interface ToolSuccess {
+  readonly isError: false;
+  /** The raw value the body returned; omitted when post-policy replaces the result. */
+  readonly value: JsonValue | undefined;
+  /** What the model reads. */
+  readonly content: readonly ContentBlock[];
+  /** UI metadata, never shown to the model. */
+  readonly meta?: JsonObject;
+  /** Extra context requested via `ctx.addContext`. */
+  readonly additionalContext?: readonly ContentBlock[];
+  /** Set when the tool called `ctx.concludeTurn()`. */
+  readonly concludesTurn?: true;
+}
+/** A tool call that failed. */
+interface ToolFailure {
+  readonly isError: true;
+  readonly error: {
+    readonly message: string;
+    readonly code: string;
+  };
+  /** What the model reads — the failure, phrased for the model. */
+  readonly content: readonly ContentBlock[];
+  readonly meta?: JsonObject;
+  readonly additionalContext?: readonly ContentBlock[];
+  /**
+   * Typed `never`: a failure must not be able to end the turn.
+   *
+   * Otherwise a denied or crashed tool could silently stop work the user asked
+   * for, which is the opposite of what a failure should do.
+   */
+  readonly concludesTurn?: never;
+}
+/** The outcome of one tool call. */
+type ToolExecutionResult = ToolSuccess | ToolFailure;
+/**
+ * The default {@link ToolDefinition.render}.
+ *
+ * A string is passed through as-is, because a tool that returns prose meant it.
+ * Everything else is indented JSON, which models parse reliably and humans can
+ * read in a transcript.
+ * @param value - the value the body returned.
+ * @returns model-facing blocks.
+ */
+declare function renderJsonValue(value: JsonValue | undefined): readonly ContentBlock[];
+/**
+ * Author a tool with argument types inferred from `parse`.
+ *
+ * Returns a detached frozen execution view. Schema and method references are
+ * captured once while method calls retain the caller object's receiver.
+ *
+ * ```ts
+ * const getWeather = defineTool({
+ *   name: 'get_weather',
+ *   description: 'Current weather for a city.',
+ *   parameters: {
+ *     type: 'object',
+ *     properties: { city: { type: 'string' } },
+ *     required: ['city'],
+ *   },
+ *   parse: raw => WeatherArgs.parse(raw),
+ *   execute: async ({ city }) => ({ tempC: await lookup(city) }),
+ * })
+ * ```
+ * @param definition - the tool.
+ * @returns a new immutable definition, typed.
+ */
+declare function defineTool<Args>(definition: ToolDefinition<Args>): ToolDefinition<Args>;
+/**
+ * Decide how one call may be scheduled.
+ *
+ * Fail-closed on every uncertainty, including a classifier that throws: a tool
+ * whose safety check is broken is not a tool whose safety can be assumed.
+ * @param tool - the definition, or `undefined` for an unknown tool.
+ * @param args - the parsed arguments.
+ * @returns the scheduling mode.
+ */
+declare function executionModeOf(tool: ToolDefinition | undefined, args: unknown): ToolExecutionMode;
+//#endregion
+export { ToolCallPosition, ToolDefinition, ToolExecutionMode, ToolExecutionResult, ToolFailure, ToolRunContext, ToolSuccess, defineTool, executionModeOf, renderJsonValue };
+//# sourceMappingURL=definition.d.ts.map

package/dist/agent/tool/definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","names":[],"sources":["../../../src/agent/tool/definition.ts"],"mappings":";;;;;;KA2BK,qBAAqB,iCAAiC;EACzD,kBAAkB,MAAM,OAAO;;;UAIhB;WACN;WACA;;WAEA;;WAEA;;;UAIM,uBAAuB;;WAE7B,QAAQ;;WAER;;;;;;;WAOA,QAAQ;;WAER,SAAS;;;;;;;;EASlB;;;;;;;;EASA,WAAW,2BAA2B;;;;;;;;;KAU5B;;UAGK,eAAe,wBAAwB;;;;;;;;;;;WAW7C,QAAQ,sBAAsB,eAAe;;;;;;;WAQ7C,SAAS,sBACf,MAAM,MAAM,KAAK,iBAClB,QAAQ,oBAAoB;;;;;;;;WAUrB,SAAS,sBACf,OAAO,uBAAuB,MAAM,gBAC5B;;;;;;WAQF,OAAO,sBACb,OAAO,uBAAuB,MAAM,OACrC;;;;;;;;;WAWO;;;;;;;;;WAUA,oBAAoB,sBAAsB,MAAM;;;;;;;;;;;;;;;WAgBhD;;;;;;;;WASA;;;;;;;;;;;;WAaA;;;UAIM;WACN;;WAEA,OAAO;;WAEP,kBAAkB;;WAElB,OAAO;;WAEP,6BAA6B;;WAE7B;;;UAIM;WACN;WACA;aACE;aACA;;;WAGF,kBAAkB;WAClB,OAAO;WACP,6BAA6B;;;;;;;WAO7B;;;KAIC,sBAAsB,cAAc;;;;;;;;;;iBAWhC,gBAAgB,OAAO,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;iBA8BxD,WAAW,MAAM,YAAY,eAAe,QAAQ,eAAe;;;;;;;;;;iBAanE,gBACd,MAAM,4BACN,gBACC"}

package/dist/agent/tool/definition.js

@@ -0,0 +1,2 @@
+import{captureToolDefinition as e}from"./capture.js";function t(e){return e===void 0?[{type:`text`,text:`(no output)`}]:typeof e==`string`?[{type:`text`,text:e.length===0?`(empty)`:e}]:[{type:`text`,text:JSON.stringify(e,null,2)}]}function n(t){return e(t)}function r(e,t){if(e?.isConcurrencySafe===void 0)return`exclusive`;try{return e.isConcurrencySafe(t)===!0?`parallel`:`exclusive`}catch{return`exclusive`}}export{n as defineTool,r as executionModeOf,t as renderJsonValue};
+//# sourceMappingURL=definition.js.map

package/dist/agent/tool/definition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.js","names":[],"sources":["../../../src/agent/tool/definition.ts"],"sourcesContent":["/**\n * What a tool is, what it receives, and what it produces.\n *\n * Two shape decisions worth stating up front.\n *\n * **The body returns a value, not model-facing text.** `execute` produces a\n * lossless-JSON value; `render` turns it into the blocks the model reads. Keeping\n * them apart means the value can be logged, replayed, asserted on in tests, and\n * handed to a UI, while the model-facing wording stays free to change without\n * invalidating any of that. Simple tools ignore `render` entirely and get a\n * sensible default.\n *\n * **Side channels live on the context, not in the return type.** A tool that wants\n * to end the turn or inject extra context calls `ctx.concludeTurn()` /\n * `ctx.addContext()`. That keeps the common return type trivial — a string or an\n * object — instead of forcing every tool to wrap its result in an envelope.\n *\n * @module ai-agent-sdk/agent/tool/definition\n */\n\nimport type { ToolSchema } from '../../contract/index.ts'\nimport type { ContentBlock } from '../../message/index.ts'\nimport type { ToolCallId } from '../../primitives/index.ts'\nimport type { JsonObject, JsonValue } from '../../primitives/index.ts'\nimport type { SdkLogger } from '../../logging/types.ts'\nimport { captureToolDefinition } from './capture.ts'\n\ntype ReadonlyToolBehavior<Args extends readonly unknown[], Result> = {\n  bivarianceHack(...args: Args): Result\n}['bivarianceHack']\n\n/** Where a tool call sits in the run, for logging and diagnostics. */\nexport interface ToolCallPosition {\n  readonly runId?: string\n  readonly conversationId?: string\n  /** 1-based turn number within the conversation. */\n  readonly turn: number\n  /** 1-based step number within the turn. */\n  readonly step: number\n}\n\n/** What a tool body receives besides its arguments. */\nexport interface ToolRunContext extends ToolCallPosition {\n  /** Provider-issued id of this call. */\n  readonly callId: ToolCallId\n  /** The tool's own name, so shared helpers can report which tool called them. */\n  readonly toolName: string\n  /**\n   * Cancellation for this call.\n   *\n   * A tool that declares `timeoutMs` is ASSERTING that it forwards this signal;\n   * the timeout is cooperative and cannot interrupt code that ignores it.\n   */\n  readonly signal: AbortSignal\n  /** Always present on AgentRuntime execution paths; optional for legacy callers. */\n  readonly logger?: SdkLogger\n\n  /**\n   * End the turn after this batch of tool calls commits.\n   *\n   * For a tool that IS the answer — submitting a final result, handing off to a\n   * human. The loop still commits every call in the current batch first, so a\n   * parallel sibling's work is never discarded.\n   */\n  concludeTurn(): void\n\n  /**\n   * Inject extra context for the next step, beyond this call's result.\n   *\n   * The blocks become a user message the model sees on the following request. Use\n   * it for information the model needs but did not ask for — a reminder that it\n   * has repeated itself, a warning that a file changed underneath it.\n   */\n  addContext(content: string | readonly ContentBlock[]): void\n}\n\n/**\n * How a tool call may be scheduled relative to its siblings.\n *\n * Both reference implementations default to `exclusive` and require an explicit\n * opt-in, because the failure mode of guessing wrong is silent data corruption\n * from two tools mutating the same state, not a visible error.\n */\nexport type ToolExecutionMode = 'parallel' | 'exclusive'\n\n/** A tool the model can call. */\nexport interface ToolDefinition<Args = unknown> extends ToolSchema {\n  /**\n   * Validate and narrow raw arguments before {@link execute} sees them.\n   *\n   * The hook exists so this package needs no schema library of its own: plug in\n   * zod, valibot, ajv, or hand-written checks. Throwing here produces an\n   * `INVALID_ARGUMENTS` result the model can correct.\n   *\n   * Omitting it means `execute` receives the parsed JSON UNVALIDATED, typed as\n   * `Args` on trust. That is fine for a tool whose body checks its own inputs.\n   */\n  readonly parse?: ReadonlyToolBehavior<[raw: unknown], Args>\n\n  /**\n   * Do the work.\n   * @param args - validated arguments.\n   * @param ctx - call identity, cancellation, and the side channels.\n   * @returns a lossless-JSON value, or nothing.\n   */\n  readonly execute: ReadonlyToolBehavior<\n    [args: Args, ctx: ToolRunContext],\n    Promise<JsonValue | void> | JsonValue | void\n  >\n\n  /**\n   * Turn the returned value into what the model reads.\n   *\n   * Defaults to {@link renderJsonValue}: a string is passed through verbatim,\n   * anything else is pretty-printed JSON. Override to give the model prose, or to\n   * return an image block.\n   */\n  readonly render?: ReadonlyToolBehavior<\n    [value: JsonValue | undefined, args: Args],\n    readonly ContentBlock[]\n  >\n\n  /**\n   * Metadata for a UI, kept out of what the model sees.\n   *\n   * Must be lossless JSON — it is persisted with the result.\n   */\n  readonly meta?: ReadonlyToolBehavior<\n    [value: JsonValue | undefined, args: Args],\n    JsonObject | undefined\n  >\n\n  /**\n   * Wall-clock bound for one call, enforced cooperatively.\n   *\n   * NEVER sent to the model. Declaring it is a promise that {@link execute}\n   * forwards `ctx.signal`, because the pipeline aborts the signal and waits — it\n   * does not abandon the promise, since an orphaned tool would keep mutating state\n   * behind the loop's back.\n   */\n  readonly timeoutMs?: number\n\n  /**\n   * Whether this call may run alongside its siblings.\n   *\n   * Fail-closed: only an exact `true` opts in. A throwing or absent classifier\n   * means `exclusive`. Return `true` only when the call cannot observe or mutate\n   * state another concurrent call touches — a pure read of an immutable source\n   * qualifies, \"probably fine\" does not.\n   */\n  readonly isConcurrencySafe?: ReadonlyToolBehavior<[args: Args], boolean>\n\n  /**\n   * Exempt this tool from the turn's tool-call budget and its loop guards.\n   *\n   * For the calls that END work rather than do it: submitting a final result,\n   * asking the user a blocking question, handing a task to another agent. A\n   * budget exists to stop exploration, and a spent budget that also blocks the\n   * only remaining useful action leaves the model with no legal move — the run\n   * then dies mid-plan instead of finishing. Both reference harnesses avoid\n   * that by never failing a call for a limit at all; this flag is the narrow\n   * version of the same rule.\n   *\n   * Exempt calls still count toward the RUN-level ledger limits, so this\n   * cannot be used to escape accounting — only to reach a terminal action.\n   */\n  readonly budgetExempt?: true\n\n  /**\n   * Progress/reporting only: calling this tool does not invalidate an accepted\n   * deep-mode completion submission. Examples include updating a visible todo\n   * list after the work has been verified. Never set this for tools that edit\n   * work, obtain new evidence, delegate, or change the user's requirements.\n   * This is independent of budgetExempt and is never sent to the model.\n   */\n  readonly completionExempt?: true\n\n  /**\n   * Estimated tokens of text this tool's result may put in front of the model.\n   *\n   * For a tool that knows its own shape: a file reader can ask for room a\n   * one-line status check has no use for. The turn's budget still applies, and\n   * the STRICTER of the two wins — Codex resolves a model-requested\n   * `max_output_tokens` against its deployment policy the same way — so this\n   * can lower a tool's share but never raise it past what the host allows.\n   *\n   * Never sent to the model.\n   */\n  readonly maxOutputTokens?: number\n}\n\n/** A tool call that succeeded. */\nexport interface ToolSuccess {\n  readonly isError: false\n  /** The raw value the body returned; omitted when post-policy replaces the result. */\n  readonly value: JsonValue | undefined\n  /** What the model reads. */\n  readonly content: readonly ContentBlock[]\n  /** UI metadata, never shown to the model. */\n  readonly meta?: JsonObject\n  /** Extra context requested via `ctx.addContext`. */\n  readonly additionalContext?: readonly ContentBlock[]\n  /** Set when the tool called `ctx.concludeTurn()`. */\n  readonly concludesTurn?: true\n}\n\n/** A tool call that failed. */\nexport interface ToolFailure {\n  readonly isError: true\n  readonly error: {\n    readonly message: string\n    readonly code: string\n  }\n  /** What the model reads — the failure, phrased for the model. */\n  readonly content: readonly ContentBlock[]\n  readonly meta?: JsonObject\n  readonly additionalContext?: readonly ContentBlock[]\n  /**\n   * Typed `never`: a failure must not be able to end the turn.\n   *\n   * Otherwise a denied or crashed tool could silently stop work the user asked\n   * for, which is the opposite of what a failure should do.\n   */\n  readonly concludesTurn?: never\n}\n\n/** The outcome of one tool call. */\nexport type ToolExecutionResult = ToolSuccess | ToolFailure\n\n/**\n * The default {@link ToolDefinition.render}.\n *\n * A string is passed through as-is, because a tool that returns prose meant it.\n * Everything else is indented JSON, which models parse reliably and humans can\n * read in a transcript.\n * @param value - the value the body returned.\n * @returns model-facing blocks.\n */\nexport function renderJsonValue(value: JsonValue | undefined): readonly ContentBlock[] {\n  if (value === undefined) return [{ type: 'text', text: '(no output)' }]\n  if (typeof value === 'string') {\n    return [{ type: 'text', text: value.length === 0 ? '(empty)' : value }]\n  }\n  return [{ type: 'text', text: JSON.stringify(value, null, 2) }]\n}\n\n/**\n * Author a tool with argument types inferred from `parse`.\n *\n * Returns a detached frozen execution view. Schema and method references are\n * captured once while method calls retain the caller object's receiver.\n *\n * ```ts\n * const getWeather = defineTool({\n *   name: 'get_weather',\n *   description: 'Current weather for a city.',\n *   parameters: {\n *     type: 'object',\n *     properties: { city: { type: 'string' } },\n *     required: ['city'],\n *   },\n *   parse: raw => WeatherArgs.parse(raw),\n *   execute: async ({ city }) => ({ tempC: await lookup(city) }),\n * })\n * ```\n * @param definition - the tool.\n * @returns a new immutable definition, typed.\n */\nexport function defineTool<Args>(definition: ToolDefinition<Args>): ToolDefinition<Args> {\n  return captureToolDefinition(definition)\n}\n\n/**\n * Decide how one call may be scheduled.\n *\n * Fail-closed on every uncertainty, including a classifier that throws: a tool\n * whose safety check is broken is not a tool whose safety can be assumed.\n * @param tool - the definition, or `undefined` for an unknown tool.\n * @param args - the parsed arguments.\n * @returns the scheduling mode.\n */\nexport function executionModeOf(\n  tool: ToolDefinition | undefined,\n  args: unknown,\n): ToolExecutionMode {\n  if (tool?.isConcurrencySafe === undefined) return 'exclusive'\n  try {\n    return tool.isConcurrencySafe(args) === true ? 'parallel' : 'exclusive'\n  } catch {\n    return 'exclusive'\n  }\n}\n"],"mappings":"qDA8OA,SAAgB,EAAgB,EAAuD,CAKrF,OAJI,IAAU,IAAA,GAAkB,CAAC,CAAE,KAAM,OAAQ,KAAM,aAAc,CAAC,EAClE,OAAO,GAAU,SACZ,CAAC,CAAE,KAAM,OAAQ,KAAM,EAAM,SAAW,EAAI,UAAY,CAAM,CAAC,EAEjE,CAAC,CAAE,KAAM,OAAQ,KAAM,KAAK,UAAU,EAAO,KAAM,CAAC,CAAE,CAAC,CAChE,CAwBA,SAAgB,EAAiB,EAAwD,CACvF,OAAO,EAAsB,CAAU,CACzC,CAWA,SAAgB,EACd,EACA,EACmB,CACnB,GAAI,GAAM,oBAAsB,IAAA,GAAW,MAAO,YAClD,GAAI,CACF,OAAO,EAAK,kBAAkB,CAAI,IAAM,GAAO,WAAa,WAC9D,MAAQ,CACN,MAAO,WACT,CACF"}