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

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

@@ -105,6 +105,7 @@ import {
 } from "../WorkerHost.ts";
 import {
   definitionDigestsEqual,
+  bindingSupports,
   resolveDefinitionBinding,
   type ResolvedBinding,
 } from "./agent-registration.ts";
@@ -380,6 +381,13 @@ 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;
+
+    return first?._tag === "UserInputRecorded" ? first.input : undefined;
+  };
+
   const sourceAuthority = Effect.fn("WorkerHost.sourceAuthority")(function* (
     threadId: ThreadId,
     submissionId?: SubmissionId,
@@ -392,7 +400,7 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
     const binding = deps.bindings.find(
       (entry) =>
         entry.agentId === created.agentId &&
-        definitionDigestsEqual(entry.digests, created.definitions),
+        bindingSupports(entry, created.definitions, undefined, firstThreadInput(current)),
     );
 
     const worker = current.records.find(
@@ -435,10 +443,26 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
         return yield* failure("start", "denied");
     }
 
+    const ownerBinding =
+      ownerSubmission === undefined
+        ? undefined
+        : deps.bindings.find(
+            (entry) =>
+              entry.agentId === ownerSubmission.agentId &&
+              bindingSupports(
+                entry,
+                ownerSubmission.agentDigests,
+                undefined,
+                ownerSubmission.inputPayload,
+              ),
+          );
+
+    const selectedBinding = ownerBinding ?? binding;
+
     if (worker?._tag === "WorkerOriginRecorded")
       return {
         current,
-        binding,
+        binding: selectedBinding,
         submission: ownerSubmission,
         policyOverride: Option.none<AgentPolicy>(),
         policy: worker.origin.policy,
@@ -457,7 +481,7 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
 
       return {
         current,
-        binding,
+        binding: selectedBinding,
         submission: ownerSubmission,
         policyOverride: Option.none<AgentPolicy>(),
         policy: attached.policy,
@@ -468,17 +492,6 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
       };
     }
 
-    const ownerBinding =
-      ownerSubmission === undefined
-        ? undefined
-        : deps.bindings.find(
-            (entry) =>
-              entry.agentId === ownerSubmission.agentId &&
-              definitionDigestsEqual(entry.digests, ownerSubmission.agentDigests),
-          );
-
-    const selectedBinding = ownerBinding ?? binding;
-
     const changedRootAgent =
       ownerSubmission !== undefined && ownerSubmission.agentId !== created.agentId;
 
@@ -498,7 +511,9 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
       return yield* failure("start", "declaration-unavailable");
 
     const effectiveBinding =
-      Option.isSome(selected) || changedRootAgent ? selectedBinding : binding;
+      Option.isSome(selected) || changedRootAgent || binding === undefined
+        ? selectedBinding
+        : binding;
 
     if (effectiveBinding === undefined) return yield* failure("start", "declaration-unavailable");
 
@@ -767,7 +782,7 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
       const targetBinding = deps.bindings.find(
         (entry) =>
           entry.agentId === origin.worker.targetAgentId &&
-          definitionDigestsEqual(entry.digests, origin.targetDigests),
+          bindingSupports(entry, origin.targetDigests, undefined, input),
       );
 
       if (sourceBinding === undefined || targetBinding === undefined)
@@ -1039,16 +1054,42 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
       if (update.threadId !== submission.threadId || update.agentId !== origin.worker.targetAgentId)
         return yield* failure("followUp", "worker-mismatch");
 
+      const sourceHistory = yield* read(origin.source.threadId, "followUp");
+
+      const first = requests(sourceHistory.records).find(
+        (row) => row.admission.messageId === origin.firstMessageId,
+      );
+
+      if (first === undefined || !sameOrigin(first.admission.origin, origin))
+        return yield* failure("followUp", "corrupt");
+
+      const source = yield* sourceAuthority(
+        origin.source.threadId,
+        first.admission.sourceSubmissionId,
+      );
+
+      if (
+        source.binding === undefined ||
+        source.submission === undefined ||
+        !bindingSupports(
+          source.binding,
+          intent.sourceDigests,
+          undefined,
+          source.submission?.inputPayload,
+        )
+      )
+        return yield* failure("followUp", "declaration-unavailable");
+
       const sourceBinding = deps.bindings.find(
         (entry) =>
           entry.agentId === origin.source.agentId &&
-          definitionDigestsEqual(entry.digests, intent.sourceDigests),
+          bindingSupports(entry, intent.sourceDigests, undefined, source.submission?.inputPayload),
       );
 
       const targetBinding = deps.bindings.find(
         (entry) =>
           entry.agentId === origin.worker.targetAgentId &&
-          definitionDigestsEqual(entry.digests, origin.targetDigests),
+          bindingSupports(entry, origin.targetDigests, undefined, submission.inputPayload),
       );
 
       const reports =
@@ -1065,26 +1106,6 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
         !definitionDigestsEqual(submission.agentDigests, origin.targetDigests)
       )
         return yield* failure("followUp", "declaration-unavailable");
-      const sourceHistory = yield* read(origin.source.threadId, "followUp");
-
-      const first = requests(sourceHistory.records).find(
-        (row) => row.admission.messageId === origin.firstMessageId,
-      );
-
-      if (first === undefined || !sameOrigin(first.admission.origin, origin))
-        return yield* failure("followUp", "corrupt");
-
-      const source = yield* sourceAuthority(
-        origin.source.threadId,
-        first.admission.sourceSubmissionId,
-      );
-
-      if (
-        source.binding === undefined ||
-        source.submission === undefined ||
-        !definitionDigestsEqual(source.binding.digests, intent.sourceDigests)
-      )
-        return yield* failure("followUp", "declaration-unavailable");
 
       const recorded = source.current.records.find(
         ({ record }) => record.payload._tag === "WorkerOriginRecorded",
@@ -1231,40 +1252,6 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
       const refused = (reason: WorkerReportRefused["reason"]) =>
         WorkerReportRefused.make({ runId, messageId, reason });
 
-      const sourceBinding = deps.bindings.find(
-        (entry) =>
-          entry.agentId === origin.source.agentId &&
-          definitionDigestsEqual(entry.digests, intent.sourceDigests),
-      );
-
-      const targetBinding = deps.bindings.find(
-        (entry) =>
-          entry.agentId === origin.worker.targetAgentId &&
-          definitionDigestsEqual(entry.digests, origin.targetDigests),
-      );
-
-      const reports =
-        sourceBinding?.reporting?.filter(
-          (entry) => entry.delegationId === origin.worker.delegationId,
-        ) ?? [];
-
-      const descriptor = reports[0];
-
-      if (
-        sourceBinding === undefined ||
-        targetBinding === undefined ||
-        descriptor === undefined ||
-        reports.length !== 1 ||
-        !Object.is(descriptor.target, targetBinding.definition) ||
-        (descriptor.mode !== "standard" &&
-          !Object.is(descriptor.input, sourceBinding.definition.input)) ||
-        descriptor.mode !== intent.mode ||
-        descriptor.destination?.delegationId !== intent.destinationDelegationId ||
-        (descriptor.destination !== undefined &&
-          !Object.is(descriptor.destination.target, sourceBinding.definition))
-      )
-        return refused("declaration-unavailable");
-
       const selected = yield* deps.ledger
         .lookup(SubmissionLookupById.make({ submissionId: host.submissionId }))
         .pipe(Effect.mapError(storageFailure("inspect")));
@@ -1298,7 +1285,46 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
 
       if (
         source.binding === undefined ||
-        !definitionDigestsEqual(source.binding.digests, intent.sourceDigests)
+        !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),
+      );
+
+      const targetBinding = deps.bindings.find(
+        (entry) =>
+          entry.agentId === origin.worker.targetAgentId &&
+          bindingSupports(entry, origin.targetDigests, undefined, hostSubmission.inputPayload),
+      );
+
+      const reports =
+        sourceBinding?.reporting?.filter(
+          (entry) => entry.delegationId === origin.worker.delegationId,
+        ) ?? [];
+
+      const descriptor = reports[0];
+
+      if (
+        sourceBinding === undefined ||
+        targetBinding === undefined ||
+        descriptor === undefined ||
+        reports.length !== 1 ||
+        !Object.is(descriptor.target, targetBinding.definition) ||
+        (descriptor.mode !== "standard" &&
+          !Object.is(descriptor.input, sourceBinding.definition.input)) ||
+        descriptor.mode !== intent.mode ||
+        descriptor.destination?.delegationId !== intent.destinationDelegationId ||
+        (descriptor.destination !== undefined &&
+          !Object.is(descriptor.destination.target, sourceBinding.definition))
       )
         return refused("declaration-unavailable");
 
@@ -1686,7 +1712,7 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
       target: Agent.AnyDefinition,
       operation: WorkerError["operation"],
     ) {
-      const resolved = yield* binding(target, operation);
+      yield* binding(target, operation);
 
       if (worker.targetAgentId !== target.id) return yield* failure(operation, "worker-mismatch");
       const source = yield* read(context.source.threadId, operation);
@@ -1696,10 +1722,7 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
       )?.admission.origin;
 
       if (origin === undefined) return yield* failure(operation, "not-found");
