@agen-ai/agent-runtime 0.4.3 → 0.4.4

package/dist/executionInput/lifetime.js

@@ -0,0 +1,241 @@
+import { AgentProviderContractError, AgentProviderDelegatedOperationError } from "../contractErrors.js";
+import { throwIfAgentOperationAborted } from "../foundation.js";
+import { serializedAgentJsonValueBytes } from "../internal/serializedJsonBytes.js";
+import { parseAgentExecutionInputMessage, validateAgentExecutionInputReceipt } from "./validation.js";
+const RECEIPT_TIMEOUT_MS = 3e4;
+const DRAIN_TIMEOUT_MS = 3e4;
+const MAX_SESSION_IDENTITIES = 4096;
+const MAX_SESSION_ID_BYTES = 1048576;
+function createExecutionInputCensus(providerKey, exhausted) {
+  const identities = /* @__PURE__ */ new Set();
+  let retainedBytes = 0;
+  return {
+    claim(messageId) {
+      if (identities.has(messageId)) throw new AgentProviderContractError(
+        providerKey,
+        "execution_input_identity_reused",
+        "Execution input reused a message ID in this session generation."
+      );
+      const bytes = Buffer.byteLength(messageId, "utf8");
+      if (identities.size >= MAX_SESSION_IDENTITIES || retainedBytes + bytes > MAX_SESSION_ID_BYTES) {
+        exhausted();
+        throw new AgentProviderContractError(
+          providerKey,
+          "execution_input_identity_limit_exceeded",
+          "Execution input exhausted this session generation's bounded message identity census."
+        );
+      }
+      identities.add(messageId);
+      retainedBytes += bytes;
+    }
+  };
+}
+function unconfirmed(messageId, reason) {
+  return Object.freeze({ status: "unconfirmed", messageId, reason });
+}
+function uncertainError() {
+  return Object.freeze({
+    category: "transport",
+    code: "execution_input_delivery_uncertain",
+    message: "The native execution-input receipt was not authoritatively observed.",
+    recovery: Object.freeze({ kind: "none" })
+  });
+}
+function createExecutionInputOwner(input) {
+  let phase = { kind: "reserved" };
+  let enteredMessages = 0;
+  let retainedBytes = 0;
+  let failure;
+  let uncertain = false;
+  const messages = /* @__PURE__ */ new Map();
+  const work = /* @__PURE__ */ new Set();
+  const observe = (entry, outcome) => entry.observation.resolve(outcome);
+  const closeAdmission = (reason) => {
+    if (phase.kind === "settled") return;
+    if (phase.kind === "reserved" || phase.kind === "accepting") phase = { kind: "closing", ...reason === void 0 ? {} : { reason } };
+    else if (reason !== void 0 && phase.reason === void 0) phase = { kind: phase.kind, reason };
+    if (reason !== void 0) for (const entry of messages.values()) observe(entry, unconfirmed(entry.messageId, reason));
+  };
+  const fail = (cause) => {
+    failure ??= cause instanceof Error ? cause : new Error("Execution-input observation failed.", { cause });
+    input.fence();
+    closeAdmission("correlation_lost");
+    return failure;
+  };
+  const fenceUncertainty = () => {
+    uncertain = true;
+    input.fence();
+    closeAdmission("correlation_lost");
+  };
+  const finish = (entry) => {
+    if (entry.phase.kind === "settled") return;
+    entry.phase = { kind: "settled" };
+    messages.delete(entry.messageId);
+    retainedBytes -= entry.bytes;
+  };
+  const track = (promise) => {
+    work.add(promise);
+    void promise.then(() => work.delete(promise), (cause) => {
+      work.delete(promise);
+      fail(cause);
+    });
+  };
+  const unavailable = () => {
+    throw new AgentProviderContractError(
+      input.providerKey,
+      "active_turn_mismatch",
+      "Execution input requires the exact entered execution with open admission."
+    );
+  };
+  const sendMessage = async (candidate) => {
+    const message = parseAgentExecutionInputMessage(candidate);
+    throwIfAgentOperationAborted(message.signal);
+    input.requireAdmission();
+    if (phase.kind !== "accepting") return unavailable();
+    const port = phase.port;
+    const bytes = serializedAgentJsonValueBytes({
+      messageId: message.messageId,
+      parts: message.parts.map((part) => ({ type: part.type, text: part.text })),
+      ...message.summary === void 0 ? {} : { summary: message.summary }
+    });
+    if (enteredMessages >= input.support.limits.maxMessagesPerExecution || messages.size >= input.support.limits.maxOutstandingMessages || retainedBytes + bytes > input.support.limits.maxBufferedBytes) {
+      throw new AgentProviderContractError(
+        input.providerKey,
+        "execution_input_capacity_exhausted",
+        "Execution input exceeds this execution's bounded message capacity."
+      );
+    }
+    input.census.claim(message.messageId);
+    const observation = Promise.withResolvers();
+    const entry = { messageId: message.messageId, bytes, observation, phase: { kind: "entered", payload: message } };
+    messages.set(entry.messageId, entry);
+    enteredMessages += 1;
+    retainedBytes += bytes;
+    const receipt = Promise.withResolvers();
+    const context = { providerKey: input.providerKey, turnId: input.turnId, messageId: message.messageId, support: input.support };
+    const signal = message.signal === void 0 ? input.signal : AbortSignal.any([input.signal, message.signal]);
+    let waitState = "waiting";
+    const deadlineAt = Date.now() + RECEIPT_TIMEOUT_MS;
+    const cleanup = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", lost);
+    };
+    const lost = () => {
+      if (waitState === "settled") return;
+      waitState = "settled";
+      cleanup();
+      fenceUncertainty();
+      receipt.resolve(Object.freeze({ status: "delivery_uncertain", messageId: entry.messageId, error: uncertainError() }));
+    };
+    const deliver = (value) => {
+      if (waitState === "settled") return;
+      if (Date.now() >= deadlineAt) {
+        lost();
+        return;
+      }
+      waitState = "settled";
+      cleanup();
+      receipt.resolve(value);
+    };
+    const rejectReceipt = (cause) => {
+      if (waitState === "settled") return;
+      waitState = "settled";
+      cleanup();
+      receipt.reject(cause);
+    };
+    const timer = setTimeout(lost, RECEIPT_TIMEOUT_MS);
+    signal.addEventListener("abort", lost, { once: true });
+    let actual;
+    try {
+      actual = Promise.resolve(port.sendMessage({ ...message, signal }));
+    } catch (cause) {
+      fail(cause);
+      rejectReceipt(new AgentProviderDelegatedOperationError(input.providerKey, "send_execution_input", cause));
+      finish(entry);
+      return receipt.promise;
+    }
+    const actualReceipt = actual.then((value) => validateAgentExecutionInputReceipt(value, context));
+    track(actualReceipt.then(async (result) => {
+      if (result.status === "accepted") {
+        if (entry.phase.kind !== "settled") entry.phase = { kind: "accepted", payload: message };
+        deliver(Object.freeze({ status: "accepted", messageId: entry.messageId, settled: observation.promise }));
+        try {
+          const outcome = await result.settled;
+          observe(entry, outcome);
+          if (outcome.status === "unconfirmed" && outcome.reason === "correlation_lost") {
+            fail(new AgentProviderContractError(
+              input.providerKey,
+              "execution_input_correlation_lost",
+              "Provider lost ownership correlation for an accepted execution input."
+            ));
+          }
+        } catch (cause) {
+          fail(cause);
+        } finally {
+          finish(entry);
+        }
+      } else {
+        if (result.status === "delivery_uncertain") fenceUncertainty();
+        deliver(result);
+        finish(entry);
+      }
+    }, (cause) => {
+      const delegated = new AgentProviderDelegatedOperationError(input.providerKey, "send_execution_input", cause);
+      fail(cause);
+      rejectReceipt(delegated);
+      finish(entry);
+    }));
+    if (signal.aborted) lost();
+    return receipt.promise;
+  };
+  const join = async (producer) => {
+    let timer;
+    const deadline = new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new AgentProviderContractError(
+        input.providerKey,
+        "invalid_operation_result",
+        "Execution-input ownership did not drain before its deadline."
+      )), DRAIN_TIMEOUT_MS);
+    });
+    try {
+      if (producer !== void 0) await Promise.race([Promise.all([producer, ...work]), deadline]);
+      while (work.size > 0) await Promise.race([Promise.all([...work]), deadline]);
+    } finally {
+      if (timer !== void 0) clearTimeout(timer);
+    }
+  };
+  return {
+    port: Object.freeze({ kind: "supported", support: input.support, sendMessage }),
+    attach(port) {
+      if (phase.kind === "reserved") phase = { kind: "accepting", port };
+      else if (phase.kind !== "closing") throw new AgentProviderContractError(
+        input.providerKey,
+        "invalid_operation_result",
+        "Provider execution-input port was attached more than once."
+      );
+    },
+    closeAdmission,
+    async drain(producer) {
+      closeAdmission();
+      phase = { kind: "draining", ...phase.kind === "closing" && phase.reason !== void 0 ? { reason: phase.reason } : {} };
+      try {
+        await join(producer);
+      } catch (cause) {
+        fail(cause);
+      }
+      if (failure) throw failure;
+      phase = { kind: "settled" };
+    },
+    join,
+    get failed() {
+      return failure !== void 0;
+    },
+    get retainsOwnership() {
+      return uncertain || failure !== void 0 || work.size > 0;
+    }
+  };
+}
+export {
+  createExecutionInputCensus,
+  createExecutionInputOwner
+};

