effect-agent 0.1.0-beta.97 → 0.1.0-beta.99

package/src/durable/internal/worker-host.ts

@@ -105,7 +105,6 @@ import {
 } from "../WorkerHost.ts";
 import {
   definitionDigestsEqual,
-  bindingSupports,
   resolveDefinitionBinding,
   type ResolvedBinding,
 } from "./agent-registration.ts";
@@ -381,11 +380,10 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
     };
   });
 
-  const firstThreadInput = (history: Effect.Success<ReturnType<typeof read>>) => {
-    const first = history.records.find(({ record }) => record.payload._tag === "UserInputRecorded")
-      ?.record.payload;
+  const currentBinding = (agentId: AgentId): ResolvedBinding | undefined => {
+    const matches = deps.bindings.filter((entry) => entry.agentId === agentId);
 
-    return first?._tag === "UserInputRecorded" ? first.input : undefined;
+    return matches.length === 1 ? matches[0] : undefined;
   };
 
   const sourceAuthority = Effect.fn("WorkerHost.sourceAuthority")(function* (
@@ -397,11 +395,7 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
 
     if (created?._tag !== "ThreadCreated") return yield* failure("start", "not-found");
 
-    const binding = deps.bindings.find(
-      (entry) =>
-        entry.agentId === created.agentId &&
-        bindingSupports(entry, created.definitions, undefined, firstThreadInput(current)),
-    );
+    const binding = currentBinding(created.agentId);
 
     const worker = current.records.find(
       ({ record }) => record.payload._tag === "WorkerOriginRecorded",
@@ -444,18 +438,7 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
     }
 
     const ownerBinding =
-      ownerSubmission === undefined
-        ? undefined
-        : deps.bindings.find(
-            (entry) =>
-              entry.agentId === ownerSubmission.agentId &&
-              bindingSupports(
-                entry,
-                ownerSubmission.agentDigests,
-                undefined,
-                ownerSubmission.inputPayload,
-              ),
-          );
+      ownerSubmission === undefined ? undefined : currentBinding(ownerSubmission.agentId);
 
     const selectedBinding = ownerBinding ?? binding;
 
@@ -734,6 +717,7 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
     inputDigest: Digest,
     input: PersistedJson,
     principal: Principal,
+    retainedFrameworkInput: boolean,
   ): Effect.fn.Return<void, WorkerError> {
     const origin = admission.origin;
     const id = `worker-input:${admission.messageId}`;
@@ -779,17 +763,16 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
 
       const sourceBinding = source.binding;
 
-      const targetBinding = deps.bindings.find(
-        (entry) =>
-          entry.agentId === origin.worker.targetAgentId &&
-          bindingSupports(entry, origin.targetDigests, undefined, input),
-      );
+      const targetBinding = currentBinding(origin.worker.targetAgentId);
 
       if (sourceBinding === undefined || targetBinding === undefined)
         return yield* failure("start", "declaration-unavailable");
-      yield* Schema.decodeEffect(Schema.toEncoded(targetBinding.definition.input))(input).pipe(
-        Effect.mapError(() => failure("start", "corrupt")),
-      );
+      // Standard reports and updates retain the owner's original input bytes. Their
+      // framework message carries the new information independently of the current input codec.
+      if (!retainedFrameworkInput)
+        yield* Schema.decodeEffect(Schema.toEncoded(targetBinding.definition.input))(input).pipe(
+          Effect.mapError(() => failure("start", "corrupt")),
+        );
 
       const targetRequest = {
         definition: targetBinding.definition,
@@ -1040,7 +1023,11 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
         admission.deliveryPrincipal !== options.principal)
     )
       return yield* failure("start", "worker-mismatch");
-    yield* reservation(admission, inputDigest, input, options.principal);
+    const retainedFrameworkInput = Schema.is(FrameworkMessage)(options.messageAdmission);
+
+    if (retainedFrameworkInput && admission.reportKind !== "update")
+      yield* validateCompletion(options.messageAdmission, options, agentId, inputDigest);
+    yield* reservation(admission, inputDigest, input, options.principal, retainedFrameworkInput);
 
     return admission;
   });
@@ -1068,29 +1055,11 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
         first.admission.sourceSubmissionId,
       );
 
-      if (
-        source.binding === undefined ||
-        source.submission === undefined ||
-        !bindingSupports(
-          source.binding,
-          intent.sourceDigests,
-          undefined,
-          source.submission?.inputPayload,
-        )
-      )
+      if (source.binding === undefined || source.submission === undefined)
         return yield* failure("followUp", "declaration-unavailable");
 
-      const sourceBinding = deps.bindings.find(
-        (entry) =>
-          entry.agentId === origin.source.agentId &&
-          bindingSupports(entry, intent.sourceDigests, undefined, source.submission?.inputPayload),
-      );
-
-      const targetBinding = deps.bindings.find(
-        (entry) =>
-          entry.agentId === origin.worker.targetAgentId &&
-          bindingSupports(entry, origin.targetDigests, undefined, submission.inputPayload),
-      );
+      const sourceBinding = currentBinding(origin.source.agentId);
+      const targetBinding = currentBinding(origin.worker.targetAgentId);
 
       const reports =
         sourceBinding?.reporting?.filter(
@@ -1124,14 +1093,7 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
       );
 
       if (now >= deadlineAtMillis) return yield* failure("followUp", "denied");
