effect-agent 0.1.0-beta.96 → 0.1.0-beta.98

package/src/durable/internal/agent-registration.ts

@@ -18,6 +18,7 @@ import {
   ToolNamespace,
 } from "../../core/ToolExposure.ts";
 import { type RuntimeBinding } from "../../engine/AgentRuntime.ts";
+import { ContextRolloverTool } from "../../engine/ContextWindow.ts";
 import { getToolExecutionClass } from "../../engine/DurableStep.ts";
 import {
   BackgroundReporting,
@@ -26,44 +27,19 @@ import {
 } from "../../engine/SubagentHost.ts";
 import { digestDefinitions, digestJson, DigestError } from "../Digest.ts";
 import type { DurableWorkerFailure, DurableWorkerRequirements } from "../DurableAgentRuntime.ts";
-import {
-  DefinitionDigestInput,
-  DefinitionDigests,
-  ReplayContract,
-  type PersistedJson,
-} from "../Records.ts";
+import type { DefinitionDigestInput, PersistedJson } from "../Records.ts";
+import { DefinitionDigests, ReplayContract } from "../Records.ts";
 import type { Claim, Settlement } from "../SubmissionLedger.ts";
 
-/**
- * No Agent Binding is registered for the requested stable identity. Recovery
- * fails closed: it never substitutes the latest Binding or runs different
- * code.
- */
+/** No unique current executable is registered for the stable Agent identity. */
 export class BindingUnavailable extends Schema.TaggedError<BindingUnavailable>()(
   "BindingUnavailable",
-  {
-    agentId: AgentId,
-    message: Schema.String,
-  },
-) {}
-
-/**
- * A Binding is registered for the identity but neither the exact admission fingerprints
- * nor its declared replay contract support the retained pending operations. Refusal leaves
- * the original Submission pending until compatible code is available.
- */
-export class BindingDigestMismatch extends Schema.TaggedError<BindingDigestMismatch>()(
-  "BindingDigestMismatch",
-  {
-    agentId: AgentId,
-    message: Schema.String,
-  },
+  { agentId: AgentId, message: Schema.String },
 ) {}
 
-/** The typed refusal family of durable Binding resolution (spec §11, SUB-032). */
-export type DurableBindingFailure = BindingUnavailable | BindingDigestMismatch;
+export type DurableBindingFailure = BindingUnavailable;
 
-/** Byte-for-byte equality of two stored definition digest triples (SUB-023). */
+/** Exact immutable admission, lineage and delivery evidence; never an executable-code gate. */
 export const definitionDigestsEqual = (
   left: DefinitionDigests,
   right: DefinitionDigests,
@@ -73,67 +49,35 @@ export const definitionDigestsEqual = (
   left.tools === right.tools &&
   Schema.toEquivalence(Schema.UndefinedOr(ReplayContract))(left.replay, right.replay);
 
-/**
- * Host-owned semantic versions, independent of deployment and tool inventory. Change a version
- * when the meaning of an operation, its durable Step names or external idempotency keys changes.
- * Codecs and execution class are included automatically; JSON Schema alone cannot prove semantics.
- */
+/** Change an operation version when its meaning, durable Steps or idempotency keys change. */
 export interface ReplayVersions {
-  readonly agent: PersistedJson;
   readonly tools: Readonly<Record<string, PersistedJson>>;
 }
 
-/**
- * Data exported from a definition, never an old executable Binding. A host may supply an audited
- * manifest from the original release for work admitted before replay contracts were retained.
- * Its original declarations must hash to that admission; a bare old digest is not a manifest.
- */
-export class BindingManifest extends Schema.Class<BindingManifest>("BindingManifest")({
-  agentId: AgentId,
-  definitions: DefinitionDigestInput,
-  replay: ReplayContract,
-}) {}
-
-export const makeBindingManifest = Effect.fn("AgentRegistration.makeBindingManifest")(function* (
+/** Hash current operation contracts; no historical definitions or schemas are retained. */
+export const toolReplayContracts = Effect.fn("AgentRegistration.toolReplayContracts")(function* (
   definition: Agent.AnyDefinition,
-  definitions: DefinitionDigestInput,
-  versions: ReplayVersions,
+  versions?: ReplayVersions,
+  fallbackVersion: PersistedJson = null,
 ) {
-  const jsonSchema = (schema: Schema.Top) =>
-    Schema.decodeUnknownSync(Schema.Json)(Tool.getJsonSchemaFromSchema(schema));
-
-  const contracts = yield* Effect.try({
+  const declarations = yield* Effect.try({
     try: () => {
-      const tools = Object.values(definition.toolkit.tools);
-
-      if (tools.some((tool) => !Object.hasOwn(versions.tools, tool.name)))
-        throw new Error("Every Tool needs an explicit replay semantic version");
-
-      return {
-        agent: {
-          version: versions.agent,
-          id: definition.id,
-          input: jsonSchema(definition.input),
-          output: jsonSchema(definition.output),
-          updates: definition.updates === undefined ? null : jsonSchema(definition.updates),
-          completion:
-            definition.completion === undefined
-              ? null
-              : {
-                  tool: definition.completion.tool,
-                  required: definition.completion.required ?? false,
-                },
-          completionFromTools:
-            definition.completionFromTools?.map((entry) => entry.tool).sort() ?? [],
-          disposition:
-            definition.runDisposition === undefined
-              ? null
-              : jsonSchema(definition.runDisposition.schema),
-        },
-        tools: tools.map((tool) => ({
+      const jsonSchema = (schema: Schema.Top) =>
+        Schema.decodeUnknownSync(Schema.Json)(Tool.getJsonSchemaFromSchema(schema));
+
+      return Object.values(definition.toolkit.tools).map((tool) => {
+        const version = versions === undefined ? fallbackVersion : versions.tools[tool.name];
+
+        if (
+          version === undefined ||
+          (versions !== undefined && !Object.hasOwn(versions.tools, tool.name))
+        )
+          throw new Error("Every Tool needs an explicit replay semantic version");
+
+        return {
           name: tool.name,
           contract: {
-            version: versions.tools[tool.name]!,
+            version,
             parameters: jsonSchema(tool.parametersSchema),
             success: jsonSchema(tool.successSchema),
             failure: jsonSchema(tool.failureSchema),
@@ -142,59 +86,47 @@ export const makeBindingManifest = Effect.fn("AgentRegistration.makeBindingManif
               typeof tool.needsApproval === "function" ? "dynamic" : (tool.needsApproval ?? false),
             executionClass: getToolExecutionClass(tool),
             executionKind: getToolExecutionKind(tool.annotations),
+            contextRollover: Context.get(tool.annotations, ContextRolloverTool),
+            completion: definition.completion?.tool === tool.name,
+            completionFromTool:
+              definition.completionFromTools?.some(
+                (declaration) => declaration.tool === tool.name,
+              ) ?? false,
           },
-        })),
-      };
+        };
+      });
     },
     catch: () =>
       DigestError.make({
-        message:
-          "Replay contracts require serializable codecs and an explicit semantic version for every Tool",
+        message: "Operation contracts require serializable codecs and a version for every Tool",
       }),
   });
 
-  const agent = yield* digestJson(contracts.agent);
-
-  const tools = yield* Effect.forEach(contracts.tools, ({ name, contract }) =>
-    digestJson(contract).pipe(Effect.map((digest) => [name, digest] as const)),
+  return Object.fromEntries(
+    yield* Effect.forEach(declarations, ({ name, contract }) =>
+      digestJson(contract).pipe(Effect.map((digest) => [name, digest] as const)),
+    ),
   );
-
-  return BindingManifest.make({
-    agentId: definition.id,
-    definitions,
-    replay: ReplayContract.make({ agent, tools: Object.fromEntries(tools) }),
-  });
 });
 
-const replaySupports = (
-  current: ReplayContract,
-  retained: ReplayContract,
-  requiredTools?: ReadonlyArray<string>,
-): boolean =>
-  current.agent === retained.agent &&
-  (requiredTools ?? Object.keys(retained.tools)).every(
-    (name) => retained.tools[name] !== undefined && current.tools[name] === retained.tools[name],
-  );
-
-/** Resolve executable code only. Admission, delivery, lineage and receipt comparisons stay exact. */
-export const bindingSupports = (
-  binding: Pick<ResolvedBinding, "digests" | "retainedManifests">,
-  digests: DefinitionDigests,
-  requiredTools?: ReadonlyArray<string>,
-): boolean => {
-  if (definitionDigestsEqual(binding.digests, digests)) return true;
-
-  const retained =
-    digests.replay ??
-    binding.retainedManifests?.find((entry) => definitionDigestsEqual(entry.digests, digests))
-      ?.replay;
-
-  return (
-    binding.digests.replay !== undefined &&
-    retained !== undefined &&
-    replaySupports(binding.digests.replay, retained, requiredTools)
-  );
-};
+/** Compile current metadata without acquiring executable services. */
+export const compileBindingContracts = Effect.fn("AgentRegistration.compileBindingContracts")(
+  function* (
+    definition: Agent.AnyDefinition,
+    definitions: DefinitionDigestInput,
+    versions?: ReplayVersions,
+  ): Effect.fn.Return<Pick<ResolvedBinding, "digests">, DigestError, Crypto.Crypto> {
+    const digests = yield* digestDefinitions(definitions);
+    const tools = yield* toolReplayContracts(definition, versions, definitions.tools);
+
+    return {
+      digests: DefinitionDigests.make({
+        ...digests,
+        replay: ReplayContract.make({ agent: digests.agent, tools }),
+      }),
+    };
+  },
+);
 
 type ExecutableDefinition = Agent.AnyDefinition & {
   readonly instructions: InstructionSource<never, unknown, unknown>;
@@ -326,11 +258,6 @@ const backgroundReports = (definition: Agent.AnyDefinition) => [
 /** One exact executable registration used by durable claim-time resolution. */
 export interface ResolvedBinding extends CapturedBinding {
   readonly digests: DefinitionDigests;
-  readonly manifest?: BindingManifest;
-  readonly retainedManifests?: ReadonlyArray<{
-    readonly digests: DefinitionDigests;
-    readonly replay: ReplayContract;
-  }>;
 }
 
 /** Trusted claim identity for resolving per-Attempt application services. Not model input. */
@@ -427,37 +354,18 @@ export const makeLegacyWorkerBinding = capture;
 export const resolveWorkerBinding = (
   bindings: ReadonlyArray<ResolvedBinding>,
   agentId: AgentId,
-  digests: DefinitionDigests,
-  requiredTools?: ReadonlyArray<string>,
-): Effect.Effect<ResolvedBinding, DurableBindingFailure> => {
+): Effect.Effect<ResolvedBinding, BindingUnavailable> => {
   const registered = bindings.filter((binding) => binding.agentId === agentId);
-
-  if (registered.length === 0) {
-    return Effect.fail(
-      BindingUnavailable.make({
-        agentId,
-        message: `No Agent Binding is registered for ${agentId}; recovery never substitutes different code (SUB-023)`,
-      }),
-    );
-  }
-  const exact = registered.find((binding) => definitionDigestsEqual(binding.digests, digests));
-
-  const compatible =
-    exact ??
-    (registered.length === 1 && bindingSupports(registered[0]!, digests, requiredTools)
-      ? registered[0]
-      : undefined);
-
-  if (compatible === undefined) {
-    return Effect.fail(
-      BindingDigestMismatch.make({
-        agentId,
-        message: `No registered Binding proves the retained replay contracts for ${agentId}; the original request and receipts remain pending`,
-      }),
-    );
-  }
-
-  return Effect.succeed(compatible);
+  const binding = registered[0];
+
+  return registered.length === 1 && binding !== undefined
+    ? Effect.succeed(binding)
+    : Effect.fail(
+        BindingUnavailable.make({
+          agentId,
+          message: `Exactly one current Agent Binding must be registered for ${agentId}`,
+        }),
+      );
 };
 
 /** Resolve authoring-time admission through the one exact host registration, never by identity alone. */
@@ -498,10 +406,9 @@ export type AgentRegistration<A extends ExecutableAgentBinding = ExecutableAgent
       readonly definitions: DefinitionDigestInput;
     }
 ) & {
-  /** Opt into contract-checked deployment continuity. Omit to require an exact registration. */
+  /** Explicit operation versions let unchanged unfinished handlers survive toolbox changes. */
   readonly continuity?: {
     readonly versions: ReplayVersions;
-    readonly retainedManifests?: ReadonlyArray<BindingManifest>;
   };
   /**
    * Source-owned reports capture services outside attemptLayer and open a fresh Scope per
@@ -632,8 +539,8 @@ const compileRegistration = <Entry extends AgentRegistration>(
       try: () => registrationDefinitions(entry),
       catch: () =>
         DigestError.make({ message: "Agent update schema has no serializable wire contract" }),
-    }).pipe(Effect.flatMap(digestDefinitions)),
-    (digests) =>
+    }),
+    (definitions) =>
       Effect.gen(function* () {
         const binding = yield* capture(
           entry.model === undefined ? entry.agent : { definition: entry.agent, model: entry.model },
@@ -645,32 +552,14 @@ const compileRegistration = <Entry extends AgentRegistration>(
           ...backgroundReports(binding.definition),
         ]);
 
-        if (entry.continuity === undefined) return { ...binding, digests, reporting };
-
-        const manifest = yield* makeBindingManifest(
-          binding.definition,
-          registrationDefinitions(entry),
-          entry.continuity.versions,
-        );
-
-        const retainedManifests = yield* Effect.forEach(
-          entry.continuity.retainedManifests ?? [],
-          (retained) =>
-            retained.agentId === binding.agentId
-              ? digestDefinitions(retained.definitions).pipe(
-                  Effect.map((digests) => ({ digests, replay: retained.replay })),
-                )
-              : Effect.fail(
-                  DigestError.make({ message: "A retained manifest belongs to another Agent" }),
-                ),
-        );
-
         return {
           ...binding,
-          digests: DefinitionDigests.make({ ...digests, replay: manifest.replay }),
+          ...(yield* compileBindingContracts(
+            binding.definition,
+            definitions,
+            entry.continuity?.versions,
+          )),
           reporting,
-          manifest,
-          retainedManifests,
         };
       }),
     // The erased descriptor accepts arbitrary provided services. Restore the concrete entry's

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

@@ -52,7 +52,6 @@ import {
 } from "../ThreadStore.ts";
 import {
   definitionDigestsEqual,
-  bindingSupports,
   resolveDefinitionBinding,
   type ResolvedBinding,
 } from "./agent-registration.ts";
@@ -103,10 +102,7 @@ export const makeMessagingRuntime = Effect.fn("MessagingHost.make")(function* (
 
     if (created?._tag !== "ThreadCreated") return yield* failure("context", "not-found");
 
-    const matching = deps.bindings.filter(
-      (binding) =>
-        binding.agentId === created.agentId && bindingSupports(binding, created.definitions),
-    );
+    const matching = deps.bindings.filter((binding) => binding.agentId === created.agentId);
 
     if (matching.length !== 1) return yield* failure("context", "binding-mismatch");
 
@@ -310,7 +306,6 @@ export const makeMessagingRuntime = Effect.fn("MessagingHost.make")(function* (
             !Schema.is(MessageAdmission)(metadata) ||
             metadata.peerName !== request.name ||
             saved.envelope.agentId !== target.agentId ||
-            !bindingSupports(target, saved.envelope.definitions) ||
             !sameJson(saved.envelope.input, input) ||
             (inReplyTo === undefined || metadata.inReplyTo === undefined
               ? inReplyTo !== metadata.inReplyTo