package/dist/executionInput/types.d.ts

@@ -0,0 +1,61 @@
+import type { AgentError, AgentOperationInputCapability, AgentTurnId, AgentTurnInputContent } from "@agen-ai/agent-protocol";
+declare const executionInputMessageIdBrand: unique symbol;
+/** Process-local submission identity; distinct from a turn or human request ID. */
+export type AgentExecutionInputMessageId = string & {
+    readonly [executionInputMessageIdBrand]: true;
+};
+export type AgentExecutionInputSupport = Readonly<{
+    kind: "unsupported";
+}> | Readonly<{
+    kind: "supported";
+    delivery: "current_or_owned_continuation";
+    consumptionReporting: "message_ids" | "unavailable";
+    input: AgentOperationInputCapability;
+    limits: Readonly<{
+        maxOutstandingMessages: number;
+        maxMessagesPerExecution: number;
+        maxBufferedBytes: number;
+    }>;
+}>;
+/** Initial admission accepts text only, using the canonical turn-content bounds. */
+export interface AgentExecutionInputMessage extends AgentTurnInputContent {
+    readonly messageId: AgentExecutionInputMessageId;
+    readonly signal?: AbortSignal;
+}
+/** Consumption is attribution to native work, not proof that the instruction was obeyed. */
+export type AgentExecutionInputOutcome = Readonly<{
+    status: "consumed";
+    messageId: AgentExecutionInputMessageId;
+    turnId: AgentTurnId;
+    placement: "original_native_command" | "owned_native_continuation";
+}> | Readonly<{
+    status: "unconfirmed";
+    messageId: AgentExecutionInputMessageId;
+    reason: "provider_does_not_report_consumption" | "closed" | "interrupted" | "native_failed" | "correlation_lost";
+}>;
+/** In-process receipt and settlement handle; never a wire or persistence format. */
+export type AgentExecutionInputReceipt = Readonly<{
+    status: "accepted";
+    messageId: AgentExecutionInputMessageId;
+    settled: Promise<AgentExecutionInputOutcome>;
+}> | Readonly<{
+    status: "rejected";
+    messageId: AgentExecutionInputMessageId;
+    error: AgentError;
+}> | Readonly<{
+    status: "delivery_uncertain";
+    messageId: AgentExecutionInputMessageId;
+    error: AgentError;
+}>;
+/** Keep the sole outputs reader running while awaiting a receipt and its settlement. */
+export type AgentExecutionInput = Readonly<{
+    kind: "unsupported";
+}> | Readonly<{
+    kind: "supported";
+    support: Extract<AgentExecutionInputSupport, {
+        kind: "supported";
+    }>;
+    sendMessage: (input: AgentExecutionInputMessage) => Promise<AgentExecutionInputReceipt>;
+}>;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/executionInput/validation.d.ts

