@yielded/agent 0.1.0-beta.173 → 0.1.0-beta.174

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

@@ -105,6 +105,11 @@ export const toolReplayContracts = Effect.fnUntraced(function* (
   // different host Crypto service must never inherit another host's digest map.
   const crypto = Option.getOrUndefined(yield* Effect.serviceOption(Crypto.Crypto));
 
+  const invalidContracts = () =>
+    DigestError.make({
+      message: "Operation contracts require serializable codecs and a version for every Tool",
+    });
+
   const prepared = yield* Effect.try({
     try: () => {
       const tools = Object.values(definition.toolkit.tools);
@@ -146,16 +151,38 @@ export const toolReplayContracts = Effect.fnUntraced(function* (
         return projection;
       };
 
-      const declarations = tools.map((tool) => {
-        const version = versions === undefined ? fallbackVersion : versions.tools[tool.name];
+      return {
+        _tag: "Compile" as const,
+        jsonSchema,
+        cacheable,
+        tools,
+        completionTool,
+        completionFromTools,
+      };
+    },
+    catch: () =>
+      DigestError.make({
+        message: "Operation contracts require serializable codecs and a version for every Tool",
+      }),
+  });
+
+  if (prepared._tag === "Cached") return prepared.contracts;
 
-        if (
-          version === undefined ||
-          (versions !== undefined && !Object.hasOwn(versions.tools, tool.name))
-        )
-          throw new Error("Every Tool needs an explicit replay semantic version");
+  const declarations = yield* Effect.forEach(
+    prepared.tools,
+    Effect.fnUntraced(function* (tool) {
+      const { version, present } = yield* Effect.try({
+        try: () => ({
+          version: versions === undefined ? fallbackVersion : versions.tools[tool.name],
+          present: versions === undefined || Object.hasOwn(versions.tools, tool.name),
+        }),
+        catch: invalidContracts,
+      });
 
-        return {
+      if (version === undefined || !present) return yield* invalidContracts();
+
+      return yield* Effect.try({
+        try: () => ({
           name: tool.name,
           contract: {
             version,
@@ -170,9 +197,9 @@ export const toolReplayContracts = Effect.fnUntraced(function* (
                   readonly: Context.get(tool.annotations, Tool.Readonly),
                 }
               : {}),
-            parameters: jsonSchema(tool.parametersSchema),
-            success: jsonSchema(tool.successSchema),
-            failure: jsonSchema(tool.failureSchema),
+            parameters: prepared.jsonSchema(tool.parametersSchema),
+            success: prepared.jsonSchema(tool.successSchema),
+            failure: prepared.jsonSchema(tool.failureSchema),
             failureMode: tool.failureMode,
             needsApproval:
               typeof tool.needsApproval === "function" ? "dynamic" : (tool.needsApproval ?? false),
@@ -185,28 +212,14 @@ export const toolReplayContracts = Effect.fnUntraced(function* (
                 (declaration) => declaration.tool === tool.name,
               ) ?? false,
           },
-        };
+        }),
+        catch: invalidContracts,
       });
-
-      return {
-        _tag: "Compile" as const,
-        declarations,
-        cacheable,
-        tools,
-        completionTool,
-        completionFromTools,
-      };
-    },
-    catch: () =>
-      DigestError.make({
-        message: "Operation contracts require serializable codecs and a version for every Tool",
-      }),
-  });
-
-  if (prepared._tag === "Cached") return prepared.contracts;
+    }),
+  );
 
   const contracts = Object.fromEntries(
-    yield* Effect.forEach(prepared.declarations, ({ name, contract }) =>
+    yield* Effect.forEach(declarations, ({ name, contract }) =>
       digestJson(contract).pipe(Effect.map((digest) => [name, digest] as const)),
     ),
   );
@@ -365,7 +378,7 @@ const omitTraceContext = Context.omit(
 const withoutTraceContext = <R>(context: Context.Context<R>): Context.Context<R> =>
   omitTraceContext(context) as Context.Context<R>;
 
-const captureReporting = <R>(reports: ReadonlyArray<WorkerReporting<unknown, R>>) =>
+const captureReporting = <E, R>(reports: ReadonlyArray<WorkerReporting<E, R>>) =>
   Effect.map(
     Effect.context<Exclude<R, Scope.Scope>>().pipe(Effect.map(withoutTraceContext)),
     (context) =>
@@ -405,18 +418,19 @@ export interface AgentAttemptContext {
   readonly attemptId: Claim["attemptId"];
 }
 
-const capture = <A extends ExecutableAgentBinding, Provides = never, Requires = never>(
+const capture = <A extends ExecutableAgentBinding, Requires>(
   agent: A,
-  attemptLayer?: (context: AgentAttemptContext) => Layer.Layer<Provides, never, Requires>,
-): Effect.Effect<
-  CapturedBinding,
-  never,
-  Exclude<DurableWorkerRequirements<A>, Provides> | Requires
-> =>
+  prepare: (
+    execute: ReturnType<CapturedAttempt<A>>,
+    context: AgentAttemptContext,
+  ) => Effect.Effect<
+    Option.Option<Settlement>,
+    DurableWorkerFailure | DurableBindingFailure,
+    Requires
+  >,
+): Effect.Effect<CapturedBinding, never, Requires> =>
   Effect.map(
-    Effect.context<Exclude<DurableWorkerRequirements<A>, Provides> | Requires>().pipe(
-      Effect.map(withoutTraceContext),
-    ),
+    Effect.context<Requires>().pipe(Effect.map(withoutTraceContext)),
     (context): CapturedBinding => ({
       agentId: agent.definition.id,
       definition: agent.definition,
@@ -433,29 +447,23 @@ const capture = <A extends ExecutableAgentBinding, Provides = never, Requires =
           claim.attemptId,
         );
 
-        const scoped =
-          attemptLayer === undefined
-            ? execute
-            : execute.pipe(
-                Effect.provide(
-                  Layer.fresh(
-                    attemptLayer({
-                      threadId,
-                      submissionId: claim.submissionId,
-                      attemptId: claim.attemptId,
-                    }),
-                  ),
-                ),
-              );
-
-        return scoped.pipe(Effect.provide(context)) as Effect.Effect<
-          Option.Option<Settlement>,
-          DurableWorkerFailure | DurableBindingFailure
-        >;
+        return prepare(execute, {
+          threadId,
+          submissionId: claim.submissionId,
+          attemptId: claim.attemptId,
+        }).pipe(Effect.provide(context));
       },
     }),
   );
 
+const captureWithAttemptLayer = <A extends ExecutableAgentBinding, Provides, Requires>(
+  agent: A,
+  attemptLayer: (context: AgentAttemptContext) => Layer.Layer<Provides, never, Requires>,
+) =>
+  capture(agent, (execute, context) =>
+    execute.pipe(Effect.provide(Layer.fresh(attemptLayer(context)))),
+  );
+
 /**
  * Build one exact worker registration from an executable Agent Binding and
  * its already-computed definition digests.
@@ -471,7 +479,7 @@ export const DurableWorkerBinding = {
     digests: DefinitionDigests,
   ): Effect.Effect<ResolvedBinding, never, DurableWorkerRequirements<A>> =>
     Effect.gen(function* () {
-      const binding = yield* capture(agent);
+      const binding = yield* capture(agent, (execute) => execute);
       const reporting = yield* captureReporting(backgroundReports(agent.definition));
 
       return { ...binding, digests, reporting };
@@ -479,7 +487,8 @@ export const DurableWorkerBinding = {
 } as const;
 
 /** INTERNAL identity-only capture retained for the legacy direct worker path. */
-export const makeLegacyWorkerBinding = capture;
+export const makeLegacyWorkerBinding = <A extends ExecutableAgentBinding>(agent: A) =>
+  capture(agent, (execute) => execute);
 
 export const resolveWorkerBinding = Effect.fnUntraced(function* (
   bindings: ReadonlyArray<ResolvedBinding>,
@@ -576,11 +585,9 @@ type EntryRequirements<Entry> = Entry extends unknown
     >
   : never;
 
-type RegistrationRequirements<Entries extends ReadonlyArray<AgentRegistration>> = [
-  Entries[number],
-] extends [never]
-  ? never
-  : EntryRequirements<Entries[number]>;
+type RegistrationRequirements<Entries extends ReadonlyArray<AgentRegistration>> = EntryRequirements<
+  Entries[number]
+>;
 
 const registrationDefinitions = (entry: AgentRegistration): DefinitionDigestInput => {
   const definition = entry.model === undefined ? entry.agent.definition : entry.agent;
@@ -655,10 +662,13 @@ const registrationDefinitions = (entry: AgentRegistration): DefinitionDigestInpu
   };
 };
 
-const compileRegistration = <Entry extends AgentRegistration>(
+// The public signature distributes over descriptors, including optional attempt Layers.
+// The implementation consumes their erased union and captures the selected Layer's context.
+function compileRegistration<Entry extends AgentRegistration>(
   entry: Entry,
-): Effect.Effect<ResolvedBinding, DigestError, Crypto.Crypto | EntryRequirements<Entry>> =>
-  Effect.flatMap(
+): Effect.Effect<ResolvedBinding, DigestError, Crypto.Crypto | EntryRequirements<Entry>>;
+function compileRegistration(entry: AgentRegistration) {
+  return Effect.flatMap(
     Effect.try({
       try: () => registrationDefinitions(entry),
       catch: () =>
@@ -666,10 +676,19 @@ const compileRegistration = <Entry extends AgentRegistration>(
     }),
     (definitions) =>
       Effect.gen(function* () {
-        const binding = yield* capture(
-          entry.model === undefined ? entry.agent : { definition: entry.agent, model: entry.model },
-          entry.attemptLayer,
-        );
+        const agent =
+          // The heterogeneous descriptor erases model services; the overload retains EntryRequirements.
+          // @effect-diagnostics-next-line anyUnknownInErrorContext:off
+          entry.model === undefined ? entry.agent : { definition: entry.agent, model: entry.model };
+
+        // Omitted attempt services need no Layer construction or provisioning scope.
+        const binding = yield* entry.attemptLayer === undefined
+          ? // Capture closes the erased requirements over the registration's actual Context.
+            // @effect-diagnostics-next-line anyUnknownInErrorContext:off
+            capture(agent, (execute) => execute)
+          : // The selected Layer discharges its services before the remaining Context is captured.
+            // @effect-diagnostics-next-line anyUnknownInErrorContext:off
+            captureWithAttemptLayer(agent, entry.attemptLayer);
 
         const reporting = yield* captureReporting(backgroundReports(binding.definition));
 
@@ -683,9 +702,8 @@ const compileRegistration = <Entry extends AgentRegistration>(
           reporting,
         };
       }),
-    // The erased descriptor accepts arbitrary provided services. Restore the concrete entry's
-    // Exclude<worker requirements, provided services> | layer requirements at this collection seam.
-  ) as Effect.Effect<ResolvedBinding, DigestError, Crypto.Crypto | EntryRequirements<Entry>>;
+  );
+}
 
 /** Compile heterogeneous Agent descriptors into exact, dependency-closed worker registrations. */
 export const compileRegistrations = <const Entries extends ReadonlyArray<AgentRegistration>>(
@@ -695,16 +713,5 @@ export const compileRegistrations = <const Entries extends ReadonlyArray<AgentRe
   DigestError,
   Crypto.Crypto | RegistrationRequirements<Entries>
 > => {
-  // `Effect.forEach` instantiates a generic callback at its constraint. Specialize the callback to
-  // this tuple's distributed requirement union before collection so empty and heterogeneous tuples
-  // retain their exact service requirements.
-  const compileEntry = compileRegistration as unknown as (
-    entry: Entries[number],
-  ) => Effect.Effect<
-    ResolvedBinding,
-    DigestError,
-    Crypto.Crypto | RegistrationRequirements<Entries>
-  >;
-
-  return Effect.forEach(entries, compileEntry);
+  return Effect.forEach(entries, compileRegistration<Entries[number]>);
 };

package/src/durable/internal/canonical-json.ts

@@ -1,4 +1,4 @@
-import { Array, type Schema } from "effect";
+import { Array, Predicate, Result, Schema } from "effect";
 
 interface JsonLimits {
   readonly depth: number;
@@ -7,19 +7,36 @@ interface JsonLimits {
   readonly textUnits: number;
 }
 
+export class CanonicalJsonLimitError extends Schema.TaggedError<CanonicalJsonLimitError>()(
+  "CanonicalJsonLimitError",
+  { message: Schema.String },
+) {}
+
+// Only this codec's private synchronous aborts become typed bounds failures.
+const boundsFailures = new WeakMap<object, string>();
+
+const exceeded = (bound: "text" | "traversal" | "collection"): never => {
+  const message = `Canonical JSON exceeds its ${bound} bound`;
+  // oxlint-disable-next-line effect/no-native-error -- Private synchronous codec abort; the Result boundary translates only errors owned here.
+  const error = new RangeError(message);
+
+  boundsFailures.set(error, message);
+  // oxlint-disable-next-line effect/no-untyped-throw -- Abort synchronous JSON traversal at the first exceeded bound; the Result boundary catches this owned error.
+  throw error;
+};
+
 /** Values have already crossed their Schema boundary; visit each serialized occurrence. */
-export const canonicalJson = (value: Schema.Json, limits?: JsonLimits): string => {
+const serialize = (value: Schema.Json, limits?: JsonLimits): string => {
   let nodes = 0;
   let textUnits = 0;
 
   const charge = (length: number) => {
-    if (limits !== undefined && (textUnits += length) > limits.textUnits)
-      throw new RangeError("Canonical JSON exceeds its text bound");
+    if (limits !== undefined && (textUnits += length) > limits.textUnits) return exceeded("text");
   };
 
   const visit = (value: Schema.Json, depth: number): string => {
     if (limits !== undefined && (depth > limits.depth || ++nodes > limits.nodes))
-      throw new RangeError("Canonical JSON exceeds its traversal bound");
+      return exceeded("traversal");
     if (
       value === null ||
       typeof value === "boolean" ||
@@ -34,30 +51,54 @@ export const canonicalJson = (value: Schema.Json, limits?: JsonLimits): string =
     }
     if (Array.isArray<Schema.Json>(value)) {
       if (limits !== undefined && value.length > limits.collectionLength)
-        throw new RangeError("Canonical JSON exceeds its collection bound");
+        return exceeded("collection");
       charge(2 + Math.max(0, value.length - 1));
 
-      return `[${globalThis.Array.from(value, (entry) => visit(entry, depth + 1)).join(",")}]`;
+      let json = "[";
+
+      for (let index = 0; index < value.length; index++) {
+        if (index > 0) json += ",";
+        json += visit(value[index], depth + 1);
+      }
+
+      return `${json}]`;
     }
 
-    const entries = Object.entries(value).sort(([left], [right]) =>
-      left < right ? -1 : left > right ? 1 : 0,
-    );
+    const keys = Object.keys(value).sort();
 
-    if (limits !== undefined && entries.length > limits.collectionLength)
-      throw new RangeError("Canonical JSON exceeds its collection bound");
-    charge(2 + Math.max(0, entries.length - 1));
+    if (limits !== undefined && keys.length > limits.collectionLength)
+      return exceeded("collection");
+    charge(2 + Math.max(0, keys.length - 1));
+    let json = "{";
 
-    return `{${entries
-      .map(([key, entry]) => {
-        const encodedKey = JSON.stringify(key);
+    for (let index = 0; index < keys.length; index++) {
+      const key = keys[index];
+      const encodedKey = JSON.stringify(key);
 
-        charge(encodedKey.length + 1);
+      charge(encodedKey.length + 1);
+      if (index > 0) json += ",";
+      json += `${encodedKey}:${visit(value[key], depth + 1)}`;
+    }
 
-        return `${encodedKey}:${visit(entry, depth + 1)}`;
-      })
-      .join(",")}}`;
+    return `${json}}`;
   };
 
   return visit(value, 0);
 };
+
+export const canonicalJson = (value: Schema.Json): string => serialize(value);
+
+export const boundedCanonicalJson = (
+  value: Schema.Json,
+  limits: JsonLimits,
+): Result.Result<string, CanonicalJsonLimitError> => {
+  try {
+    return Result.succeed(serialize(value, limits));
+  } catch (cause) {
+    const message = Predicate.isObjectKeyword(cause) ? boundsFailures.get(cause) : undefined;
+
+    if (message !== undefined) return Result.fail(CanonicalJsonLimitError.make({ message }));
+    // oxlint-disable-next-line effect/no-untyped-throw -- Foreign JSON/getter errors retain their identity for the caller's typed capture boundary.
+    throw cause;
+  }
+};

package/src/durable/internal/prompt-history-cache.ts

@@ -1,4 +1,4 @@
-import { Effect, Option, Schema, Stream } from "effect";
+import { Effect, Option, Result, Schema, Stream } from "effect";
 import { Prompt } from "effect/ai";
 
 import type { RunId, ThreadId } from "../../core/Identifiers.ts";
@@ -87,7 +87,8 @@ function hydratePart(part: Prompt.PartEncoded): Prompt.Part {
     case "tool-approval-response":
       return Prompt.toolApprovalResponsePart(part);
   }
-  throw new Error(`Unhandled Prompt part: ${part satisfies never}`);
+
+  return part satisfies never;
 }
 
 const hydrateMessage = (message: Prompt.MessageEncoded): Prompt.Message => {
@@ -116,7 +117,8 @@ const hydrateMessage = (message: Prompt.MessageEncoded): Prompt.Message => {
         content: message.content.map((p) => hydratePart(p)),
       });
   }
-  throw new Error(`Unhandled Prompt message: ${message satisfies never}`);
+
+  return message satisfies never;
 };
 
 export interface PromptHistory {
@@ -291,7 +293,14 @@ export const makeCommittedPromptSuffix = (original: CanonicalRecordEnvelope) =>
     // as readPrompt, never raw provider values. Failure invalidates this derivative, not the commit.
     try {
       for (const fact of facts) {
-        const owned = captureRecord(fact);
+        const captured = captureRecord(fact);
+
+        if (Result.isFailure(captured)) {
+          discard();
+
+          return;
+        }
+        const owned = captured.success;
         const payload = owned.canonical.payload;
 
         if (