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

package/src/durable/internal/record-encoding.ts

@@ -1,4 +1,4 @@
-import { DateTime, Predicate, Schema } from "effect";
+import { DateTime, Predicate, Result, Schema } from "effect";
 
 import type { RunId } from "../../core/Identifiers.ts";
 import { utf8ByteLength } from "../../core/internal/utf8.ts";
@@ -13,7 +13,7 @@ import {
   type RecordJson,
   type RunContinuation,
 } from "../Records.ts";
-import { canonicalJson } from "./canonical-json.ts";
+import { boundedCanonicalJson, canonicalJson } from "./canonical-json.ts";
 import {
   executionRunIds,
   isPreContinuationFact,
@@ -31,6 +31,11 @@ const recordLimits = {
   textUnits: MAX_CANONICAL_RECORD_BYTES,
 };
 
+export class RecordEncodingError extends Schema.TaggedError<RecordEncodingError>()(
+  "RecordEncodingError",
+  { message: Schema.String, cause: Schema.optionalKey(Schema.Defect()) },
+) {}
+
 export interface RecordEncoding {
   readonly canonical: RecordEnvelope;
   readonly wire: RecordJson;
@@ -39,6 +44,10 @@ export interface RecordEncoding {
   readonly progress: ProgressAppendRecord;
 }
 
+interface CapturedRecordEncoding extends RecordEncoding {
+  readonly wire: typeof RecordEnvelope.Encoded;
+}
+
 /** Private capture metadata, never caller-supplied wire data or execution authority. */
 export interface ProgressAppendRecord {
   readonly recordId: RecordEnvelope["recordId"];
@@ -67,7 +76,40 @@ const progressRecord = (record: RecordEnvelope, bytes: number): ProgressAppendRe
   });
 };
 