@@ -0,0 +1,25 @@
+import { type AgentProviderKey, type AgentTextInputPart, type AgentTurnId } from "@agen-ai/agent-protocol";
+import type { AgentExecutionInput, AgentExecutionInputMessage, AgentExecutionInputMessageId, AgentExecutionInputOutcome, AgentExecutionInputReceipt, AgentExecutionInputSupport } from "./types.js";
+export declare const AGENT_EXECUTION_INPUT_LIMITS: Readonly<{
+    maxOutstandingMessages: 2;
+    maxMessagesPerExecution: 16;
+    maxBufferedBytes: 1048576;
+}>;
+export declare function parseAgentExecutionInputMessageId(value: unknown): AgentExecutionInputMessageId;
+export declare function validateAgentExecutionInputSupport(value: unknown): AgentExecutionInputSupport | undefined;
+export declare function validateAgentExecutionInputPort(candidate: AgentExecutionInput | undefined, declared: AgentExecutionInputSupport | undefined, providerKey: AgentProviderKey): AgentExecutionInput | undefined;
+export declare function parseAgentExecutionInputMessage(value: unknown): Omit<AgentExecutionInputMessage, "parts"> & Readonly<{
+    parts: readonly AgentTextInputPart[];
+}>;
+type ReceiptContext = Readonly<{
+    providerKey: AgentProviderKey;
+    messageId: AgentExecutionInputMessageId;
+    turnId: AgentTurnId;
+    support: Extract<AgentExecutionInputSupport, {
+        kind: "supported";
+    }>;
+}>;
+export declare function validateAgentExecutionInputOutcome(value: unknown, context: ReceiptContext): AgentExecutionInputOutcome;
+export declare function validateAgentExecutionInputReceipt(value: unknown, context: ReceiptContext): AgentExecutionInputReceipt;
+export {};
+//# sourceMappingURL=validation.d.ts.map

