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

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

@@ -433,16 +433,15 @@ export const layerMemory = Layer.effect(
         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,
-          });
-        }),
+      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);

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));