@agen-ai/agent-runtime 0.4.3 → 0.4.5

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>>;

package/dist/turnExecution/execution.js

@@ -5,8 +5,11 @@ import {
 import { AgentProviderContractError, AgentProviderDelegatedOperationError, throwAgentProviderContractError } from "../contractErrors.js";
 import { throwIfAgentOperationAborted } from "../foundation.js";
 import { hasExactOwnKeys } from "../internal/objectShape.js";
+import { validateAgentExecutionInputPort } from "../executionInput/validation.js";
+import { createExecutionInputOwner } from "../executionInput/lifetime.js";
 import { validateAgentRequestResolutionResult } from "./receipts.js";
 import { createAgentTurnRequestAdmission } from "./requests.js";
+import { createAgentTurnTerminalBuffer } from "./terminalBuffer.js";
 function createValidatedAgentTurnExecution(input) {
   return createExecution(input, { kind: "caller", input: input.turnInput, start: input.start });
 }
@@ -17,14 +20,17 @@ function createExecution(input, origin) {
   const turnId = origin.kind === "caller" ? origin.input.turnId : origin.turnId;
   const callerSignal = origin.kind === "caller" ? origin.input.signal : void 0;
   const lifetime = new AbortController();
+  let inputOwner;
   const validateCandidate = (candidate) => {
-    if (candidate === null || typeof candidate !== "object" || candidate.turnId !== turnId || !hasExactOwnKeys(candidate, ["turnId", "outputs", "resolveRequest"]) || typeof candidate.resolveRequest !== "function" || !candidate.outputs || typeof candidate.outputs[Symbol.asyncIterator] !== "function") {
+    if (candidate === null || typeof candidate !== "object" || candidate.turnId !== turnId || !hasExactOwnKeys(candidate, ["turnId", "outputs", "resolveRequest", ...Object.hasOwn(candidate, "input") ? ["input"] : []]) || typeof candidate.resolveRequest !== "function" || !candidate.outputs || typeof candidate.outputs[Symbol.asyncIterator] !== "function") {
       throwAgentProviderContractError(
         input.providerKey,
         origin.kind === "native" ? "invalid_native_continuation" : "invalid_operation_result",
         "Provider returned an invalid turn execution."
       );
     }
+    const port = validateAgentExecutionInputPort(candidate.input, input.executionInputSupport, input.providerKey);
+    if (port?.kind === "supported") inputOwner?.attach(port);
     return candidate;
   };
   let state;
@@ -54,6 +60,8 @@ function createExecution(input, origin) {
     resolveDisposition = resolve;
   });
   let source;
+  let sourceExhausted = false;
+  let terminalTail;
   const requests = createAgentTurnRequestAdmission({
     providerKey: input.providerKey,
     sessionAdmission: input.sessionAdmission,
@@ -61,6 +69,40 @@ function createExecution(input, origin) {
     canRestore: () => state.kind === "entered" && !input.isTerminal(),
     canRestoreRequest: input.canRestoreRequest
   });
+  let resolvingRequests = 0;
+  if (origin.kind === "caller" && input.executionInputSupport?.kind === "supported") {
+    inputOwner = createExecutionInputOwner({
+      providerKey: input.providerKey,
+      turnId,
+      support: input.executionInputSupport,
+      census: input.executionInputCensus,
+      signal: lifetime.signal,
+      fence: input.retire,
+      requireAdmission() {
+        input.requireUsable();
+        if (state.kind !== "entered" || !input.ownsExecution() || input.isTerminal()) {
+          throwAgentProviderContractError(
+            input.providerKey,
+            "active_turn_mismatch",
+            "Execution input does not identify the exact active entered execution."
+          );
+        }
+        if (input.structuredOutputBound) throwAgentProviderContractError(
+          input.providerKey,
+          "structured_output_unsupported",
+          "Schema-bound execution cannot admit additional input."
+        );
+        input.requireInputContext();
+        if (requests.hasUnclaimedRequest() || resolvingRequests > 0) {
+          throwAgentProviderContractError(
+            input.providerKey,
+            "request_pending",
+            "Execution input cannot enter while a human request or its response remains unsettled."
+          );
+        }
+      }
+    });
+  }
   let acquired = false;
   let pulling = false;
   let returnPromise;
@@ -75,8 +117,11 @@ function createExecution(input, origin) {
     return new DOMException("The turn execution was stopped.", "AbortError");
   };
   const detachAbort = () => callerSignal?.removeEventListener("abort", abort);
-  const stop = (reason) => {
+  const stop = (reason, inputReason = "native_failed") => {
     if (state.kind === "settled" || state.kind === "stopped") return;
+    inputOwner?.closeAdmission(inputReason);
+    terminalTail?.clear();
+    terminalTail = void 0;
     const entered = dispatched || state.kind === "entered" || state.kind === "entering";
     state = { kind: "stopped", reason };
     requests.withdraw();
@@ -97,7 +142,7 @@ function createExecution(input, origin) {
     } catch (error) {
       if (error instanceof Error) reason = error;
     }
-    stop(reason);
+    stop(reason, "interrupted");
   };
   callerSignal?.addEventListener("abort", abort, { once: true });
   const track = (operation) => {
@@ -105,6 +150,7 @@ function createExecution(input, origin) {
     void operation.then(() => nativeOperations.delete(operation), () => nativeOperations.delete(operation));
     return operation;
   };
+  const pullNative = () => track(Promise.resolve().then(() => state.kind === "entered" ? sourceExhausted ? { done: true, value: void 0 } : state.iterator.next() : origin.kind === "native" && state.kind === "settled" ? { done: true, value: void 0 } : Promise.reject(abortError())));
   let joinPromise;
   const join = () => {
     if (joinPromise) return joinPromise;
@@ -113,6 +159,7 @@ function createExecution(input, origin) {
         await Promise.allSettled([...nativeOperations, ...input.inFlightOperations]);
       }
       if (source?.return) await source.return();
+      await inputOwner?.join();
     })();
     joinPromise = attempt;
     void attempt.catch(() => {
@@ -150,6 +197,7 @@ function createExecution(input, origin) {
       settle = resolve;
     });
     input.inFlightOperations.add(settlement);
+    resolvingRequests += 1;
     try {
       try {
         requestInput.onProviderExecutionStarted?.();
@@ -174,6 +222,7 @@ function createExecution(input, origin) {
       if (result.status === "delivery_uncertain") input.retire();
       return result;
     } finally {
+      resolvingRequests -= 1;
       input.inFlightOperations.delete(settlement);
       settle();
     }
@@ -186,6 +235,12 @@ function createExecution(input, origin) {
     let removeAbort = () => {
     };
     try {
+      if (terminalTail) {
+        throwIfAgentOperationAborted(lifetime.signal);
+        const trailing = terminalTail.take();
+        if (trailing !== void 0) return { done: false, value: trailing };
+        terminalTail = void 0;
+      }
       if (state.kind === "parked") {
         ready();
         await dispatch;
@@ -224,7 +279,7 @@ function createExecution(input, origin) {
         }
       }
       if (state.kind !== "entered") throw abortError();
-      const nativePull = track(Promise.resolve().then(() => state.kind === "entered" ? state.iterator.next() : origin.kind === "native" && state.kind === "settled" ? { done: true, value: void 0 } : Promise.reject(abortError())));
+      const nativePull = pullNative();
       const stopped = new Promise((_, reject) => {
         const onAbort = () => reject(abortError());
         lifetime.signal.addEventListener("abort", onAbort, { once: true });
@@ -236,6 +291,24 @@ function createExecution(input, origin) {
         if (origin.kind === "native" && currentState().kind === "settled") throwAgentProviderContractError(input.providerKey, "invalid_native_continuation", "A no-work execution emitted native output.");
         observedOutput = true;
         const output = input.observe(result.value, requests);
+        if (inputOwner && output.kind === "event" && output.event.type === "turn.completed") {
+          inputOwner.closeAdmission();
+          const buffer = createAgentTurnTerminalBuffer(input.providerKey, output);
+          const exhaustSource = (async () => {
+            for (; ; ) {
+              const trailing = await Promise.race([pullNative(), stopped]);
+              throwIfAgentOperationAborted(lifetime.signal);
+              if (trailing.done) {
+                sourceExhausted = true;
+                return;
+              }
+              buffer.append(input.observe(trailing.value, requests));
+            }
+          })();
+          await Promise.race([inputOwner.drain(exhaustSource), stopped]);
+          throwIfAgentOperationAborted(lifetime.signal);
+          terminalTail = buffer;
+        }
         return { done: false, value: output };
       }
       while (input.inFlightOperations.size > 0) {
@@ -247,7 +320,7 @@ function createExecution(input, origin) {
       requests.withdraw();
       state = { kind: "settled" };
       detachAbort();
-      input.release();
+      if (!inputOwner?.retainsOwnership) input.release();
       complete();
       return { done: true, value: void 0 };
     } catch (error) {
@@ -256,6 +329,8 @@ function createExecution(input, origin) {
         void input.abandon().catch(() => {
         });
       }
+      if (inputOwner?.failed) void input.abandon().catch(() => {
+      });
       throw error;
     } finally {
       removeAbort();
@@ -268,7 +343,7 @@ function createExecution(input, origin) {
       if (returnPromise) return returnPromise;
       if (state.kind === "settled") return Promise.resolve({ done: true, value: void 0 });
       const entered = dispatched || state.kind === "entered" || source !== void 0;
-      stop(new DOMException("The turn output consumer returned.", "AbortError"));
+      stop(new DOMException("The turn output consumer returned.", "AbortError"), "closed");
       if (entered && origin.kind === "native") {
         void input.abandon().catch(() => {
         });
@@ -285,10 +360,16 @@ function createExecution(input, origin) {
     }
   });
   return {
-    execution: Object.freeze({ turnId, outputs, resolveRequest }),
+    execution: Object.freeze({
+      turnId,
+      outputs,
+      resolveRequest,
+      ...inputOwner === void 0 ? origin.kind === "native" && input.executionInputSupport?.kind === "supported" ? { input: Object.freeze({ kind: "unsupported" }) } : {} : { input: inputOwner.port }
+    }),
     hasEntered: () => dispatched && state.kind === "parked" || state.kind === "entering" || state.kind === "entered",
     stop,
     join,
+    closeInputAdmission: () => inputOwner?.closeAdmission(),
     suspendRequests: requests.suspend,
     completed,
     readerReady,

package/dist/turnExecution/terminalBuffer.d.ts

@@ -0,0 +1,9 @@
+import type { AgentProviderKey } from "@agen-ai/agent-protocol";
+import type { AgentProviderOutput } from "../outputs.js";
+/** Holds validated observations in native order until the terminal and its input ownership can publish. */
+export declare function createAgentTurnTerminalBuffer(providerKey: AgentProviderKey, terminal: AgentProviderOutput): {
+    append(output: AgentProviderOutput): void;
+    take(): AgentProviderOutput | undefined;
+    clear(): void;
+};
+//# sourceMappingURL=terminalBuffer.d.ts.map

package/dist/turnExecution/terminalBuffer.js

@@ -0,0 +1,38 @@
+import { throwAgentProviderContractError } from "../contractErrors.js";
+const MAX_TRAILING_OUTPUTS = 32;
+const MAX_RETAINED_BYTES = 16 * 1024 * 1024;
+function retainedOutputBytes(output) {
+  if (output.kind === "artifact" && output.candidate.source.kind === "bytes") {
+    const metadata = { ...output, candidate: { ...output.candidate, source: { kind: "bytes" } } };
+    return output.candidate.source.bytes.byteLength + Buffer.byteLength(JSON.stringify(metadata), "utf8");
+  }
+  return Buffer.byteLength(JSON.stringify(output), "utf8");
+}
+function createAgentTurnTerminalBuffer(providerKey, terminal) {
+  const trailing = [];
+  let retainedBytes = retainedOutputBytes(terminal);
+  return {
+    append(output) {
+      const bytes = retainedOutputBytes(output);
+      if (trailing.length >= MAX_TRAILING_OUTPUTS || retainedBytes + bytes > MAX_RETAINED_BYTES) {
+        throwAgentProviderContractError(
+          providerKey,
+          "invalid_operation_result",
+          "Provider exceeded bounded terminal output capacity."
+        );
+      }
+      trailing.push(output);
+      retainedBytes += bytes;
+    },
+    take() {
+      return trailing.shift();
+    },
+    clear() {
+      trailing.length = 0;
+      retainedBytes = 0;
+    }
+  };
+}
+export {
+  createAgentTurnTerminalBuffer
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agen-ai/agent-runtime",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "private": false,
   "description": "Provider-neutral driver, instance, adapter, session, output, and conformance contracts for coding-agent runtimes.",
   "type": "module",
@@ -28,10 +28,14 @@
     "./environment": {
       "types": "./dist/environment/index.d.ts",
       "import": "./dist/environment/index.js"
+    },
+    "./generation": {
+      "types": "./dist/generation/index.d.ts",
+      "import": "./dist/generation/index.js"
     }
   },
   "dependencies": {
-    "@agen-ai/agent-protocol": "^0.4.3"
+    "@agen-ai/agent-protocol": "^0.4.5"
   },
   "devDependencies": {
     "tsup": "^8.5.0"