package/dist/executionInput/validation.js

@@ -0,0 +1,178 @@
+import {
+  parseAgentError,
+  parseAgentTurnId,
+  parseAgentTurnInputContent
+} from "@agen-ai/agent-protocol";
+import { throwAgentProviderContractError } from "../contractErrors.js";
+import { parseAgentProviderTechnicalId } from "../foundation.js";
+import { hasExactOwnKeys } from "../internal/objectShape.js";
+const AGENT_EXECUTION_INPUT_LIMITS = Object.freeze({
+  maxOutstandingMessages: 2,
+  maxMessagesPerExecution: 16,
+  maxBufferedBytes: 1048576
+});
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function record(value) {
+  if (!isRecord(value)) throw new TypeError("Expected an execution-input object.");
+  return value;
+}
+function parseAgentExecutionInputMessageId(value) {
+  return parseAgentProviderTechnicalId(value, "execution input message ID");
+}
+function positiveLimit(value, ceiling) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1 || value > ceiling) {
+    throw new TypeError("Execution-input limits must be positive integers within SDK ceilings.");
+  }
+  return value;
+}
+function isUnsupported(value) {
+  return isRecord(value) && hasExactOwnKeys(value, ["kind"]) && value.kind === "unsupported";
+}
+function validateAgentExecutionInputSupport(value) {
+  if (value === void 0) return void 0;
+  if (isUnsupported(value)) return Object.freeze({ kind: "unsupported" });
+  const support = record(value);
+  if (!hasExactOwnKeys(support, ["kind", "delivery", "consumptionReporting", "input", "limits"]) || support.kind !== "supported" || support.delivery !== "current_or_owned_continuation" || support.consumptionReporting !== "message_ids" && support.consumptionReporting !== "unavailable") {
+    throw new TypeError("Invalid execution-input support descriptor.");
+  }
+  const input = record(support.input);
+  if (!hasExactOwnKeys(input, ["text", "images", "contentReferences"]) || input.text !== true || !isUnsupported(input.images) || !isUnsupported(input.contentReferences)) {
+    throw new TypeError("Execution input currently supports text only.");
+  }
+  const limits = record(support.limits);
+  if (!hasExactOwnKeys(limits, ["maxOutstandingMessages", "maxMessagesPerExecution", "maxBufferedBytes"])) {
+    throw new TypeError("Invalid execution-input limits.");
+  }
+  const maxMessagesPerExecution = positiveLimit(limits.maxMessagesPerExecution, AGENT_EXECUTION_INPUT_LIMITS.maxMessagesPerExecution);
+  const maxOutstandingMessages = positiveLimit(limits.maxOutstandingMessages, AGENT_EXECUTION_INPUT_LIMITS.maxOutstandingMessages);
+  if (maxOutstandingMessages > maxMessagesPerExecution) {
+    throw new TypeError("Outstanding execution inputs cannot exceed the execution message limit.");
+  }
+  return Object.freeze({
+    kind: "supported",
+    delivery: support.delivery,
+    consumptionReporting: support.consumptionReporting,
+    input: Object.freeze({
+      text: true,
+      images: Object.freeze({ kind: "unsupported" }),
+      contentReferences: Object.freeze({ kind: "unsupported" })
+    }),
+    limits: Object.freeze({
+      maxOutstandingMessages,
+      maxMessagesPerExecution,
+      maxBufferedBytes: positiveLimit(limits.maxBufferedBytes, AGENT_EXECUTION_INPUT_LIMITS.maxBufferedBytes)
+    })
+  });
+}
+function validateAgentExecutionInputPort(candidate, declared, providerKey) {
+  try {
+    if (candidate === void 0 && declared?.kind !== "supported") return void 0;
+    if (candidate?.kind === "unsupported" && hasExactOwnKeys(candidate, ["kind"]) && declared?.kind !== "supported") {
+      return Object.freeze({ kind: "unsupported" });
+    }
+    if (candidate?.kind !== "supported" || declared?.kind !== "supported" || !hasExactOwnKeys(candidate, ["kind", "support", "sendMessage"]) || typeof candidate.sendMessage !== "function") {
+      throw new TypeError("Execution input is undeclared or missing its supported port.");
+    }
+    const support = validateAgentExecutionInputSupport(candidate.support);
+    if (support?.kind !== "supported" || support.delivery !== declared.delivery || support.consumptionReporting !== declared.consumptionReporting || support.limits.maxOutstandingMessages !== declared.limits.maxOutstandingMessages || support.limits.maxMessagesPerExecution !== declared.limits.maxMessagesPerExecution || support.limits.maxBufferedBytes !== declared.limits.maxBufferedBytes) {
+      throw new TypeError("Execution-input support differs from the adapter declaration.");
+    }
+    return Object.freeze({ kind: "supported", support, sendMessage: candidate.sendMessage.bind(candidate) });
+  } catch {
+    return throwAgentProviderContractError(
+      providerKey,
+      "capability_port_mismatch",
+      "Provider execution input does not match its adapter support declaration."
+    );
+  }
+}
+function parseAgentExecutionInputMessage(value) {
+  const input = record(value);
+  const keys = [
+    "messageId",
+    "parts",
+    ...Object.hasOwn(input, "summary") ? ["summary"] : [],
+    ...Object.hasOwn(input, "signal") ? ["signal"] : []
+  ];
+  if (!hasExactOwnKeys(input, keys) || input.signal !== void 0 && !(input.signal instanceof AbortSignal)) {
+    throw new TypeError("Invalid execution-input message envelope.");
+  }
+  const messageId = parseAgentExecutionInputMessageId(input.messageId);
+  const content = parseAgentTurnInputContent({
+    parts: input.parts,
+    ...input.summary === void 0 ? {} : { summary: input.summary }
+  });
+  const parts = content.parts.map((part) => {
+    if (part.type !== "text") throw new TypeError("Execution input currently accepts text parts only.");
+    return Object.freeze({ type: part.type, text: part.text });
+  });
+  return Object.freeze({
+    messageId,
+    parts: Object.freeze(parts),
+    ...content.summary === void 0 ? {} : { summary: content.summary },
+    ...input.signal === void 0 ? {} : { signal: input.signal }
+  });
+}
+function validateAgentExecutionInputOutcome(value, context) {
+  try {
+    const outcome = record(value);
+    const messageId = parseAgentExecutionInputMessageId(outcome.messageId);
+    if (messageId !== context.messageId) throw new TypeError("Execution-input outcome changed message identity.");
+    if (outcome.status === "consumed" && hasExactOwnKeys(outcome, ["status", "messageId", "turnId", "placement"]) && context.support.consumptionReporting === "message_ids" && (outcome.placement === "original_native_command" || outcome.placement === "owned_native_continuation")) {
+      const turnId = parseAgentTurnId(outcome.turnId);
+      if (turnId !== context.turnId) throw new TypeError("Execution-input consumption changed execution identity.");
+      return Object.freeze({ status: "consumed", messageId, turnId, placement: outcome.placement });
+    }
+    if (outcome.status === "unconfirmed" && hasExactOwnKeys(outcome, ["status", "messageId", "reason"]) && (outcome.reason === "closed" || outcome.reason === "interrupted" || outcome.reason === "native_failed" || outcome.reason === "correlation_lost" || outcome.reason === "provider_does_not_report_consumption" && context.support.consumptionReporting === "unavailable")) {
+      return Object.freeze({ status: "unconfirmed", messageId, reason: outcome.reason });
+    }
+    throw new TypeError("Invalid execution-input outcome.");
+  } catch {
+    return throwAgentProviderContractError(
+      context.providerKey,
+      "invalid_operation_result",
+      "Provider returned an invalid execution-input outcome."
+    );
+  }
+}
+function validateAgentExecutionInputReceipt(value, context) {
+  try {
+    const receipt = record(value);
+    const settlement = Object.hasOwn(receipt, "settled") ? Promise.resolve(receipt.settled) : void 0;
+    void settlement?.catch(() => {
+    });
+    const messageId = parseAgentExecutionInputMessageId(receipt.messageId);
+    if (messageId !== context.messageId) throw new TypeError("Execution-input receipt changed message identity.");
+    if (receipt.status === "accepted" && hasExactOwnKeys(receipt, ["status", "messageId", "settled"]) && isRecord(receipt.settled) && typeof receipt.settled.then === "function" && settlement) {
+      const settled = settlement.then((outcome) => validateAgentExecutionInputOutcome(outcome, context), () => throwAgentProviderContractError(
+        context.providerKey,
+        "invalid_operation_result",
+        "Provider execution-input settlement rejected."
+      ));
+      void settled.catch(() => {
+      });
+      return Object.freeze({ status: "accepted", messageId, settled });
+    }
+    if ((receipt.status === "rejected" || receipt.status === "delivery_uncertain") && hasExactOwnKeys(receipt, ["status", "messageId", "error"])) {
+      return Object.freeze({ status: receipt.status, messageId, error: parseAgentError(receipt.error) });
+    }
+    throw new TypeError("Invalid execution-input receipt.");
+  } catch {
+    return throwAgentProviderContractError(
+      context.providerKey,
+      "invalid_operation_result",
+      "Provider returned an invalid execution-input receipt."
+    );
+  }
+}
+export {
+  AGENT_EXECUTION_INPUT_LIMITS,
+  parseAgentExecutionInputMessage,
+  parseAgentExecutionInputMessageId,
+  validateAgentExecutionInputOutcome,
+  validateAgentExecutionInputPort,
+  validateAgentExecutionInputReceipt,
+  validateAgentExecutionInputSupport
+};

