@agen-ai/agent-runtime 0.4.2 → 0.4.4

package/dist/sessions.d.ts

@@ -1,4 +1,4 @@
-import type { AgentAuthenticationFlow, AgentCollaborationControlInput, AgentCollaborationNode, AgentCollaborationSpawnInput, AgentConfigurationCatalog, AgentConfigurationSelectionInput, AgentError, AgentGeneratedResourceDescriptor, AgentGeneratedResourceId, AgentManagedContentCatalog, AgentOperationCatalog, AgentOperationInvocation, AgentOperationResult, AgentRequestResolution, AgentSessionBinding, AgentSessionBranchSource, AgentSessionConfiguration, AgentSessionId, AgentTurnId, AgentTurnInputContent, AgentTurnInteractionMode, AgentTurnInputPart, AgentTurnInterruptionReason } from "@agen-ai/agent-protocol";
+import type { AgentAuthenticationFlow, AgentCollaborationControlInput, AgentCollaborationNode, AgentCollaborationSpawnInput, AgentConfigurationCatalog, AgentConfigurationSelectionInput, AgentError, AgentGeneratedResourceDescriptor, AgentGeneratedResourceId, AgentManagedContentCatalog, AgentOperationCatalog, AgentOperationInvocation, AgentOperationResult, AgentRequestResolution, AgentSessionBinding, AgentSessionBranchSource, AgentSessionConfiguration, AgentSessionId, AgentStructuredOutputRequest, AgentTurnId, AgentTurnInputContent, AgentTurnInteractionMode, AgentTurnInputPart, AgentTurnInterruptionReason } from "@agen-ai/agent-protocol";
 import type { AgentNativeContinuationContext, AgentNativeContinuationSupport } from "./nativeContinuations/types.js";
 import type { MaybePromise } from "./foundation.js";
 import type { AgentSessionHostBinding, AgentSessionHostBindingSupport } from "./hostBindings/types.js";
@@ -6,6 +6,7 @@ import type { AgentProviderOutput } from "./outputs.js";
 import type { AgentArtifactCandidate } from "./artifacts.js";
 import type { AgentProviderSessionInteractionContext, AgentSessionInteractionContext, AgentSessionInteractionSupport } from "./sessionInteractions/types.js";
 import type { AgentEnvironmentObservationPort } from "./environment/types.js";