-      if (
-        origin.worker.delegationId !== worker.delegationId ||
-        !definitionDigestsEqual(origin.targetDigests, resolved.digests)
-      )
+      if (origin.worker.delegationId !== worker.delegationId)
         return yield* failure(operation, "worker-mismatch");
 
       return origin;
@@ -2404,11 +2427,19 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
 
     if (created?._tag !== "ThreadCreated") return yield* failure("context", "not-found");
 
-    const resolved = deps.bindings.find(
-      (entry) =>
-        entry.agentId === created.agentId &&
-        definitionDigestsEqual(entry.digests, created.definitions),
-    );
+    const selected =
+      request.sourceSubmissionId === undefined
+        ? 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;
 
     if (resolved === undefined) return yield* failure("context", "declaration-unavailable");
 
@@ -2427,11 +2458,6 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
           ? attached
           : undefined;
 
-    const selected =
-      request.sourceSubmissionId === undefined
-        ? undefined
-        : yield* sourceAuthority(sourceThreadId, request.sourceSubmissionId);
-
     return facet(
       {
         source: {

package/src/engine/RunOptions.ts

@@ -1005,9 +1005,9 @@ export interface RunOptions<HookError = never, HookRequirements = never> {
    * Optional absolute deadline for the Run's `maxDuration` rail. The engine
    * uses the earlier of this value and the fresh policy deadline, so callers
    * may preserve or tighten an existing Run allowance but can never widen it.
-   * Durable coordinators derive this value from the canonical `RunStarted`
-   * record timestamp and stored duration so replacement Attempts share one
-   * wall-clock allowance (RUN-030).
+   * Durable coordinators reuse the canonical per-Attempt duration allowance;
+   * deployment downtime does not consume it. An immutable worker grant can
+   * impose an earlier absolute expiry. Turn, Tool and cost budgets remain Run-wide.
    */
   readonly durationDeadline?: DateTime.Utc | undefined;
   /**

package/src/engine/internal/agent-runtime.ts

@@ -532,7 +532,7 @@ interface RunContext {
   readonly pendingFollowUps: Array<Prompt.RawInput>;
   /** Wall-clock Run start, the base of the run-status elapsed rendering (RUN-024). */
   readonly startedAtMillis: number;
-  /** Absolute `maxDuration` rail shared by every durable Attempt (RUN-030). */
+  /** Absolute `maxDuration` rail for this Attempt, optionally tightened by its coordinator. */
   readonly durationDeadlineMillis: number;
   history: Prompt.Prompt;
   modelCalls: number;
@@ -7921,9 +7921,8 @@ function streamWithCompletion<
           const maxDurationMillis = Duration.toMillis(agent.definition.policy.maxDuration);
           const attemptDeadlineMillis = attemptStartedAtMillis + maxDurationMillis;
 
-          // RUN-030: a durable coordinator supplies the logical Run deadline from
-          // canonical Run-start evidence. Taking the earlier deadline keeps this
-          // public option tightening-only for every other caller.
+          // A coordinator can impose an earlier deadline (for example a worker grant).
+          // This option can only tighten the fresh execution allowance.
           const durationDeadlineMillis =
             options.durationDeadline === undefined
               ? attemptDeadlineMillis