-const captured = new WeakMap<RecordEnvelope, RecordEncoding>();
+const captured = new WeakMap<RecordEnvelope, CapturedRecordEncoding>();
+
+// Define own data properties so valid JSON keys never invoke inherited setters.
+const setOwn = (target: object, key: PropertyKey, value: unknown): void => {
+  Object.defineProperty(target, key, {
+    value,
+    writable: true,
+    enumerable: true,
+    configurable: true,
+  });
+};
+
+/** JSON arrays use indexed values, even when inherited or non-enumerable. */
+const copyOwn = (value: object): object => {
+  if (!Array.isArray(value)) {
+    const copy = { ...value };
+
+    Object.setPrototypeOf(copy, Object.getPrototypeOf(value));
+
+    return copy;
+  }
+  const copy: Array<unknown> = [];
+
+  for (let index = 0; index < value.length; index++) setOwn(copy, index, value[index]);
+  for (const key of Reflect.ownKeys(value)) {
+    if (
+      !Object.hasOwn(copy, key) &&
+      Object.getOwnPropertyDescriptor(value, key)?.enumerable === true
+    )
+      setOwn(copy, key, Reflect.get(value, key));
+  }
+
+  return copy;
+};
 
 /** Own every fact before suspension; encoded JSON fields can share these private frozen values. */
 const capturePayload = (payload: CanonicalRecordPayload) => {
@@ -76,31 +118,26 @@ const capturePayload = (payload: CanonicalRecordPayload) => {
   Object.setPrototypeOf(copy, Object.getPrototypeOf(payload));
   const copies = new WeakMap<object, object>([[payload, copy]]);
 
-  const pending: Array<{ readonly source: object; readonly target: object }> = [
-    { source: payload, target: copy },
-  ];
+  const pending: Array<object> = [copy];
 
   const owned: Array<object> = [copy];
 
   while (pending.length > 0) {
     const next = pending.pop()!;
 
-    for (const [key, value] of Object.entries(next.source)) {
-      if (!Predicate.isObject(value)) continue;
+    for (const [key, value] of Object.entries(next)) {
+      if (!Predicate.isObjectOrArray(value)) continue;
       let child = copies.get(value);
 
       if (child === undefined) {
-        const created: object = Array.isArray(value)
-          ? []
-          : Object.create(Object.getPrototypeOf(value));
+        const created = copyOwn(value);
 
-        Object.assign(created, value);
         copies.set(value, created);
         owned.push(created);
-        pending.push({ source: value, target: created });
+        pending.push(created);
         child = created;
       }
-      Reflect.set(next.target, key, child);
+      setOwn(next, key, child);
     }
   }
   for (const value of owned) Object.freeze(value);
@@ -109,17 +146,17 @@ const capturePayload = (payload: CanonicalRecordPayload) => {
 };
 
 /** Schema-created structures are private; detach JSON pass-throughs using the same owned copy. */
-const ownWire = (wire: RecordJson, copies: WeakMap<object, object>): RecordJson => {
-  const pending: Array<object> = Predicate.isObject(wire) ? [wire] : [];
+const ownWire = <Wire extends RecordJson>(wire: Wire, copies: WeakMap<object, object>): Wire => {
+  const pending: Array<object> = Predicate.isObjectOrArray(wire) ? [wire] : [];
 
   while (pending.length > 0) {
     const next = pending.pop()!;
 
     for (const [key, value] of Object.entries(next)) {
-      if (!Predicate.isObject(value)) continue;
+      if (!Predicate.isObjectOrArray(value)) continue;
       const copy = copies.get(value);
 
-      if (copy !== undefined) Reflect.set(next, key, copy);
+      if (copy !== undefined) setOwn(next, key, copy);
       else pending.push(value);
     }
     Object.freeze(next);
@@ -129,66 +166,85 @@ const ownWire = (wire: RecordJson, copies: WeakMap<object, object>): RecordJson
 };
 
 /** Capture at the Schema boundary; only the privately owned result can reuse its encoding. */
-export const captureRecord = (input: RecordEnvelope): RecordEncoding => {
-  const existing = captured.get(input);
-
-  if (existing !== undefined) return existing;
-  const encoded = encodeRecord(input);
-  const owned = capturePayload(input.payload);
-  const wire = ownWire(encoded, owned.copies);
-  const json = canonicalJson(wire, recordLimits);
-  const bytes = utf8ByteLength(json);
-
-  if (bytes > MAX_CANONICAL_RECORD_BYTES)
-    throw new RangeError("Canonical JSON exceeds its byte bound");
-  const createdAt = DateTime.makeUnsafe(DateTime.toEpochMillis(input.createdAt));
-
-  // DateTime fills this cache lazily; populate it before freezing our private copy.
-  Object.freeze(DateTime.toPartsUtc(createdAt));
-  Object.freeze(createdAt);
-
-  const canonical = Object.freeze(
-    new RecordEnvelope(
-      {
-        ...input,
-        createdAt,
-        payload: owned.payload,
-      },
-      { disableChecks: true },
-    ),
-  );
-
-  const encoding = Object.freeze({
-    canonical,
-    wire,
-    json,
-    bytes,
-    progress: progressRecord(canonical, bytes),
-  });
+export const captureRecord = (
+  input: RecordEnvelope,
+): Result.Result<CapturedRecordEncoding, RecordEncodingError> => {
+  try {
+    const existing = captured.get(input);
+
+    if (existing !== undefined) return Result.succeed(existing);
+    const encoded = encodeRecord(input);
+    const owned = capturePayload(input.payload);
+    const wire = ownWire(encoded, owned.copies);
+    const serialized = boundedCanonicalJson(wire, recordLimits);
+
+    if (Result.isFailure(serialized))
+      return Result.fail(RecordEncodingError.make({ message: serialized.failure.message }));
+    const json = serialized.success;
+    const bytes = utf8ByteLength(json);
 
-  captured.set(canonical, encoding);
+    if (bytes > MAX_CANONICAL_RECORD_BYTES)
+      return Result.fail(
+        RecordEncodingError.make({ message: "Canonical JSON exceeds its byte bound" }),
+      );
+    const createdAt = DateTime.makeUnsafe(DateTime.toEpochMillis(input.createdAt));
+
+    // DateTime fills this cache lazily; populate it before freezing our private copy.
+    Object.freeze(DateTime.toPartsUtc(createdAt));
+    Object.freeze(createdAt);
+
+    const canonical = Object.freeze(
+      RecordEnvelope.make(
+        {
+          ...input,
+          createdAt,
+          payload: owned.payload,
+        },
+        { disableChecks: true },
+      ),
+    );
+
+    const encoding = Object.freeze({
+      canonical,
+      wire,
+      json,
+      bytes,
+      progress: progressRecord(canonical, bytes),
+    });
 
-  return encoding;
+    captured.set(canonical, encoding);
+
+    return Result.succeed(encoding);
+  } catch (cause) {
+    return Result.fail(
+      RecordEncodingError.make({ message: "Canonical record capture failed", cause }),
+    );
+  }
 };
 
 /** Read evidence retains its original wire; fresh writes use the captured Schema encoding. */
-export const recordEncoding = (record: RecordEnvelope): RecordEncoding => {
+export const recordEncoding = (
+  record: RecordEnvelope,
+): Result.Result<RecordEncoding, RecordEncodingError> => {
   const existing = captured.get(record);
 
-  if (existing !== undefined) return existing;
-  if (record instanceof ExportedRecord) {
-    const json = canonicalJson(record.wire);
+  if (existing !== undefined) return Result.succeed(existing);
 
+  try {
+    if (!(record instanceof ExportedRecord)) return captureRecord(record);
+    const json = canonicalJson(record.wire);
     const bytes = utf8ByteLength(json);
 
-    return {
+    return Result.succeed({
       canonical: record,
       wire: record.wire,
       json,
       bytes,
       progress: progressRecord(record, bytes),
-    };
+    });
+  } catch (cause) {
+    return Result.fail(
+      RecordEncodingError.make({ message: "Canonical record encoding failed", cause }),
+    );
   }
-
-  return captureRecord(record);
 };

package/src/durable/internal/schedule-time.ts

@@ -156,14 +156,14 @@ export const scheduleNextAfter = (
           while (next <= afterMillis) {
             const following = Cron.next(cron.success, next).getTime();
 
-            if (following <= next) throw new Error("Cron did not advance");
+            if (following <= next) return invalid("Cron has no supported next firing");
             next = following;
           }
 
-          return next;
+          return checkedInstant(next, "Next cron occurrence");
         },
         catch: () => ScheduleValidationError.make({ message: "Cron has no supported next firing" }),
-      }).pipe(Result.flatMap((next) => checkedInstant(next, "Next cron occurrence")));
+      }).pipe(Result.flatMap((result) => result));
     }
   }
 };
@@ -250,15 +250,15 @@ export const scheduleDueOccurrence = (
         let next = Cron.next(cron.success, intended).getTime();
 
         while (next <= nowMillis) {
-          if (next <= intended) throw new Error("Cron did not advance");
+          if (next <= intended) return invalid("Cron has no supported due firing");
           intended = next;
           next = Cron.next(cron.success, intended).getTime();
         }
 
-        return { intended, next };
+        return Result.succeed({ intended, next });
       },
       catch: () => ScheduleValidationError.make({ message: "Cron has no supported due firing" }),
-    });
+    }).pipe(Result.flatMap((result) => result));
 
     if (Result.isFailure(due)) return Result.fail(due.failure);
     const next = checkedInstant(due.success.next, "Next cron occurrence");