package/dist/generation/cleanup.d.ts

@@ -0,0 +1,15 @@
+import type { AgentProviderSession } from "../sessions.js";
+export declare function createGenerationCleanupOwner(input: Readonly<{
+    turnId: Parameters<Extract<AgentProviderSession["interruption"], {
+        kind: "supported";
+    }>["interruptTurn"]>[0]["turnId"];
+    stopCallbacks: () => void;
+}>): {
+    retain: <T>(work: Promise<T>) => Promise<T>;
+    setOpening(work: Promise<AgentProviderSession>): void;
+    markEntered(): void;
+    markTerminal(): void;
+    cleanup(failed: boolean): Promise<void>;
+};
+export type GenerationCleanupOwner = ReturnType<typeof createGenerationCleanupOwner>;
+//# sourceMappingURL=cleanup.d.ts.map

package/dist/generation/cleanup.js

@@ -0,0 +1,108 @@
+import { AgentProviderSessionCleanupError } from "../contractErrors.js";
+import { AGENT_GENERATION_CLEANUP_TIMEOUT_MS, waitForGenerationWork } from "./deadline.js";
+function createGenerationCleanupOwner(input) {
+  const pending = /* @__PURE__ */ new Set();
+  let opening;
+  let session;
+  let openingCleanup;
+  let entered = false;
+  let terminal = false;
+  let interrupted = false;
+  let stopping = false;
+  let closed = false;
+  let close;
+  let closeFailed = false;
+  let attempt;
+  let cleanupSignal;
+  function retain(work) {
+    pending.add(work);
+    void work.then(() => pending.delete(work), () => pending.delete(work));
+    return work;
+  }
+  function startSessionCleanup(failed) {
+    if (!session || closed) return;
+    if (failed && entered && !terminal && !interrupted && session.interruption.kind === "supported") {
+      interrupted = true;
+      try {
+        retain(Promise.resolve(session.interruption.interruptTurn({
+          turnId: input.turnId,
+          reason: "other",
+          ...cleanupSignal === void 0 ? {} : { signal: cleanupSignal }
+        })));
+      } catch {
+      }
+    }
+    if (close) return;
+    try {
+      close = Promise.resolve(session.close({ reason: failed ? "error" : "idle", ...cleanupSignal === void 0 ? {} : { signal: cleanupSignal } }));
+    } catch (error) {
+      close = Promise.reject(error);
+    }
+    const current = close;
+    retain(current);
+    void current.then(() => {
+      closed = true;
+    }, () => {
+      if (close === current) closeFailed = true;
+    });
+  }
+  return {
+    retain,
+    setOpening(work) {
+      opening = work;
+      retain(work);
+      void work.then((opened) => {
+        session = opened;
+        if (stopping) startSessionCleanup(true);
+      }, (error) => {
+        if (error instanceof AgentProviderSessionCleanupError) openingCleanup = error;
+      });
+    },
+    markEntered() {
+      entered = true;
+    },
+    markTerminal() {
+      terminal = true;
+    },
+    cleanup(failed) {
+      if (attempt) return attempt;
+      stopping = true;
+      if (closeFailed) {
+        close = void 0;
+        closeFailed = false;
+      }
+      input.stopCallbacks();
+      const controller = new AbortController();
+      cleanupSignal = controller.signal;
+      const expiresAt = Date.now() + AGENT_GENERATION_CLEANUP_TIMEOUT_MS;
+      const timeoutError = new Error("Object generation cleanup exceeded its deadline.");
+      const timeout = setTimeout(() => controller.abort(timeoutError), AGENT_GENERATION_CLEANUP_TIMEOUT_MS);
+      startSessionCleanup(failed);
+      const drain = async () => {
+        if (opening) {
+          try {
+            session = await opening;
+          } catch (error) {
+            if (error instanceof AgentProviderSessionCleanupError) openingCleanup = error;
+          }
+        }
+        if (openingCleanup) await openingCleanup.retryCleanup();
+        startSessionCleanup(failed);
+        if (close) await close;
+        while (pending.size > 0) await Promise.allSettled([...pending]);
+      };
+      const work = waitForGenerationWork(drain(), controller.signal).then(() => {
+        if (Date.now() >= expiresAt) throw timeoutError;
+      }).finally(() => {
+        clearTimeout(timeout);
+        cleanupSignal = void 0;
+        attempt = void 0;
+      });
+      attempt = work;
+      return work;
+    }
+  };
+}
+export {
+  createGenerationCleanupOwner
+};

package/dist/generation/deadline.d.ts

@@ -0,0 +1,16 @@
+export declare const AGENT_GENERATION_TIMEOUT_MS = 300000;
+export declare const AGENT_GENERATION_MAX_TIMEOUT_MS = 3600000;
+export declare const AGENT_GENERATION_OBSERVER_TIMEOUT_MS = 30000;
+export declare const AGENT_GENERATION_REQUEST_TIMEOUT_MS = 300000;
+export declare const AGENT_GENERATION_RESPONSE_TIMEOUT_MS = 30000;
+export declare const AGENT_GENERATION_CLEANUP_TIMEOUT_MS = 30000;
+export declare const AGENT_GENERATION_REQUEST_LIMIT = 8;
+export declare function waitForGenerationWork<T>(work: Promise<T>, signal: AbortSignal): Promise<T>;
+export declare function createGenerationDeadline(deadlineAt: number, callerSignal?: AbortSignal): {
+    signal: AbortSignal;
+    check(): void;
+    stop(error: unknown): void;
+    dispose(): void;
+};
+export declare function waitForBoundedGenerationWork<T>(work: Promise<T>, signal: AbortSignal, timeoutMs: number, error: Error): Promise<T>;
+//# sourceMappingURL=deadline.d.ts.map