+import type { AgentExecutionInput, AgentExecutionInputSupport } from "./executionInput/types.js";
 export interface AgentProviderSessionContext {
     readonly sessionId: AgentSessionId;
     readonly workingDirectory: string;
@@ -17,6 +18,7 @@ export interface AgentProviderSessionContext {
 export type AgentSessionBindingCreatedObserver = (binding: AgentSessionBinding) => void;
 export interface AgentProviderCreateSessionInput extends AgentProviderSessionContext {
     readonly onBindingCreated: AgentSessionBindingCreatedObserver;
+    readonly output?: AgentStructuredOutputRequest;
 }
 export interface AgentProviderResumeSessionInput extends AgentProviderSessionContext {
     readonly binding: AgentSessionBinding;
@@ -33,6 +35,7 @@ export interface AgentProviderStartTurnInput {
     readonly parts: readonly AgentTurnInputPart[];
     readonly summary?: string;
     readonly deadlineAt?: string;
+    readonly output?: AgentStructuredOutputRequest;
     readonly signal?: AbortSignal;
     readonly onProviderExecutionStarted?: AgentProviderExecutionStartedObserver;
 }
@@ -55,6 +58,7 @@ export type AgentRequestResolutionResult = Readonly<{
 export interface AgentProviderTurnExecution {
     readonly turnId: AgentTurnId;
     readonly outputs: AsyncIterable<AgentProviderOutput>;
+    readonly input?: AgentExecutionInput;
     readonly resolveRequest: (input: AgentProviderResolveRequestInput) => Promise<AgentRequestResolutionResult>;
 }
 export interface AgentProviderInterruptTurnInput {
@@ -215,6 +219,7 @@ export type AgentProviderAuthentication = Readonly<{
     cancel: (input: AgentProviderAuthenticationCancelInput) => MaybePromise<AgentProviderOperationResult>;
 }>;
 export interface AgentProviderAdapter {
+    readonly executionInput?: AgentExecutionInputSupport;
     readonly sessionInteractions?: AgentSessionInteractionSupport;
     readonly hostBinding?: AgentSessionHostBindingSupport;
     readonly nativeContinuations?: AgentNativeContinuationSupport;
@@ -229,6 +234,7 @@ export type AgentSessionOpenContext = Omit<AgentProviderSessionContext, "interac
 }>;
 export type AgentCreateSessionInput = AgentSessionOpenContext & Readonly<{
     onBindingCreated: AgentSessionBindingCreatedObserver;
+    output?: AgentStructuredOutputRequest;
 }>;
 export type AgentResumeSessionInput = AgentSessionOpenContext & Readonly<{
     binding: AgentSessionBinding;

package/dist/structuredOutput/admission.d.ts

@@ -0,0 +1,16 @@
+import { type AgentCapabilities, type AgentStructuredOutputRequest } from "@agen-ai/agent-protocol";
+export interface AgentStructuredOutputBinding {
+    readonly request: AgentStructuredOutputRequest;
+    readonly maxOutputBytes: number;
+}
+export declare function admitAgentStructuredOutputOpening(input: Readonly<{
+    capabilities: AgentCapabilities;
+    operation: "create" | "resume" | "branch";
+    output: unknown;
+}>): AgentStructuredOutputBinding | undefined;
+export declare function admitAgentStructuredOutputTurn(input: Readonly<{
+    capabilities: AgentCapabilities;
+    binding?: AgentStructuredOutputBinding;
+    output: unknown;
+}>): AgentStructuredOutputBinding | undefined;
+//# sourceMappingURL=admission.d.ts.map

package/dist/structuredOutput/admission.js

@@ -0,0 +1,89 @@
+import {
+  AgentProtocolValidationError,
+  agentProtocolSerializedJsonBytes,
+  parseAgentOutputSchema
+} from "@agen-ai/agent-protocol";
+import { throwAgentProviderContractError } from "../contractErrors.js";
+import { hasExactOwnKeys } from "../internal/objectShape.js";
+function parseOutputRequest(input, maxOutputBytes) {
+  const invalid = () => {
+    throw new AgentProtocolValidationError([{
+      code: "invalid_structured_output_request",
+      message: "Structured output must be a plain json_schema request with only kind and schema data properties.",
+      path: ["output"]
+    }]);
+  };
+  if (input === null || typeof input !== "object") return invalid();
+  let kind;
+  let schema;
+  try {
+    const prototype = Object.getPrototypeOf(input);
+    if (prototype !== Object.prototype && prototype !== null || !hasExactOwnKeys(input, ["kind", "schema"])) return invalid();
+    const kindDescriptor = Object.getOwnPropertyDescriptor(input, "kind");
+    const schemaDescriptor = Object.getOwnPropertyDescriptor(input, "schema");
+    if (!kindDescriptor || !("value" in kindDescriptor) || !kindDescriptor.enumerable || !schemaDescriptor || !("value" in schemaDescriptor) || !schemaDescriptor.enumerable) return invalid();
+    kind = kindDescriptor.value;
+    schema = schemaDescriptor.value;
+  } catch (error) {
+    if (error instanceof AgentProtocolValidationError) throw error;
+    return invalid();
+  }
+  if (kind !== "json_schema") return invalid();
+  return Object.freeze({ kind, schema: parseAgentOutputSchema(schema, { maxOutputBytes }) });
+}
+function admitRequest(capabilities, output) {
+  const capability = capabilities.turns.structuredOutput;
+  if (capability.kind === "unsupported") {
+    throwAgentProviderContractError(
+      capabilities.providerKey,
+      "structured_output_unsupported",
+      "Provider does not support structured output."
+    );
+  }
+  const request = parseOutputRequest(output, capability.maxOutputBytes);
+  if (agentProtocolSerializedJsonBytes(request.schema) > capability.maxSchemaBytes) {
+    throwAgentProviderContractError(
+      capabilities.providerKey,
+      "invalid_structured_output",
+      "Structured output schema exceeds the provider's advertised byte limit."
+    );
+  }
+  return Object.freeze({ request, maxOutputBytes: capability.maxOutputBytes });
+}
+function admitAgentStructuredOutputOpening(input) {
+  if (input.output === void 0) return void 0;
+  const { capabilities } = input;
+  if (input.operation !== "create") {
+    throwAgentProviderContractError(
+      capabilities.providerKey,
+      "structured_output_unsupported",
+      "Structured output cannot be restored through resume or branch."
+    );
+  }
+  const capability = capabilities.turns.structuredOutput;
+  if (capability.kind === "supported" && capability.scope !== "session") {
+    throwAgentProviderContractError(
+      capabilities.providerKey,
+      "structured_output_scope_mismatch",
+      "Provider accepts structured output only when starting a turn."
+    );
+  }
+  return admitRequest(capabilities, input.output);
+}
+function admitAgentStructuredOutputTurn(input) {
+  if (input.output === void 0) return input.binding;
+  const { capabilities } = input;
+  const capability = capabilities.turns.structuredOutput;
+  if (input.binding || capability.kind === "supported" && capability.scope !== "turn") {
+    throwAgentProviderContractError(
+      capabilities.providerKey,
+      "structured_output_scope_mismatch",
+      "Session-scoped structured output cannot be overridden or supplied on a turn."
+    );
+  }
+  return admitRequest(capabilities, input.output);
+}
+export {
+  admitAgentStructuredOutputOpening,
+  admitAgentStructuredOutputTurn
+};

package/dist/structuredOutput/candidate.d.ts

@@ -0,0 +1,22 @@
+import { type AgentOutputSchema, type AgentStructuredOutputResult, type AgentStructuredOutputUnavailableReason } from "@agen-ai/agent-protocol";
+export type AgentStructuredOutputCandidate = Readonly<{
+    kind: "json_text";
+    text: string;
+}> | Readonly<{
+    kind: "json_value";
+    value: unknown;
+}> | Readonly<{
+    kind: "unavailable";
+    reason: AgentStructuredOutputUnavailableReason;
+}>;
+export interface CreateAgentStructuredOutputCandidateInput {
+    readonly schema: AgentOutputSchema;
+    readonly maxOutputBytes?: number;
+    readonly candidate: AgentStructuredOutputCandidate;
+}
+export type AgentStructuredOutputCandidateResult = Exclude<AgentStructuredOutputResult, Readonly<{
+    kind: "not_requested";
+}>>;
+export declare function validateAgentStructuredOutputCandidate(schema: AgentOutputSchema, value: unknown, maxOutputBytes: number): AgentStructuredOutputCandidateResult;
+export declare function createAgentStructuredOutputCandidate(input: CreateAgentStructuredOutputCandidateInput): AgentStructuredOutputCandidateResult;
+//# sourceMappingURL=candidate.d.ts.map

package/dist/structuredOutput/candidate.js

@@ -0,0 +1,64 @@
+import {
+  AGENT_OUTPUT_RAW_JSON_BYTES_LIMIT,
+  AGENT_OUTPUT_VALUE_BYTES_LIMIT,
+  AGENT_STRUCTURED_OUTPUT_UNAVAILABLE_REASONS,
+  parseAgentOutputSchema,
+  validateAgentOutputValue
+} from "@agen-ai/agent-protocol";
+function freezeJson(value) {
+  if (value === null || typeof value !== "object") return;
+  for (const child of Object.values(value)) freezeJson(child);
+  Object.freeze(value);
+}
+function validateAgentStructuredOutputCandidate(schema, value, maxOutputBytes) {
+  const parsed = validateAgentOutputValue(schema, value, { maxOutputBytes });
+  if (!parsed.success) {
+    if (parsed.issues.some((issue) => issue.code === "output_limit_exceeded")) {
+      return Object.freeze({ kind: "unavailable", reason: "output_limit_exceeded" });
+    }
+    if (parsed.issues.some((issue) => issue.code === "invalid_json_data")) {
+      return Object.freeze({ kind: "unavailable", reason: "invalid_json" });
+    }
+    return Object.freeze({ kind: "unavailable", reason: "schema_mismatch", issues: Object.freeze(parsed.issues.map((issue) => Object.freeze({
+      ...issue,
+      path: Object.freeze([...issue.path])
+    }))) });
+  }
+  freezeJson(parsed.data);
+  return Object.freeze({ kind: "json", value: parsed.data });
+}
+function createAgentStructuredOutputCandidate(input) {
+  const schema = parseAgentOutputSchema(input.schema);
+  const maxOutputBytes = input.maxOutputBytes ?? AGENT_OUTPUT_VALUE_BYTES_LIMIT;
+  if (!Number.isSafeInteger(maxOutputBytes) || maxOutputBytes <= 0 || maxOutputBytes > AGENT_OUTPUT_VALUE_BYTES_LIMIT) {
+    throw new RangeError("Structured output byte limit must be a positive integer within the portable profile ceiling.");
+  }
+  const { candidate } = input;
+  switch (candidate.kind) {
+    case "unavailable":
+      if (!AGENT_STRUCTURED_OUTPUT_UNAVAILABLE_REASONS.includes(candidate.reason)) {
+        throw new TypeError("Structured output candidate has an unsupported unavailable reason.");
+      }
+      return Object.freeze({ kind: "unavailable", reason: candidate.reason });
+    case "json_text": {
+      if (typeof candidate.text !== "string") throw new TypeError("Structured JSON text candidate must contain a string.");
+      if (candidate.text.length > AGENT_OUTPUT_RAW_JSON_BYTES_LIMIT || Buffer.byteLength(candidate.text, "utf8") > AGENT_OUTPUT_RAW_JSON_BYTES_LIMIT) {
+        return Object.freeze({ kind: "unavailable", reason: "output_limit_exceeded" });
+      }
+      let value;
+      try {
+        value = JSON.parse(candidate.text);
+      } catch {
+        return Object.freeze({ kind: "unavailable", reason: "invalid_json" });
+      }
+      return validateAgentStructuredOutputCandidate(schema, value, maxOutputBytes);
+    }
+    case "json_value":
+      return validateAgentStructuredOutputCandidate(schema, candidate.value, maxOutputBytes);
+  }
+  throw new TypeError("Structured output candidate kind is unsupported.");
+}
+export {
+  createAgentStructuredOutputCandidate,
+  validateAgentStructuredOutputCandidate
+};

package/dist/structuredOutput/validation.d.ts

@@ -0,0 +1,8 @@
+import type { AgentProviderKey, AgentStructuredOutputResult } from "@agen-ai/agent-protocol";
+import type { AgentStructuredOutputBinding } from "./admission.js";
+export declare function validateAgentStructuredOutputResult(input: Readonly<{
+    providerKey: AgentProviderKey;
+    binding?: AgentStructuredOutputBinding;
+    result: AgentStructuredOutputResult;
+}>): AgentStructuredOutputResult;
+//# sourceMappingURL=validation.d.ts.map

package/dist/structuredOutput/validation.js

@@ -0,0 +1,26 @@
+import { throwAgentProviderContractError } from "../contractErrors.js";
+import { validateAgentStructuredOutputCandidate } from "./candidate.js";
+function validateAgentStructuredOutputResult(input) {
+  const { binding, result } = input;
+  if (!binding) {
+    if (result.kind !== "not_requested") {
+      throwAgentProviderContractError(
+        input.providerKey,
+        "invalid_structured_output",
+        "Provider reported structured output for a turn without an admitted schema."
+      );
+    }
+    return result;
+  }
+  if (result.kind === "not_requested") {
+    throwAgentProviderContractError(
+      input.providerKey,
+      "invalid_structured_output",
+      "Provider omitted the admitted structured-output contract."
+    );
+  }
+  return result.kind === "json" ? validateAgentStructuredOutputCandidate(binding.request.schema, result.value, binding.maxOutputBytes) : result;
+}
+export {
+  validateAgentStructuredOutputResult
+};

package/dist/testing/conformance.d.ts

@@ -1,4 +1,4 @@
-import { type AgentCollaborationSpawnInput, type AgentConfigurationSelectionInput, type AgentEnvironmentId, type AgentGeneratedResourceId, type AgentOperationInvocation, type AgentRequest, type AgentRequestResolution, type AgentSessionBinding, type AgentSessionBranchSource, type AgentSessionConfiguration, type AgentSessionId, type AgentTurnId, type AgentTurnInputContent } from "@agen-ai/agent-protocol";
+import { type AgentCollaborationSpawnInput, type AgentJsonObject, type AgentOutputSchema, type AgentConfigurationSelectionInput, type AgentEnvironmentId, type AgentGeneratedResourceId, type AgentOperationInvocation, type AgentRequest, type AgentRequestResolution, type AgentSessionBinding, type AgentSessionBranchSource, type AgentSessionConfiguration, type AgentSessionId, type AgentTurnId, type AgentTurnInputContent } from "@agen-ai/agent-protocol";
 import type { AgentProviderDriver, AgentProviderInstanceDefinition } from "../providerDriver.js";
 import type { AgentProviderStartTurnInput } from "../sessions.js";
 export interface AgentProviderConformanceScenario {
@@ -23,6 +23,25 @@ export interface AgentProviderConformanceScenario {
     }>) => AgentRequestResolution | undefined | Promise<AgentRequestResolution | undefined>;
     readonly branchSource?: (binding: AgentSessionBinding, turnId: AgentTurnId) => AgentSessionBranchSource;
     readonly steeringInput?: AgentTurnInputContent;
+    readonly structuredOutput?: AgentStructuredOutputConformanceScenario;
+}
+export interface AgentStructuredOutputConformanceScenario {
+    readonly sessionId: AgentSessionId;
+    readonly plainSessionId: AgentSessionId;
+    readonly schema: AgentOutputSchema;
+    readonly alternateSchema: AgentOutputSchema;
+    /** Turn scope uses schema then alternateSchema; session scope uses schema for both turns. */
+    readonly turns: readonly [
+        Readonly<{
+            turn: Omit<AgentProviderStartTurnInput, "output">;
+            expectedValue: AgentJsonObject;
+        }>,
+        Readonly<{
+            turn: Omit<AgentProviderStartTurnInput, "output">;
+            expectedValue: AgentJsonObject;
+        }>
+    ];
+    readonly plainTurn: Omit<AgentProviderStartTurnInput, "output">;
 }
 export interface AgentProviderConformanceReport {
     readonly providerKey: string;

package/dist/testing/conformance.js

@@ -1,3 +1,4 @@
+import { isDeepStrictEqual } from "node:util";
 import {
   matchesAgentSessionBinding,
   parseAgentEnvironmentId,
@@ -5,6 +6,7 @@ import {
   parseAgentTurnId
 } from "@agen-ai/agent-protocol";
 import { isAgentOperationAbortError } from "../foundation.js";
+import { AgentProviderContractError } from "../contractErrors.js";
 import {
   createAgentProviderRegistry,
   AgentProviderRegistryError
@@ -61,7 +63,7 @@ async function advanceToStartedTurn(session, input) {
     throw error;
   }
 }
-async function collectRemainingOutputs(started, resolutionFor, beforeClose) {
+async function collectRemainingOutputs(started, resolutionFor, beforeClose, closeOnSuccess = true) {
   const requests = /* @__PURE__ */ new Map();
   const tasks = [];
   let acceptingRequests = true;
@@ -119,7 +121,6 @@ async function collectRemainingOutputs(started, resolutionFor, beforeClose) {
         requests.delete(event.payload.requestId);
       } else if (event.type === "turn.completed") {
         abortRequests();
-        return;
       }
     }
   })();
@@ -134,7 +135,7 @@ async function collectRemainingOutputs(started, resolutionFor, beforeClose) {
   }
   acceptingRequests = false;
   abortRequests();
-  const closing = started.session.close({ reason: failures.size > 0 ? "contract_rejected" : "idle" });
+  const closing = failures.size > 0 || closeOnSuccess ? started.session.close({ reason: failures.size > 0 ? "contract_rejected" : "idle" }) : Promise.resolve();
   const [closed, read, inspected, returned] = await Promise.allSettled([closing, reader, checked, started.iterator.return?.()]);
   if (closed?.status === "rejected") failures.add(closed.reason);
   for (const result of [read, inspected]) {
@@ -163,6 +164,99 @@ function hasStableTurnBoundary(events) {
   );
   return boundary?.type === "turn.completed" || boundary?.type === "turn.state_changed" && boundary.payload.state === "waiting_for_request";
 }
+async function requireStructuredRejection(operation, code) {
+  let rejected = false;
+  try {
+    await operation();
+  } catch (error) {
+    requireCheck(
+      error instanceof AgentProviderContractError && error.code === code,
+      "structured_output",
+      "Structured output rejection did not preserve its admission classification."
+    );
+    rejected = true;
+  }
+  requireCheck(rejected, "structured_output", "Unsupported structured output was admitted.");
+}
+async function checkStructuredOutput(input) {
+  const { adapter, capability, scenario } = input;
+  const schema = scenario.structuredOutput?.schema ?? {
+    type: "object",
+    properties: { title: { type: "string" } },
+    required: ["title"],
+    additionalProperties: false
+  };
+  const request = { kind: "json_schema", schema };
+  if (capability.kind === "unsupported") {
+    await requireStructuredRejection(async () => {
+      const unexpected = await adapter.createSession({
+        sessionId: scenario.abortedSessionId,
+        workingDirectory: scenario.workingDirectory,
+        configuration: scenario.configuration,
+        onBindingCreated() {
+        },
+        output: request
+      });
+      await unexpected.close({ reason: "contract_rejected" });
+    }, "structured_output_unsupported");
+    await requireStructuredRejection(() => input.plainSession.startTurn({ ...scenario.turn, output: request }), "structured_output_unsupported");
+    return ["structured_output_unsupported"];
+  }
+  const fixture = scenario.structuredOutput;
+  requireCheck(fixture !== void 0, "structured_output", "Supported structured output requires two schema/result fixtures and an ordinary turn.");
+  let bound;
+  let plain;
+  let failure;
+  const open = (sessionId, bind) => adapter.createSession({
+    sessionId,
+    workingDirectory: scenario.workingDirectory,
+    configuration: scenario.configuration,
+    onBindingCreated() {
+    },
+    ...bind ? { output: request } : {}
+  });
+  try {
+    bound = await open(fixture.sessionId, capability.scope === "session");
+    for (const [index, turnFixture] of fixture.turns.entries()) {
+      const selected = { kind: "json_schema", schema: index === 0 ? schema : fixture.alternateSchema };
+      if (capability.scope === "session") {
+        await requireStructuredRejection(() => bound.startTurn({ ...turnFixture.turn, output: selected }), "structured_output_scope_mismatch");
+      }
+      const started2 = await advanceToStartedTurn(bound, { ...turnFixture.turn, ...capability.scope === "turn" ? { output: selected } : {} });
+      const observed2 = await collectRemainingOutputs(started2, scenario.resolutionFor, void 0, false);
+      const terminal2 = semanticEvents(observed2.outputs).at(-1);
+      requireCheck(
+        terminal2?.type === "turn.completed" && terminal2.payload.outcome === "completed" && terminal2.payload.structuredOutput.kind === "json" && isDeepStrictEqual(terminal2.payload.structuredOutput.value, turnFixture.expectedValue),
+        "structured_output",
+        "Structured turn did not finish with the expected schema-valid native value."
+      );
+    }
+    if (capability.scope === "session") {
+      await bound.close({ reason: "idle" });
+      plain = await open(fixture.plainSessionId, false);
+    } else plain = bound;
+    const started = await advanceToStartedTurn(plain, fixture.plainTurn);
+    const observed = await collectRemainingOutputs(started, scenario.resolutionFor, void 0, false);
+    const terminal = semanticEvents(observed.outputs).at(-1);
+    requireCheck(
+      terminal?.type === "turn.completed" && terminal.payload.outcome === "completed" && terminal.payload.structuredOutput.kind === "not_requested",
+      "structured_output_lifetime",
+      "An ordinary turn inherited a structured output binding."
+    );
+    return ["structured_output", "structured_output_lifetime"];
+  } catch (error) {
+    failure = { error };
+    throw error;
+  } finally {
+    const settled = await Promise.allSettled([bound?.close({ reason: "idle" }), plain === bound ? void 0 : plain?.close({ reason: "idle" })]);
+    const failures = settled.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+    if (failures.length > 0) throw new AggregateError(
+      failure ? [failure.error, ...failures] : failures,
+      "Structured conformance cleanup failed.",
+      failure ? { cause: failure.error } : void 0
+    );
+  }
+}
 async function runAgentProviderConformance(scenario) {
   const checks = [];
   try {
@@ -337,6 +431,12 @@ async function runAgentProviderConformance(scenario) {
       }
     }
     checks.push("environment_session");
+    checks.push(...await checkStructuredOutput({
+      adapter: instance.adapter,
+      capability: instance.capabilities.turns.structuredOutput,
+      plainSession: created,
+      scenario
+    }));
     const aborted = new AbortController();
     aborted.abort(new DOMException("Conformance abort.", "AbortError"));
     try {

package/dist/testing/fakeProvider.js

@@ -44,10 +44,11 @@ function defaultCapabilities(providerKey) {
     }
   };
   return parseAgentCapabilities({
-    protocolVersion: 12,
+    protocolVersion: 13,
     providerKey,
     sessions: { create: true, resume: true, branch: { kind: "through_turn" } },
     turns: {
+      structuredOutput: { kind: "unsupported" },
       interactionModes: ["default"],
       interrupt: true,
       steer: { kind: "supported", input }
@@ -166,7 +167,7 @@ function sessionBinding(state, sessionId) {
   };
 }
 function eventBase(sessionId, turnId, occurredAt) {
-  return { protocolVersion: 12, sessionId, turnId, occurredAt };
+  return { protocolVersion: 13, sessionId, turnId, occurredAt };
 }
 function fakeEnvironmentSnapshot(environmentId) {
   return parseAgentEnvironmentSnapshot({
@@ -293,7 +294,7 @@ function fakeSession(input) {
       yield createAgentEventOutput({
         ...eventBase(input.context.sessionId, turnInput.turnId, input.now()),
         type: "turn.completed",
-        payload: { outcome: "canceled", reason: "Fake provider interrupted." }
+        payload: { structuredOutput: { kind: "not_requested" }, outcome: "canceled", reason: "Fake provider interrupted." }
       });
       return;
     }
@@ -353,7 +354,7 @@ function fakeSession(input) {
     yield createAgentEventOutput({
       ...eventBase(input.context.sessionId, turnInput.turnId, occurredAt),
       type: "turn.completed",
-      payload: { outcome: interruptedTurns.has(turnInput.turnId) ? "canceled" : "completed", reason: "Fake provider completed." }
+      payload: { structuredOutput: { kind: "not_requested" }, outcome: interruptedTurns.has(turnInput.turnId) ? "canceled" : "completed", reason: "Fake provider completed." }
     });
   };
   const close = async () => {

package/dist/turnExecution/execution.d.ts

@@ -1,4 +1,6 @@
 import { type AgentProviderKey, type AgentTurnId } from "@agen-ai/agent-protocol";
+import type { AgentExecutionInputSupport } from "../executionInput/types.js";
+import { type createExecutionInputCensus } from "../executionInput/lifetime.js";
 import type { AgentProviderOutput } from "../outputs.js";
 import type { AgentSessionAdmission } from "../sessionAdmission.js";
 import type { AgentProviderStartTurnInput, AgentProviderTurnExecution } from "../sessions.js";
@@ -6,13 +8,19 @@ import { type AgentTurnRequestAdmission, type PendingAgentRequest, type Suspende
 export interface ValidatedAgentTurnExecution {
     readonly execution: AgentProviderTurnExecution;
     readonly hasEntered: () => boolean;
-    readonly stop: (reason: Error) => void;
+    readonly stop: (reason: Error, inputReason?: "closed" | "interrupted" | "native_failed") => void;
+    readonly closeInputAdmission: () => void;
     readonly join: () => Promise<void>;
     readonly suspendRequests: () => SuspendedAgentTurnRequests;
     readonly completed: Promise<void>;
 }
 type ExecutionOptions = Readonly<{
     providerKey: AgentProviderKey;
+    executionInputSupport?: AgentExecutionInputSupport;
+    executionInputCensus: ReturnType<typeof createExecutionInputCensus>;
+    ownsExecution: () => boolean;
+    requireInputContext: () => void;
+    structuredOutputBound: boolean;
     pendingRequests: Map<string, PendingAgentRequest>;
     sessionAdmission: AgentSessionAdmission;
     inFlightOperations: Set<Promise<void>>;