package/src/durable/internal/usage-totals.ts

@@ -0,0 +1,35 @@
+import { Effect } from "effect";
+
+import { summarizeModelUsage, type ModelCallUsage } from "../../core/Usage.ts";
+
+/** Captured calls are additive and nonnegative; progress does not need attribution groups. */
+export const continuationUsage = (calls: ReadonlyArray<ModelCallUsage>) =>
+  Effect.suspend(() => {
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let costMicrousd = 0;
+    let knownWebSearchCalls = 0;
+
+    for (const call of calls) {
+      inputTokens += call.inputTokens.total;
+      outputTokens += call.outputTokens.total;
+      costMicrousd += call.costMicrousd;
+      knownWebSearchCalls += call.webSearchCalls ?? 0;
+    }
+    if (
+      Number.isSafeInteger(inputTokens) &&
+      Number.isSafeInteger(outputTokens) &&
+      Number.isSafeInteger(costMicrousd) &&
+      Number.isSafeInteger(knownWebSearchCalls)
+    )
+      return Effect.succeed({ modelCalls: calls.length, inputTokens, outputTokens, costMicrousd });
+
+    // Safe global sums bound every component/group. On overflow retain the full validator,
+    // including groups whose hosted-search coverage differs from the aggregate's coverage.
+    return Effect.map(summarizeModelUsage(calls), (summary) => ({
+      modelCalls: summary.modelCalls,
+      inputTokens: summary.inputTokens.total,
+      outputTokens: summary.outputTokens.total,
+      costMicrousd: summary.costMicrousd,
+    }));
+  });

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