-      const sourceSubmission = source.submission;
-
-      const input = yield* Schema.decodeEffect(Schema.toEncoded(sourceBinding.definition.input))(
-        source.submission.inputPayload,
-      ).pipe(
-        Effect.flatMap(() => Schema.decodeEffect(PersistedJson)(sourceSubmission.inputPayload)),
-        Effect.mapError(() => failure("followUp", "corrupt")),
-      );
+      const input = source.submission.inputPayload;
 
       let workerAdmission: WorkerAdmission | undefined;
       let principal = submission.principal;
@@ -1283,28 +1245,10 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
         firstInput.admission.sourceSubmissionId,
       );
 
-      if (
-        source.binding === undefined ||
-        !bindingSupports(
-          source.binding,
-          intent.sourceDigests,
-          undefined,
-          source.submission?.inputPayload,
-        )
-      )
-        return refused("declaration-unavailable");
-
-      const sourceBinding = deps.bindings.find(
-        (entry) =>
-          entry.agentId === origin.source.agentId &&
-          bindingSupports(entry, intent.sourceDigests, undefined, source.submission?.inputPayload),
-      );
+      if (source.binding === undefined) return refused("declaration-unavailable");
 
-      const targetBinding = deps.bindings.find(
-        (entry) =>
-          entry.agentId === origin.worker.targetAgentId &&
-          bindingSupports(entry, origin.targetDigests, undefined, hostSubmission.inputPayload),
-      );
+      const sourceBinding = currentBinding(origin.source.agentId);
+      const targetBinding = currentBinding(origin.worker.targetAgentId);
 
       const reports =
         sourceBinding?.reporting?.filter(
@@ -1420,12 +1364,13 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
           ? source.submission?.inputPayload
           : projection.value.encodedInput;
 
-      const validated = yield* Schema.decodeEffect(
-        Schema.toEncoded(sourceBinding.definition.input),
-      )(reportInput).pipe(
-        Effect.flatMap(() => Schema.decodeUnknownEffect(PersistedJson)(reportInput)),
-        Effect.option,
-      );
+      const validated = yield* (
+        descriptor.mode === "standard"
+          ? Schema.decodeUnknownEffect(PersistedJson)(reportInput)
+          : Schema.decodeEffect(Schema.toEncoded(sourceBinding.definition.input))(reportInput).pipe(
+              Effect.flatMap(() => Schema.decodeUnknownEffect(PersistedJson)(reportInput)),
+            )
+      ).pipe(Effect.option);
 
       if (Option.isNone(validated)) return refused("input");
       const input = validated.value;
@@ -2084,7 +2029,7 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
               threadId: Schema.decodeSync(ThreadId)(messageId),
             },
             source: existing?.envelope.workerAdmission?.origin.source ?? context.source,
-            targetDigests: resolved.digests,
+            targetDigests: previousOrigin?.targetDigests ?? resolved.digests,
             policy: request.policy,
             budget: request.budget,
             ...(request.budgetScope === undefined ? {} : { budgetScope: request.budgetScope }),
@@ -2432,14 +2377,7 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
         ? undefined
         : yield* sourceAuthority(sourceThreadId, request.sourceSubmissionId);
 
-    const resolved =
-      selected === undefined
-        ? deps.bindings.find(
-            (entry) =>
-              entry.agentId === created.agentId &&
-              bindingSupports(entry, created.definitions, undefined, firstThreadInput(current)),
-          )
-        : selected.binding;
+    const resolved = selected === undefined ? currentBinding(created.agentId) : selected.binding;
 
     if (resolved === undefined) return yield* failure("context", "declaration-unavailable");
 

package/src/engine/RunOptions.ts

@@ -611,9 +611,9 @@ export interface RunDurabilityHook<Error = never, Requirements = never> {
 /**
  * `DefinitionDigests`-shaped digests of one child Agent Binding in plain
  * string form. The durable coordinator's thread-owned digest Schema never
- * crosses inward: the coordinator resolves these digests from the exact
- * registered target and stores and verifies them
- * byte-for-byte (SUB-023 exact-digest binding resolution).
+ * crosses inward: the coordinator captures these digests from the admitted target
+ * and verifies them byte-for-byte as immutable provenance. Current executable
+ * selection uses the stable Agent identity, independently of historical definitions.
  */
 export interface RunSubagentDigests {
   readonly agent: string;
@@ -829,6 +829,8 @@ export type RunResumeUsage = typeof RunResumeUsageSchema.Type;
  * proceeds through the normal continuation.
  */
 export interface RunTurnResume {
+  /** A successful settled call whose original operation contract still supports completion projection. */
+  readonly settledCompletion?: ToolCallId | undefined;
   /** Canonical rejection evidence, matched to the exact call; never permits handler execution. */
   readonly toolParameterRejections?: ReadonlyArray<ToolParameterRejection> | undefined;
   readonly toolExposure?: Snapshot | undefined;
@@ -919,6 +921,14 @@ export interface RunOptions<HookError = never, HookRequirements = never> {
   /** Host-validated worker message; application input still supplies instructions and policy context. */
   readonly frameworkMessage?: FrameworkMessage;
 
+  /**
+   * Original admitted JSON for a durable continuation or verified framework message. Static
+   * instructions can resume without decoding a future input Schema; input-dependent instructions
+   * still require that Schema. The original value remains the policy input, and a saved prompt
+   * is restored through `context` instead of rerendering the application's input prompt.
+   */
+  readonly retainedInput?: Schema.Json | undefined;
+
   /** Initial or canonically restored run-scoped native selection. */
   readonly toolSelection?: Selection | undefined;
   /**