@agen-ai/agent-runtime 0.3.1 → 0.4.1

package/dist/turnExecution/receipts.js

@@ -0,0 +1,39 @@
+import { parseAgentError } from "@agen-ai/agent-protocol";
+import { throwAgentProviderContractError } from "../contractErrors.js";
+import { hasExactOwnKeys } from "../internal/objectShape.js";
+import { validateAgentProviderOperationResult } from "../outputValidation.js";
+function validateAgentProviderTurnInterruptionResult(candidate, context) {
+  if (candidate === null || typeof candidate !== "object" || !hasExactOwnKeys(candidate, candidate.status === "failed" ? ["status", "error"] : ["status"])) {
+    return throwAgentProviderContractError(
+      context.providerKey,
+      "invalid_operation_result",
+      "Provider interruption must return an output-free operation receipt."
+    );
+  }
+  const result = validateAgentProviderOperationResult(candidate, context);
+  return Object.freeze({ status: result.status, ...result.error === void 0 ? {} : { error: result.error } });
+}
+function validateAgentRequestResolutionResult(candidate, providerKey) {
+  const invalid = () => throwAgentProviderContractError(
+    providerKey,
+    "invalid_operation_result",
+    "Provider returned an invalid request delivery receipt."
+  );
+  if (candidate === null || typeof candidate !== "object" || !("status" in candidate)) return invalid();
+  if (candidate.status === "delivered" && hasExactOwnKeys(candidate, ["status"])) {
+    return Object.freeze({ status: "delivered" });
+  }
+  if (!("error" in candidate)) return invalid();
+  const error = parseAgentError(candidate.error);
+  if (candidate.status === "delivery_uncertain" && hasExactOwnKeys(candidate, ["status", "error"])) {
+    return Object.freeze({ status: "delivery_uncertain", error });
+  }
+  if (candidate.status === "rejected" && hasExactOwnKeys(candidate, ["status", "requestState", "error"]) && "requestState" in candidate && (candidate.requestState === "pending" || candidate.requestState === "unavailable")) {
+    return Object.freeze({ status: "rejected", requestState: candidate.requestState, error });
+  }
+  return invalid();
+}
+export {
+  validateAgentProviderTurnInterruptionResult,
+  validateAgentRequestResolutionResult
+};

package/dist/turnExecution/requests.d.ts

@@ -0,0 +1,19 @@
+import type { AgentRequest, AgentTurnId } from "@agen-ai/agent-protocol";
+export interface PendingAgentRequest {
+    readonly request: AgentRequest;
+    readonly turnId: AgentTurnId;
+}
+export interface SuspendedAgentTurnRequests {
+    readonly restore: () => void;
+    readonly withdraw: () => void;
+}
+export declare function createAgentTurnRequestAdmission(input: Readonly<{
+    pendingRequests: Map<string, PendingAgentRequest>;
+    canRestore: () => boolean;
+}>): {
+    claim: (requestId: string, pending: PendingAgentRequest) => (() => void);
+    suspend: () => SuspendedAgentTurnRequests;
+    withdraw: () => void;
+    observeRequest(): void;
+};
+//# sourceMappingURL=requests.d.ts.map

package/dist/turnExecution/requests.js

@@ -0,0 +1,56 @@
+function createRequestAdmissionGeneration() {
+  return { suspensions: /* @__PURE__ */ new Set(), withheldRequests: /* @__PURE__ */ new Map() };
+}
+function createAgentTurnRequestAdmission(input) {
+  let generation = createRequestAdmissionGeneration();
+  const withdraw = () => {
+    generation = createRequestAdmissionGeneration();
+    input.pendingRequests.clear();
+  };
+  const restoreReadyRequests = (requestGeneration) => {
+    if (requestGeneration !== generation || !input.canRestore() || requestGeneration.suspensions.size > 0 || input.pendingRequests.size > 0) return;
+    for (const [requestId, pending] of requestGeneration.withheldRequests) {
+      input.pendingRequests.set(requestId, pending);
+    }
+    requestGeneration.withheldRequests.clear();
+  };
+  const claim = (requestId, pending) => {
+    const claimedGeneration = generation;
+    input.pendingRequests.delete(requestId);
+    return () => {
+      if (claimedGeneration !== generation || !input.canRestore()) return;
+      claimedGeneration.withheldRequests.set(requestId, pending);
+      restoreReadyRequests(claimedGeneration);
+    };
+  };
+  const suspend = () => {
+    const suspendedGeneration = generation;
+    const suspension = Symbol("interruption");
+    suspendedGeneration.suspensions.add(suspension);
+    for (const [requestId, pending] of input.pendingRequests) {
+      suspendedGeneration.withheldRequests.set(requestId, pending);
+    }
+    input.pendingRequests.clear();
+    return {
+      restore() {
+        if (!suspendedGeneration.suspensions.delete(suspension)) return;
+        restoreReadyRequests(suspendedGeneration);
+      },
+      withdraw() {
+        if (!suspendedGeneration.suspensions.delete(suspension)) return;
+        if (suspendedGeneration === generation) withdraw();
+      }
+    };
+  };
+  return {
+    claim,
+    suspend,
+    withdraw,
+    observeRequest() {
+      generation = createRequestAdmissionGeneration();
+    }
+  };
+}
+export {
+  createAgentTurnRequestAdmission
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agen-ai/agent-runtime",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "private": false,
   "description": "Provider-neutral driver, instance, adapter, session, output, and conformance contracts for coding-agent runtimes.",
   "type": "module",
@@ -31,7 +31,7 @@
     }
   },
   "dependencies": {
-    "@agen-ai/agent-protocol": "^0.3.1"
+    "@agen-ai/agent-protocol": "^0.4.1"
   },
   "devDependencies": {
     "tsup": "^8.5.0"