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

package/src/core/Agent.ts

@@ -570,9 +570,11 @@ export function make(
 
   for (const declaration of options.completionFromTools ?? []) {
     if (declaration.tool === options.completion?.tool || completionNames.has(declaration.tool)) {
+      // oxlint-disable-next-line effect/no-untyped-throw, effect/no-native-error -- Agent.make synchronously rejects duplicate completion declarations before constructing the Definition.
       throw new Error(`Tool ${declaration.tool} has more than one completion declaration`);
     }
     if (!Object.hasOwn(options.toolkit.tools, declaration.tool)) {
+      // oxlint-disable-next-line effect/no-untyped-throw, effect/no-native-error -- Agent.make synchronously rejects completion declarations for absent Tools.
       throw new Error(`Unknown completion Tool ${declaration.tool}`);
     }
     completionNames.add(declaration.tool);
@@ -622,11 +624,14 @@ export function make(
 }
 
 /** Bind a native model or thread resolver without acquiring or hiding its requirements. */
-export const withModel = <DefinitionValue extends AnyDefinition, ModelValue>(
+export function withModel<DefinitionValue extends AnyDefinition, ModelValue>(
   definition: DefinitionValue,
   model: NativeModel<ModelValue>,
-): Binding<DefinitionValue, ModelValue> =>
-  Object.freeze({
-    definition,
-    model,
-  });
+): Binding<DefinitionValue, ModelValue>;
+
+export function withModel<DefinitionValue extends AnyDefinition, ModelValue>(
+  definition: DefinitionValue,
+  model: ModelValue,
+) {
+  return Object.freeze({ definition, model });
+}

package/src/core/AgentUpdates.ts

@@ -59,20 +59,20 @@ export const emit = Effect.fnUntraced(function* <S extends Schema.Top>(
 ): Effect.fn.Return<Update, UpdateError, Emitter | S["EncodingServices"]> {
   const target = "definition" in agent ? agent.definition : agent;
 
-  if (target.updates === undefined) return yield* new UpdateError({ reason: "unavailable" });
+  if (target.updates === undefined) return yield* UpdateError.make({ reason: "unavailable" });
 
   const updateId = yield* Schema.decodeEffect(IdempotencyKey)(options.idempotencyKey).pipe(
-    Effect.mapError(() => new UpdateError({ reason: "validation" })),
+    Effect.mapError(() => UpdateError.make({ reason: "validation" })),
   );
 
   const encoded = yield* Schema.encodeEffect(target.updates)(value).pipe(
     Effect.flatMap(Schema.decodeUnknownEffect(Schema.Json)),
-    Effect.mapError(() => new UpdateError({ reason: "validation" })),
+    Effect.mapError(() => UpdateError.make({ reason: "validation" })),
   );
 
   const emitter = yield* Effect.serviceOption(Emitter);
 
-  if (Option.isNone(emitter)) return yield* new UpdateError({ reason: "unavailable" });
+  if (Option.isNone(emitter)) return yield* UpdateError.make({ reason: "unavailable" });
 
   return yield* emitter.value.emit({ target, updateId, value: encoded });
 });
@@ -84,16 +84,16 @@ export const decode = Effect.fnUntraced(function* <S extends Schema.Top>(
 ): Effect.fn.Return<S["Type"], UpdateError, S["DecodingServices"]> {
   const definition = "definition" in agent ? agent.definition : agent;
 
-  if (definition.updates === undefined) return yield* new UpdateError({ reason: "unavailable" });
+  if (definition.updates === undefined) return yield* UpdateError.make({ reason: "unavailable" });
 
   const decoded = yield* Schema.decodeEffect(Update)(update).pipe(
-    Effect.mapError(() => new UpdateError({ reason: "validation" })),
+    Effect.mapError(() => UpdateError.make({ reason: "validation" })),
   );
 
-  if (decoded.agentId !== definition.id) return yield* new UpdateError({ reason: "identity" });
+  if (decoded.agentId !== definition.id) return yield* UpdateError.make({ reason: "identity" });
 
   return yield* Schema.decodeEffect(definition.updates)(decoded.value).pipe(
-    Effect.mapError(() => new UpdateError({ reason: "validation" })),
+    Effect.mapError(() => UpdateError.make({ reason: "validation" })),
   );
 });
 

package/src/core/Thread.ts

@@ -287,164 +287,160 @@ const appendEncoded = Effect.fnUntraced(function* (
 });
 
 /** In-memory storage shared for the consumer's Scope; it does not survive process loss. */
-export const layerMemory = Layer.effect(
-  Store,
-  Effect.gen(function* () {
-    const state = yield* SynchronizedRef.make<State>({ threads: new Map(), contentBytes: 0 });
-    const root: Owner = { closed: false };
-
-    const release = (owner: Owner) =>
-      SynchronizedRef.update(state, (current) => {
-        owner.closed = true;
-        const threads = new Map(current.threads);
-        let contentBytes = current.contentBytes;
-
-        for (const [id, entry] of threads) {
-          if (belongsTo(entry.owner, owner)) {
-            threads.delete(id);
-            contentBytes -= entry.snapshot.contentBytes;
-          }
+export const makeMemoryStore = Effect.gen(function* () {
+  const state = yield* SynchronizedRef.make<State>({ threads: new Map(), contentBytes: 0 });
+  const root: Owner = { closed: false };
+
+  const release = (owner: Owner) =>
+    SynchronizedRef.update(state, (current) => {
+      owner.closed = true;
+      const threads = new Map(current.threads);
+      let contentBytes = current.contentBytes;
+
+      for (const [id, entry] of threads) {
+        if (belongsTo(entry.owner, owner)) {
+          threads.delete(id);
+          contentBytes -= entry.snapshot.contentBytes;
         }
+      }
 
-        return { threads, contentBytes };
-      });
+      return { threads, contentBytes };
+    });
 
-    yield* Effect.addFinalizer(() => release(root));
-
-    const view = (owner: Owner): StoreService => ({
-      scoped: Effect.acquireRelease(
-        Effect.sync((): Owner => ({ closed: false, parent: owner })),
-        release,
-      ).pipe(Effect.map(view)),
-      create: (threadId) =>
-        SynchronizedRef.modifyEffect(
-          state,
-          Effect.fnUntraced(function* (threads) {
-            const existing = yield* access(threads, owner, threadId);
-
-            if (existing !== undefined) return [existing, threads] as const;
-            if (threads.threads.size >= MAX_THREADS) {
-              return yield* ThreadLimitExceeded.make({
-                threadId,
-                limit: "threads",
-                limitValue: MAX_THREADS,
-                observedValue: threads.threads.size + 1,
-              });
-            }
+  yield* Effect.addFinalizer(() => release(root));
+
+  const view = (owner: Owner): StoreService => ({
+    scoped: Effect.acquireRelease(
+      Effect.sync((): Owner => ({ closed: false, parent: owner })),
+      release,
+    ).pipe(Effect.map(view)),
+    create: (threadId) =>
+      SynchronizedRef.modifyEffect(
+        state,
+        Effect.fnUntraced(function* (threads) {
+          const existing = yield* access(threads, owner, threadId);
+
+          if (existing !== undefined) return [existing, threads] as const;
+          if (threads.threads.size >= MAX_THREADS) {
+            return yield* ThreadLimitExceeded.make({
+              threadId,
+              limit: "threads",
+              limitValue: MAX_THREADS,
+              observedValue: threads.threads.size + 1,
+            });
+          }
 
-            const created = Thread.make({
-              version: 1,
+          const created = Thread.make({
+            version: 1,
+            threadId,
+            nextSequence: 0,
+            contentBytes: 0,
+            messages: [],
+          });
+
+          return [created, put(threads, owner, created)] as const;
+        }),
+      ),
+    append: Effect.fnUntraced(function* (threadId, message) {
+      const encoded = yield* encodeMessage(threadId, message.message);
+      const timestamp = DateTime.toUtc(DateTime.makeUnsafe(yield* Clock.currentTimeMillis));
+
+      return yield* SynchronizedRef.modifyEffect(
+        state,
+        Effect.fnUntraced(function* (threads) {
+          const current = yield* findSnapshot(threads, owner, threadId);
+
+          return yield* appendEncoded(threads, owner, current, message, encoded, timestamp);
+        }),
+      );
+    }),
+    recordHistory: Effect.fnUntraced(function* (threadId, historyRunId, history) {
+      const incoming = yield* Effect.forEach(history.content, (message) =>
+        encodeMessage(threadId, message).pipe(Effect.map((encoded) => ({ message, encoded }))),
+      );
+
+      // Publish the complete suffix only after verification and every bounded append succeed.
+      return yield* SynchronizedRef.modifyEffect(
+        state,
+        Effect.fnUntraced(function* (threads) {
+          const current = yield* findSnapshot(threads, owner, threadId);
+
+          const currentEncoded = yield* Effect.forEach(current.messages, (entry) =>
+            encodeMessage(threadId, entry.message),
+          );
+
+          if (
+            incoming.length < currentEncoded.length ||
+            currentEncoded.some((encoded, index) => encoded !== incoming[index]?.encoded)
+          ) {
+            return yield* ThreadHistoryDiverged.make({
               threadId,
-              nextSequence: 0,
-              contentBytes: 0,
-              messages: [],
+              message: "Engine history is not an append-only extension of official history",
             });
+          }
+          const timestamp = DateTime.toUtc(DateTime.makeUnsafe(yield* Clock.currentTimeMillis));
 
-            return [created, put(threads, owner, created)] as const;
-          }),
-        ),
-      append: Effect.fnUntraced(function* (threadId, message) {
-        const encoded = yield* encodeMessage(threadId, message.message);
-        const timestamp = DateTime.toUtc(DateTime.makeUnsafe(yield* Clock.currentTimeMillis));
-
-        return yield* SynchronizedRef.modifyEffect(
-          state,
-          Effect.fnUntraced(function* (threads) {
-            const current = yield* findSnapshot(threads, owner, threadId);
-
-            return yield* appendEncoded(threads, owner, current, message, encoded, timestamp);
-          }),
-        );
-      }),
-      recordHistory: Effect.fnUntraced(function* (threadId, historyRunId, history) {
-        const incoming = yield* Effect.forEach(history.content, (message) =>
-          encodeMessage(threadId, message).pipe(Effect.map((encoded) => ({ message, encoded }))),
-        );
-
-        // Publish the complete suffix only after verification and every bounded append succeed.
-        return yield* SynchronizedRef.modifyEffect(
-          state,
-          Effect.fnUntraced(function* (threads) {
-            const current = yield* findSnapshot(threads, owner, threadId);
-
-            const currentEncoded = yield* Effect.forEach(current.messages, (entry) =>
-              encodeMessage(threadId, entry.message),
-            );
+          if (incoming.length === currentEncoded.length) return [current, threads] as const;
+
+          const messages = [...current.messages];
+          let contentBytes = current.contentBytes;
+          let storeBytes = threads.contentBytes;
+          let nextSequence = current.nextSequence;
+
+          for (const entry of incoming.slice(currentEncoded.length)) {
+            const append = ThreadAppend.make({ runId: historyRunId, message: entry.message });
 
-            if (
-              incoming.length < currentEncoded.length ||
-              currentEncoded.some((encoded, index) => encoded !== incoming[index]?.encoded)
-            ) {
-              return yield* ThreadHistoryDiverged.make({
+            const messageBytes = yield* messageSize(threadId, entry.encoded);
+
+            contentBytes += messageBytes;
+            storeBytes += messageBytes;
+            if (storeBytes > MAX_STORE_CONTENT_BYTES) {
+              return yield* ThreadLimitExceeded.make({
                 threadId,
-                message: "Engine history is not an append-only extension of official history",
+                limit: "store-content-bytes",
+                limitValue: MAX_STORE_CONTENT_BYTES,
+                observedValue: storeBytes,
               });
             }
-            const timestamp = DateTime.toUtc(DateTime.makeUnsafe(yield* Clock.currentTimeMillis));
-
-            if (incoming.length === currentEncoded.length) return [current, threads] as const;
-
-            const messages = [...current.messages];
-            let contentBytes = current.contentBytes;
-            let storeBytes = threads.contentBytes;
-            let nextSequence = current.nextSequence;
-
-            for (const entry of incoming.slice(currentEncoded.length)) {
-              const append = ThreadAppend.make({ runId: historyRunId, message: entry.message });
-
-              const messageBytes = yield* messageSize(threadId, entry.encoded);
-
-              contentBytes += messageBytes;
-              storeBytes += messageBytes;
-              if (storeBytes > MAX_STORE_CONTENT_BYTES) {
-                return yield* ThreadLimitExceeded.make({
-                  threadId,
-                  limit: "store-content-bytes",
-                  limitValue: MAX_STORE_CONTENT_BYTES,
-                  observedValue: storeBytes,
-                });
-              }
-              messages.push(
-                ThreadMessage.make({
-                  threadId,
-                  sequence: nextSequence,
-                  ...(append.runId === undefined ? {} : { runId: append.runId }),
-                  message: append.message,
-                  encodedBytes: messageBytes,
-                  timestamp,
-                }),
-              );
-              nextSequence += 1;
-            }
-
-            const snapshot = Thread.make({
-              version: current.version,
-              threadId,
-              nextSequence,
-              contentBytes,
-              messages,
-            });
+            messages.push(
+              ThreadMessage.make({
+                threadId,
+                sequence: nextSequence,
+                ...(append.runId === undefined ? {} : { runId: append.runId }),
+                message: append.message,
+                encodedBytes: messageBytes,
+                timestamp,
+              }),
+            );
+            nextSequence += 1;
+          }
 
-            return [snapshot, put(threads, owner, snapshot)] as const;
-          }),
-        );
-      }),
-      snapshot: (threadId) =>
-        SynchronizedRef.get(state).pipe(
-          Effect.flatMap((all) => findSnapshot(all, owner, threadId)),
-        ),
-      export: (threadId) =>
-        Effect.gen(function* () {
-          const snapshot = yield* findSnapshot(yield* SynchronizedRef.get(state), owner, threadId);
-
-          return ThreadExport.make({
-            format: "effect-agent/ephemeral-thread@1",
-            exportedAt: DateTime.toUtc(DateTime.makeUnsafe(yield* Clock.currentTimeMillis)),
-            snapshot,
+          const snapshot = Thread.make({
+            version: current.version,
+            threadId,
+            nextSequence,
+            contentBytes,
+            messages,
           });
+
+          return [snapshot, put(threads, owner, snapshot)] as const;
         }),
-    });
+      );
+    }),
+    snapshot: (threadId) =>
+      SynchronizedRef.get(state).pipe(Effect.flatMap((all) => findSnapshot(all, owner, threadId))),
+    export: Effect.fnUntraced(function* (threadId) {
+      const snapshot = yield* findSnapshot(yield* SynchronizedRef.get(state), owner, threadId);
+
+      return ThreadExport.make({
+        format: "effect-agent/ephemeral-thread@1",
+        exportedAt: DateTime.toUtc(DateTime.makeUnsafe(yield* Clock.currentTimeMillis)),
+        snapshot,
+      });
+    }),
+  });
+
+  return view(root);
+});
 
-    return view(root);
-  }),
-);
+export const layerMemory = Layer.effect(Store, makeMemoryStore);

package/src/core/Usage.ts

@@ -293,8 +293,8 @@ export const sumRunTotals = Effect.fnUntraced(function* (
 
   for (const contribution of contributions) {
     const value = yield* Schema.decodeEffect(RunTotals)(contribution).pipe(
-      Effect.mapError(
-        () => new UsageAggregationError({ field: "totals", message: "Invalid Run totals" }),
+      Effect.mapError(() =>
+        UsageAggregationError.make({ field: "totals", message: "Invalid Run totals" }),
       ),
     );
 
@@ -376,12 +376,11 @@ export const summarizeModelUsage = Effect.fnUntraced(function* (
     seed === undefined
       ? undefined
       : yield* Schema.decodeEffect(RunUsageSummary)(seed).pipe(
-          Effect.mapError(
-            () =>
-              new UsageAggregationError({
-                field: "seed",
-                message: "Canonical usage seed does not satisfy the RunUsageSummary Schema",
-              }),
+          Effect.mapError(() =>
+            UsageAggregationError.make({
+              field: "seed",
+              message: "Canonical usage seed does not satisfy the RunUsageSummary Schema",
+            }),
           ),
         );
 

package/src/core/internal/agent-updates.ts

@@ -29,6 +29,7 @@ export const withUpdateTool = (
 ): Toolkit.Any => {
   if (schema === undefined) return toolkit;
   if (Object.hasOwn(toolkit.tools, "emit_update"))
+    // oxlint-disable-next-line effect/no-untyped-throw, effect/no-native-error -- Agent.make synchronously rejects a toolkit that occupies the reserved update Tool name.
     throw new TypeError("emit_update is reserved for Agent updates");
 
   return Toolkit.make(...Object.values(toolkit.tools), updateTool(schema));