@@ -3207,70 +3207,66 @@ export const makeWorkerRuntime = Effect.fnUntraced(function* (options: WorkerRun
             .get({ ownerThreadId: context.source.threadId, messageId })
             .pipe(Effect.mapError(storageFailure("start")));
 
-        const replay = (saved: MessageDeliveryRecord) =>
-          Effect.gen(function* () {
-            const currentPrevious =
-              command.continuationOf === undefined
-                ? undefined
-                : yield* completedContinuation(
-                    context.source,
-                    command.continuationOf,
-                    command.target.id,
-                    command.delegationId,
-                    previous?.evidence,
-                  );
-
-            const replayPrincipal = yield* authorize(
-              "start",
-              "send",
-              undefined,
-              currentPrevious?.evidence,
-            );
+        const replay = Effect.fnUntraced(function* (saved: MessageDeliveryRecord) {
+          const currentPrevious =
+            command.continuationOf === undefined
+              ? undefined
+              : yield* completedContinuation(
+                  context.source,
+                  command.continuationOf,
+                  command.target.id,
+                  command.delegationId,
+                  previous?.evidence,
+                );
 
-            yield* binding(command.target, "start");
-            const metadata = saved.envelope.workerAdmission;
+          const replayPrincipal = yield* authorize(
+            "start",
+            "send",
+            undefined,
+            currentPrevious?.evidence,
+          );
 
-            if (metadata === undefined) return yield* failure("start", "idempotency-conflict");
-            const origin = metadata.origin;
+          yield* binding(command.target, "start");
+          const metadata = saved.envelope.workerAdmission;
 
-            if (
-              !Schema.toEquivalence(Schema.UndefinedOr(WorkerContinuation))(
-                origin.continuationOf,
-                currentPrevious?.evidence,
-              ) ||
-              origin.firstMessageId !== messageId ||
-              metadata.messageId !== messageId ||
-              origin.source.threadId !== context.source.threadId ||
-              origin.worker.delegationId !== command.delegationId ||
-              origin.worker.targetAgentId !== command.target.id ||
-              !sameJson(metadata.parameters, parameters) ||
-              !Schema.toEquivalence(SubagentGrant)(origin.grant, grant) ||
-              origin.budgetScope !== effectiveScope ||
-              origin.depth !== context.depth + 1 ||
-              (!("prepare" in command) &&
-                (!samePolicy(origin.policy, command.policy) ||
-                  !Schema.toEquivalence(WorkerOrigin.fields.budget)(
-                    origin.budget,
-                    command.budget,
-                  ) ||
-                  origin.toolCallAllowance !== command.toolCallAllowance))
-            )
-              return yield* failure("start", "idempotency-conflict");
-
-            yield* verifyContinuation(origin);
-
-            return {
-              worker: origin.worker,
-              delivery: yield* send(
-                origin,
-                messageId,
-                "prepare" in command ? saved.envelope.input : command.encodedInput,
-                parameters,
-                replayPrincipal,
-                "start",
-              ),
-            };
-          });
+          if (metadata === undefined) return yield* failure("start", "idempotency-conflict");
+          const origin = metadata.origin;
+
+          if (
+            !Schema.toEquivalence(Schema.UndefinedOr(WorkerContinuation))(
+              origin.continuationOf,
+              currentPrevious?.evidence,
+            ) ||
+            origin.firstMessageId !== messageId ||
+            metadata.messageId !== messageId ||
+            origin.source.threadId !== context.source.threadId ||
+            origin.worker.delegationId !== command.delegationId ||
+            origin.worker.targetAgentId !== command.target.id ||
+            !sameJson(metadata.parameters, parameters) ||
+            !Schema.toEquivalence(SubagentGrant)(origin.grant, grant) ||
+            origin.budgetScope !== effectiveScope ||
+            origin.depth !== context.depth + 1 ||
+            (!("prepare" in command) &&
+              (!samePolicy(origin.policy, command.policy) ||
+                !Schema.toEquivalence(WorkerOrigin.fields.budget)(origin.budget, command.budget) ||
+                origin.toolCallAllowance !== command.toolCallAllowance))
+          )
+            return yield* failure("start", "idempotency-conflict");
+
+          yield* verifyContinuation(origin);
+
+          return {
+            worker: origin.worker,
+            delivery: yield* send(
+              origin,
+              messageId,
+              "prepare" in command ? saved.envelope.input : command.encodedInput,
+              parameters,
+              replayPrincipal,
+              "start",
+            ),
+          };
+        });
 
         const existing = yield* retained();
 
@@ -3461,21 +3457,20 @@ export const makeWorkerRuntime = Effect.fnUntraced(function* (options: WorkerRun
             .get({ ownerThreadId: context.source.threadId, messageId })
             .pipe(Effect.mapError(storageFailure("followUp")));
 
-        const replay = (saved: MessageDeliveryRecord) =>
-          Effect.gen(function* () {
-            const replayPrincipal = yield* authorize("followUp", "send", command.worker);
+        const replay = Effect.fnUntraced(function* (saved: MessageDeliveryRecord) {
+          const replayPrincipal = yield* authorize("followUp", "send", command.worker);
 
-            yield* currentPolicy;
+          yield* currentPolicy;
 
-            return yield* send(
-              origin,
-              messageId,
-              saved.envelope.input,
-              command.encodedParameters,
-              replayPrincipal,
-              "followUp",
-            );
-          });
+          return yield* send(
+            origin,
+            messageId,
+            saved.envelope.input,
+            command.encodedParameters,
+            replayPrincipal,
+            "followUp",
+          );
+        });
 
         const existing = "prepare" in command ? yield* retained() : null;
 

package/src/engine/MessagingHost.ts

@@ -1,4 +1,4 @@
-import type { Effect } from "effect";
+import { Effect } from "effect";
 import * as Context from "effect/Context";
 
 import type { AnyDefinition } from "../core/Agent.ts";
@@ -47,7 +47,9 @@ export class MessagingHost extends Context.Service<
   }
 >()("@effect-agent/engine/MessagingHost") {
   static readonly unavailable: MessagingHost["Service"] = {
-    context: MessagingError.make({ operation: "context", reason: "unavailable" }),
+    context: Effect.suspend(() =>
+      MessagingError.make({ operation: "context", reason: "unavailable" }),
+    ),
     send: () => MessagingError.make({ operation: "send", reason: "unavailable" }),
     reply: () => MessagingError.make({ operation: "reply", reason: "unavailable" }),
     inbox: () => MessagingError.make({ operation: "inbox", reason: "unavailable" }),

package/src/engine/ThreadHistory.ts

@@ -75,57 +75,56 @@ export class ThreadHistory extends Context.Service<
   }
 >()("@effect-agent/engine/ThreadHistory") {
   /** Bind incremental history to the supplied Thread.Store, including scoped ownership views. */
-  static readonly layerFromStore = Layer.effect(
-    ThreadHistory,
-    Effect.gen(function* () {
-      const threads = yield* ConversationStore;
+  static readonly makeFromStore = Effect.gen(function* () {
+    const threads = yield* ConversationStore;
 
-      const historyError = (cause: ThreadError): ThreadHistoryError =>
-        ThreadHistoryError.make({
-          threadId: cause.threadId,
-          reason:
-            cause._tag === "ThreadNotFound"
-              ? "not-found"
-              : cause._tag === "ThreadLimitExceeded"
-                ? "limit"
-                : cause._tag === "ThreadHistoryDiverged"
-                  ? "conflict"
-                  : cause._tag === "ThreadOwnershipError"
-                    ? cause.reason === "closed"
-                      ? "fenced"
-                      : "conflict"
-                    : "encoding",
-          message:
-            cause._tag === "ThreadNotFound"
-              ? "Thread history is not present in this application Scope"
-              : cause._tag === "ThreadLimitExceeded"
-                ? `In-memory history exceeds the ${cause.limit} limit of ${cause.limitValue}`
-                : cause.message,
-          cause,
-        });
+    const historyError = (cause: ThreadError): ThreadHistoryError =>
+      ThreadHistoryError.make({
+        threadId: cause.threadId,
+        reason:
+          cause._tag === "ThreadNotFound"
+            ? "not-found"
+            : cause._tag === "ThreadLimitExceeded"
+              ? "limit"
+              : cause._tag === "ThreadHistoryDiverged"
+                ? "conflict"
+                : cause._tag === "ThreadOwnershipError"
+                  ? cause.reason === "closed"
+                    ? "fenced"
+                    : "conflict"
+                  : "encoding",
+        message:
+          cause._tag === "ThreadNotFound"
+            ? "Thread history is not present in this application Scope"
+            : cause._tag === "ThreadLimitExceeded"
+              ? `In-memory history exceeds the ${cause.limit} limit of ${cause.limitValue}`
+              : cause.message,
+        cause,
+      });
 
-      return ThreadHistory.of({
-        retention: "incremental",
-        memoryStore: threads,
-        load: (threadId) =>
-          threads.snapshot(threadId).pipe(Effect.map(toPrompt), Effect.mapError(historyError)),
-        open: Effect.fnUntraced(function* ({ threadId, runId }) {
-          const snapshot = yield* threads.create(threadId).pipe(Effect.mapError(historyError));
+    return ThreadHistory.of({
+      retention: "incremental",
+      memoryStore: threads,
+      load: (threadId) =>
+        threads.snapshot(threadId).pipe(Effect.map(toPrompt), Effect.mapError(historyError)),
+      open: Effect.fnUntraced(function* ({ threadId, runId }) {
+        const snapshot = yield* threads.create(threadId).pipe(Effect.mapError(historyError));
 
-          return {
-            prompt: toPrompt(snapshot),
-            stageInput: () => Effect.void,
-            stageHistory: ({ source }) =>
-              threads
-                .recordHistory(threadId, runId, source)
-                .pipe(Effect.asVoid, Effect.mapError(historyError)),
-            commit: () =>
-              threads.snapshot(threadId).pipe(Effect.asVoid, Effect.mapError(historyError)),
-          };
-        }),
-      });
-    }),
-  );
+        return {
+          prompt: toPrompt(snapshot),
+          stageInput: () => Effect.void,
+          stageHistory: ({ source }) =>
+            threads
+              .recordHistory(threadId, runId, source)
+              .pipe(Effect.asVoid, Effect.mapError(historyError)),
+          commit: () =>
+            threads.snapshot(threadId).pipe(Effect.asVoid, Effect.mapError(historyError)),
+        };
+      }),
+    });
+  });
+
+  static readonly layerFromStore = Layer.effect(ThreadHistory, ThreadHistory.makeFromStore);
 
   /** Retain history for the application Scope, within message and host capacity. Separate Layer builds own separate stores. */
   static readonly layer = ThreadHistory.layerFromStore.pipe(Layer.provideMerge(layerMemory));