@agen-ai/agent-runtime 0.4.1 → 0.4.2

package/dist/testing/conformance.js

@@ -50,25 +50,104 @@ async function advanceToStartedTurn(session, input) {
       );
       outputs.push(next.value);
       if (next.value.kind === "event" && next.value.event.type === "turn.started") {
-        return { execution, iterator, outputs };
+        return { session, execution, iterator, outputs };
       }
     }
   } catch (error) {
-    await iterator.return?.();
+    const closing = session.close({ reason: "contract_rejected" });
+    const settled = await Promise.allSettled([closing, iterator.return?.()]);
+    const failures = settled.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+    if (failures.length > 0) throw new AggregateError([error, ...failures], "Conformance opening and cleanup failed.", { cause: error });
     throw error;
   }
 }
-async function collectRemainingOutputs(started, resolutionFor) {
-  for (; ; ) {
-    const next = await started.iterator.next();
-    if (next.done) return started.outputs;
-    started.outputs.push(next.value);
-    if (next.value.kind === "event" && next.value.event.type === "request.opened" && resolutionFor) {
-      const request = next.value.event.payload.request;
-      const receipt = await started.execution.resolveRequest({ resolution: parseAgentRequestResolutionFor(request, resolutionFor(request)) });
-      requireCheck(receipt.status === "delivered", "request_resolution", "Matching request answer was not accepted by the provider handler.");
+async function collectRemainingOutputs(started, resolutionFor, beforeClose) {
+  const requests = /* @__PURE__ */ new Map();
+  const tasks = [];
+  let acceptingRequests = true;
+  let deliveredRequests = 0;
+  let failTask;
+  const taskFailure = new Promise((_resolve, reject) => {
+    failTask = reject;
+  });
+  const abortRequests = () => {
+    for (const controller of requests.values()) {
+      controller.abort(new DOMException("Conformance request is no longer answerable.", "AbortError"));
+    }
+  };
+  const resolve = async (request, signal) => {
+    if (!resolutionFor) return;
+    let resolution;
+    try {
+      resolution = await resolutionFor(request, { signal });
+    } catch (error) {
+      if (signal.aborted && isAgentOperationAbortError(error)) return;
+      throw error;
     }
+    if (resolution === void 0 || signal.aborted) return;
+    const receipt = await started.execution.resolveRequest({
+      resolution: parseAgentRequestResolutionFor(request, resolution)
+    });
+    requireCheck(
+      receipt.status === "delivered",
+      "request_resolution",
+      "Matching request answer was not accepted by the provider handler."
+    );
+    deliveredRequests += 1;
+  };
+  const reader = (async () => {
+    for (; ; ) {
+      const next = await started.iterator.next();
+      if (next.done || !acceptingRequests) return;
+      started.outputs.push(next.value);
+      if (next.value.kind !== "event") continue;
+      const event = next.value.event;
+      if (event.type === "request.opened" && resolutionFor) {
+        const request = event.payload.request;
+        const controller = new AbortController();
+        requests.set(request.requestId, controller);
+        const task = resolve(request, controller.signal);
+        tasks.push(task);
+        void task.catch((error) => {
+          acceptingRequests = false;
+          failTask(error);
+        });
+      } else if (event.type === "request.unavailable") {
+        requests.get(event.payload.requestId)?.abort(
+          new DOMException("The provider retired this conformance request.", "AbortError")
+        );
+        requests.delete(event.payload.requestId);
+      } else if (event.type === "turn.completed") {
+        abortRequests();
+        return;
+      }
+    }
+  })();
+  const checked = reader.then(async () => {
+    if (acceptingRequests) await beforeClose?.();
+  });
+  const failures = /* @__PURE__ */ new Set();
+  try {
+    await Promise.race([checked, taskFailure]);
+  } catch (error) {
+    failures.add(error);
+  }
+  acceptingRequests = false;
+  abortRequests();
+  const closing = started.session.close({ reason: failures.size > 0 ? "contract_rejected" : "idle" });
+  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]) {
+    if (result?.status === "rejected" && !(failures.size > 0 && isAgentOperationAbortError(result.reason))) failures.add(result.reason);
   }
+  if (returned?.status === "rejected") failures.add(returned.reason);
+  const joined = await Promise.allSettled(tasks);
+  for (const result of joined) {
+    if (result.status === "rejected") failures.add(result.reason);
+  }
+  if (failures.size === 1) throw failures.values().next().value;
+  if (failures.size > 1) throw new AggregateError(failures, "Conformance and owned cleanup failed.", { cause: failures.values().next().value });
+  return { outputs: started.outputs, deliveredRequests };
 }
 function requireOperationStatus(result, statuses, check, message) {
   requireCheck(statuses.includes(result.status), check, message);
@@ -110,6 +189,7 @@ async function runAgentProviderConformance(scenario) {
   });
   let disposed = false;
   let createdSession = null;
+  let failure;
   try {
     const instance = registry.requireInstance(scenario.definition.instanceId);
     requireCheck(
@@ -276,55 +356,7 @@ async function runAgentProviderConformance(scenario) {
       );
       checks.push("abort");
     }
-    const startedTurn = await advanceToStartedTurn(created, scenario.turn);
-    let turnOutputs;
-    try {
-      if (instance.capabilities.turns.steer.kind === "supported") {
-        requireCheck(
-          created.steering.kind === "supported",
-          "steering",
-          "Steering capability has no handler."
-        );
-        const result = await created.steering.steerTurn({
-          turnId: scenario.turn.turnId,
-          ...scenario.steeringInput ?? {
-            parts: [
-              { type: "text", text: "Additional conformance input." }
-            ]
-          }
-        });
-        requireCheck(
-          result.status === "delivered",
-          "steering",
-          "Steering did not deliver to the live turn."
-        );
-      } else {
-        requireCheck(
-          created.steering.kind === "unsupported",
-          "steering",
-          "Unsupported steering exposed a handler."
-        );
-      }
-      turnOutputs = await collectRemainingOutputs(startedTurn, scenario.resolutionFor);
-    } catch (error) {
-      await startedTurn.iterator.return?.();
-      await created.close({ reason: "contract_rejected" });
-      throw error;
-    }
-    const events = semanticEvents(turnOutputs);
-    requireCheck(
-      events[0]?.type === "turn.started",
-      "turn_order",
-      "Turn did not start first."
-    );
-    requireCheck(
-      hasStableTurnBoundary(events),
-      "turn_order",
-      "Turn did not terminate or enter a waiting state."
-    );
-    checks.push("turn_order");
-    if (events.some((event) => event.type === "request.opened")) checks.push("request_resolution");
-    checks.push("steering");
+    const turnChecksIndex = checks.length;
     if (instance.capabilities.turns.interrupt) {
       let interruptedBindingCount = 0;
       const interrupted = await instance.adapter.createSession({
@@ -362,15 +394,15 @@ async function runAgentProviderConformance(scenario) {
           "interruption",
           "Live turn interruption did not succeed."
         );
-        const outputs = await collectRemainingOutputs(liveTurn);
+        const { outputs } = await collectRemainingOutputs(liveTurn);
         requireCheck(
           semanticEvents(outputs).some((event) => event.type === "turn.completed"),
           "interruption",
           "Interrupted turn did not produce native terminal output."
         );
       } finally {
-        await liveTurn?.iterator.return?.();
-        await interrupted.close({ reason: "other" });
+        const closing = interrupted.close({ reason: "other" });
+        await Promise.all([closing, liveTurn?.iterator.return?.()]);
       }
     } else {
       requireCheck(
@@ -526,28 +558,83 @@ async function runAgentProviderConformance(scenario) {
       );
     }
     checks.push("collaboration");
-    if (instance.capabilities.generatedResources.kind === "supported") {
-      requireCheck(
-        created.generatedResources.kind === "supported" && scenario.generatedResourceId !== void 0,
-        "generated_resources",
-        "Supported generated resources require an access port and fixture."
-      );
-      const resource = await created.generatedResources.getGeneratedResource({
-        resourceId: scenario.generatedResourceId
+    const turnChecks = [];
+    const startedTurn = await advanceToStartedTurn(created, scenario.turn);
+    let turnResult;
+    try {
+      if (instance.capabilities.turns.steer.kind === "supported") {
+        requireCheck(
+          created.steering.kind === "supported",
+          "steering",
+          "Steering capability has no handler."
+        );
+        const result = await created.steering.steerTurn({
+          turnId: scenario.turn.turnId,
+          ...scenario.steeringInput ?? {
+            parts: [
+              { type: "text", text: "Additional conformance input." }
+            ]
+          }
+        });
+        requireCheck(
+          result.status === "delivered",
+          "steering",
+          "Steering did not deliver to the live turn."
+        );
+      } else {
+        requireCheck(
+          created.steering.kind === "unsupported",
+          "steering",
+          "Unsupported steering exposed a handler."
+        );
+      }
+      turnResult = await collectRemainingOutputs(startedTurn, scenario.resolutionFor, async () => {
+        if (instance.capabilities.generatedResources.kind === "supported") {
+          requireCheck(
+            created.generatedResources.kind === "supported" && scenario.generatedResourceId !== void 0,
+            "generated_resources",
+            "Supported generated resources require an access port and fixture."
+          );
+          const resource = await created.generatedResources.getGeneratedResource({
+            resourceId: scenario.generatedResourceId
+          });
+          requireCheck(
+            resource.descriptor.resourceId === scenario.generatedResourceId,
+            "generated_resources",
+            "Generated resource access returned another resource."
+          );
+        } else {
+          requireCheck(
+            created.generatedResources.kind === "unsupported",
+            "generated_resources",
+            "Unsupported generated resources exposed an access port."
+          );
+        }
+        checks.push("generated_resources");
       });
-      requireCheck(
-        resource.descriptor.resourceId === scenario.generatedResourceId,
-        "generated_resources",
-        "Generated resource access returned another resource."
-      );
-    } else {
-      requireCheck(
-        created.generatedResources.kind === "unsupported",
-        "generated_resources",
-        "Unsupported generated resources exposed an access port."
-      );
+    } catch (error) {
+      const closing = created.close({ reason: "contract_rejected" });
+      const settled = await Promise.allSettled([closing, startedTurn.iterator.return?.()]);
+      const failures = settled.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+      if (failures.length > 0) throw new AggregateError([error, ...failures], "Conformance turn and cleanup failed.", { cause: error });
+      throw error;
     }
-    checks.push("generated_resources");
+    const events = semanticEvents(turnResult.outputs);
+    requireCheck(
+      events[0]?.type === "turn.started",
+      "turn_order",
+      "Turn did not start first."
+    );
+    requireCheck(
+      hasStableTurnBoundary(events),
+      "turn_order",
+      "Turn did not terminate or enter a waiting state."
+    );
+    turnChecks.push("turn_order");
+    if (turnResult.deliveredRequests > 0) turnChecks.push("request_resolution");
+    if (events.some((event) => event.type === "request.unavailable")) turnChecks.push("request_unavailability");
+    turnChecks.push("steering");
+    checks.splice(turnChecksIndex, 0, ...turnChecks);
     await created.close({ reason: "idle" });
     await created.close({ reason: "idle" });
     checks.push("idempotent_session_close");
@@ -620,9 +707,17 @@ async function runAgentProviderConformance(scenario) {
       providerKey: scenario.definition.providerKey,
       checks: Object.freeze(checks)
     });
+  } catch (error) {
+    failure = { error };
+    throw error;
   } finally {
-    await createdSession?.close({ reason: "contract_rejected" });
-    if (!disposed) await registry.dispose();
+    try {
+      await createdSession?.close({ reason: "contract_rejected" });
+      if (!disposed) await registry.dispose();
+    } catch (error) {
+      if (failure) throw new AggregateError([failure.error, error], "Conformance and final cleanup failed.", { cause: failure.error });
+      throw error;
+    }
   }
 }
 export {

package/dist/testing/fakeProvider.js

@@ -44,7 +44,7 @@ function defaultCapabilities(providerKey) {
     }
   };
   return parseAgentCapabilities({
-    protocolVersion: 11,
+    protocolVersion: 12,
     providerKey,
     sessions: { create: true, resume: true, branch: { kind: "through_turn" } },
     turns: {
@@ -166,7 +166,7 @@ function sessionBinding(state, sessionId) {
   };
 }
 function eventBase(sessionId, turnId, occurredAt) {
-  return { protocolVersion: 11, sessionId, turnId, occurredAt };
+  return { protocolVersion: 12, sessionId, turnId, occurredAt };
 }
 function fakeEnvironmentSnapshot(environmentId) {
   return parseAgentEnvironmentSnapshot({

package/dist/turnExecution/execution.d.ts

@@ -1,26 +1,43 @@
-import { type AgentProviderKey } from "@agen-ai/agent-protocol";
+import { type AgentProviderKey, type AgentTurnId } from "@agen-ai/agent-protocol";
 import type { AgentProviderOutput } from "../outputs.js";
+import type { AgentSessionAdmission } from "../sessionAdmission.js";
 import type { AgentProviderStartTurnInput, AgentProviderTurnExecution } from "../sessions.js";
-import { type PendingAgentRequest, type SuspendedAgentTurnRequests } from "./requests.js";
+import { type AgentTurnRequestAdmission, type PendingAgentRequest, type SuspendedAgentTurnRequests } from "./requests.js";
 export interface ValidatedAgentTurnExecution {
     readonly execution: AgentProviderTurnExecution;
     readonly hasEntered: () => boolean;
     readonly stop: (reason: Error) => void;
     readonly join: () => Promise<void>;
     readonly suspendRequests: () => SuspendedAgentTurnRequests;
+    readonly completed: Promise<void>;
 }
-export declare function createValidatedAgentTurnExecution(input: Readonly<{
+type ExecutionOptions = Readonly<{
     providerKey: AgentProviderKey;
-    turnInput: AgentProviderStartTurnInput;
     pendingRequests: Map<string, PendingAgentRequest>;
+    sessionAdmission: AgentSessionAdmission;
     inFlightOperations: Set<Promise<void>>;
-    start: (input: AgentProviderStartTurnInput) => AgentProviderTurnExecution;
     requireUsable: () => void;
     isTerminal: () => boolean;
-    observe: (output: AgentProviderOutput) => AgentProviderOutput;
+    canRestoreRequest: (pending: PendingAgentRequest) => boolean;
+    observe: (output: AgentProviderOutput, requests: AgentTurnRequestAdmission) => AgentProviderOutput;
     assertCompleted: () => void;
     release: () => void;
     retire: () => void;
     abandon: () => Promise<void>;
+}>;
+export declare function createValidatedAgentTurnExecution(input: ExecutionOptions & Readonly<{
+    turnInput: AgentProviderStartTurnInput;
+    start: (input: AgentProviderStartTurnInput) => AgentProviderTurnExecution;
 }>): ValidatedAgentTurnExecution;
+export interface AdoptedAgentTurnExecution extends ValidatedAgentTurnExecution {
+    readonly readerReady: Promise<void>;
+    readonly admitDispatch: () => void;
+    readonly settleNoWork: () => void;
+    readonly markStarted: () => void;
+}
+export declare function adoptValidatedAgentTurnExecution(input: ExecutionOptions & Readonly<{
+    turnId: AgentTurnId;
+    createCandidate: (signal: AbortSignal) => AgentProviderTurnExecution;
+}>): AdoptedAgentTurnExecution;
+export {};
 //# sourceMappingURL=execution.d.ts.map