effect-agent 0.1.0-beta.164 → 0.1.0-beta.165

package/src/core/FailureDiagnostic.ts

@@ -1,11 +1,9 @@
-import {
-  Cause as EffectCause,
-  Exit,
-  Predicate,
-  Redacted,
-  Schema,
-  SchemaTransformation,
-} from "effect";
+import * as EffectCause from "effect/Cause";
+import * as Exit from "effect/Exit";
+import * as Predicate from "effect/Predicate";
+import * as Redacted from "effect/Redacted";
+import * as Schema from "effect/Schema";
+import * as SchemaTransformation from "effect/SchemaTransformation";
 
 import { strictSchema } from "./internal/strict-schema.ts";
 

package/src/core/IdGenerator.ts

@@ -1,5 +1,8 @@
-import { Context, Effect, Layer, Schema } from "effect";
-import { IdGenerator as EffectAiIdGenerator } from "effect/unstable/ai";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import * as EffectAiIdGenerator from "effect/unstable/ai/IdGenerator";
 
 import { ThreadId, RunId, TurnId } from "./Identifiers.ts";
 

package/src/core/Messaging.ts

@@ -1,4 +1,4 @@
-import { Schema } from "effect";
+import * as Schema from "effect/Schema";
 
 import { AgentId, ThreadId } from "./Identifiers.ts";
 import { MessageRef } from "./internal/message-status.ts";

package/src/core/Receipt.ts

@@ -1,4 +1,4 @@
-import { Schema } from "effect";
+import * as Schema from "effect/Schema";
 
 import { ReceiptId, SubmissionId, ThreadId } from "./Identifiers.ts";
 

package/src/core/RunEvent.ts

@@ -1,4 +1,4 @@
-import { Schema } from "effect";
+import * as Schema from "effect/Schema";
 
 import { Update } from "./AgentUpdates.ts";
 import { AgentId, ThreadId, DelegationId, RunId, ToolCallId, TurnId } from "./Identifiers.ts";

package/src/core/RunPolicyUsage.ts

@@ -1,4 +1,4 @@
-import { Schema } from "effect";
+import * as Schema from "effect/Schema";
 
 /**
  * Cumulative policy accounting for one logical Run across replacement Attempts.

package/src/core/SubagentContract.ts

@@ -1,4 +1,5 @@
-import { Context, Schema } from "effect";
+import * as Context from "effect/Context";
+import * as Schema from "effect/Schema";
 
 import { AgentId, ThreadId, DelegationId, RunId, ToolCallId, SubmissionId } from "./Identifiers.ts";
 

package/src/core/Thread.ts

@@ -1,5 +1,12 @@
-import { Clock, Context, DateTime, Effect, Layer, Schema, SynchronizedRef } from "effect";
-import { Prompt } from "effect/unstable/ai";
+import type { Scope } from "effect";
+import * as Clock from "effect/Clock";
+import * as Context from "effect/Context";
+import * as DateTime from "effect/DateTime";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import * as SynchronizedRef from "effect/SynchronizedRef";
+import * as Prompt from "effect/unstable/ai/Prompt";
 
 import { ThreadId, RunId } from "./Identifiers.ts";
 import { utf8ByteLength } from "./internal/utf8.ts";
@@ -77,11 +84,18 @@ export class ThreadEncodingError extends Schema.TaggedError<ThreadEncodingError>
   { threadId: ThreadId, message: Schema.String },
 ) {}
 
+/** A scoped view cannot access another owner's history or be used after closure. */
+export class ThreadOwnershipError extends Schema.TaggedError<ThreadOwnershipError>()(
+  "ThreadOwnershipError",
+  { threadId: ThreadId, reason: Schema.Literals(["closed", "foreign"]), message: Schema.String },
+) {}
+
 export type ThreadError =
   | ThreadNotFound
   | ThreadLimitExceeded
   | ThreadHistoryDiverged
-  | ThreadEncodingError;
+  | ThreadEncodingError
+  | ThreadOwnershipError;
 
 /** Reconstruct exact Effect AI Prompt history, including tools, reasoning, files, and options. */
 export const toPrompt = (snapshot: Thread): Prompt.Prompt =>
@@ -93,32 +107,51 @@ export const toPrompt = (snapshot: Thread): Prompt.Prompt =>
  * ThreadHistory.layer uses this store for ordinary Runs and interactive history.
  * Scope closure releases all in-memory state.
  */
-export class Store extends Context.Service<
-  Store,
-  {
-    readonly create: (threadId: ThreadId) => Effect.Effect<Thread, ThreadLimitExceeded>;
-    readonly append: (
-      threadId: ThreadId,
-      message: ThreadAppend,
-    ) => Effect.Effect<Thread, ThreadNotFound | ThreadLimitExceeded | ThreadEncodingError>;
-    /**
-     * Record an engine-emitted full history only when it is an append-only
-     * extension of the exact official Prompt already stored. The entire
-     * suffix commits in one transaction or not at all: concurrent writers are
-     * serialized, a writer whose history no longer extends the committed
-     * official history fails with ThreadHistoryDiverged, and a limit
-     * failure inside the suffix records nothing. Earlier updates remain committed if the Run
-     * later fails or is interrupted; this transaction covers one update, not the whole Run.
-     */
-    readonly recordHistory: (
-      threadId: ThreadId,
-      runId: RunId,
-      history: Prompt.Prompt,
-    ) => Effect.Effect<Thread, ThreadError>;
-    readonly snapshot: (threadId: ThreadId) => Effect.Effect<Thread, ThreadNotFound>;
-    readonly export: (threadId: ThreadId) => Effect.Effect<ThreadExport, ThreadNotFound>;
-  }
->()("@effect-agent/capabilities/EphemeralThreads") {}
+interface StoreService {
+  /**
+   * Acquire an isolated ownership view over this same bounded store. Newly created Threads
+   * belong to the supplied Scope; closing it releases only that view's Threads and bytes.
+   * Supplied by layerMemory; custom stores may omit this capability.
+   * The view rejects foreign IDs and all access after closure. Keep its Scope open through
+   * all users, including streams, child Runs, snapshots and history hooks.
+   */
+  readonly scoped?: Effect.Effect<StoreService, never, Scope.Scope>;
+  readonly create: (
+    threadId: ThreadId,
+  ) => Effect.Effect<Thread, ThreadLimitExceeded | ThreadOwnershipError>;
+  readonly append: (
+    threadId: ThreadId,
+    message: ThreadAppend,
+  ) => Effect.Effect<
+    Thread,
+    ThreadNotFound | ThreadLimitExceeded | ThreadEncodingError | ThreadOwnershipError
+  >;
+  /**
+   * Record an engine-emitted full history only when it is an append-only
+   * extension of the exact official Prompt already stored. The entire
+   * suffix commits in one transaction or not at all: concurrent writers are
+   * serialized, a writer whose history no longer extends the committed
+   * official history fails with ThreadHistoryDiverged, and a limit
+   * failure inside the suffix records nothing. Earlier updates remain committed if the Run
+   * later fails or is interrupted; this transaction covers one update, not the whole Run.
+   */
+  readonly recordHistory: (
+    threadId: ThreadId,
+    runId: RunId,
+    history: Prompt.Prompt,
+  ) => Effect.Effect<Thread, ThreadError>;
+  readonly snapshot: (
+    threadId: ThreadId,
+  ) => Effect.Effect<Thread, ThreadNotFound | ThreadOwnershipError>;
+  readonly export: (
+    threadId: ThreadId,
+  ) => Effect.Effect<ThreadExport, ThreadNotFound | ThreadOwnershipError>;
+}
+
+/** Process-local conversation store supplied by layerMemory. */
+export class Store extends Context.Service<Store, StoreService>()(
+  "@effect-agent/capabilities/EphemeralThreads",
+) {}
 
 const encodeMessage = (
   threadId: ThreadId,
@@ -134,27 +167,71 @@ const encodeMessage = (
     ),
   );
 
-const findSnapshot = (
-  state: ReadonlyMap<ThreadId, Thread>,
-  threadId: ThreadId,
-): Effect.Effect<Thread, ThreadNotFound> => {
-  const snapshot = state.get(threadId);
+interface Owner {
+  closed: boolean;
+  readonly parent?: Owner;
+}
 
-  return snapshot === undefined
-    ? Effect.fail(ThreadNotFound.make({ threadId }))
-    : Effect.succeed(snapshot);
-};
+interface Entry {
+  readonly snapshot: Thread;
+  readonly owner: Owner;
+}
 
-const totalStoreBytes = (threads: ReadonlyMap<ThreadId, Thread>): number => {
-  let total = 0;
+interface State {
+  readonly threads: ReadonlyMap<ThreadId, Entry>;
+  readonly contentBytes: number;
+}
 
-  for (const snapshot of threads.values()) total += snapshot.contentBytes;
+const belongsTo = (owner: Owner, ancestor: Owner): boolean => {
+  for (let current: Owner | undefined = owner; current !== undefined; current = current.parent) {
+    if (current === ancestor) return true;
+  }
 
-  return total;
+  return false;
 };
 
+const access = (state: State, owner: Owner, threadId: ThreadId) => {
+  for (let current: Owner | undefined = owner; current !== undefined; current = current.parent) {
+    if (current.closed) {
+      return Effect.fail(
+        ThreadOwnershipError.make({
+          threadId,
+          reason: "closed",
+          message: "The in-memory conversation owner is closed",
+        }),
+      );
+    }
+  }
+  const entry = state.threads.get(threadId);
+
+  return entry !== undefined && entry.owner !== owner
+    ? Effect.fail(
+        ThreadOwnershipError.make({
+          threadId,
+          reason: "foreign",
+          message: "The Thread belongs to another in-memory conversation owner",
+        }),
+      )
+    : Effect.succeed(entry?.snapshot);
+};
+
+const findSnapshot = Effect.fnUntraced(function* (state: State, owner: Owner, threadId: ThreadId) {
+  const snapshot = yield* access(state, owner, threadId);
+
+  return snapshot === undefined ? yield* ThreadNotFound.make({ threadId }) : snapshot;
+});
+
+const put = (state: State, owner: Owner, snapshot: Thread): State => ({
+  threads: new Map(state.threads).set(snapshot.threadId, { snapshot, owner }),
+  contentBytes:
+    state.contentBytes +
+    snapshot.contentBytes -
+    (state.threads.get(snapshot.threadId)?.snapshot.contentBytes ?? 0),
+});
+
 const appendEncoded = Effect.fn("Thread.Store.appendEncoded")(function* (
-  threads: ReadonlyMap<ThreadId, Thread>,
+  state: State,
+  owner: Owner,
   current: Thread,
   append: ThreadAppend,
   encoded: string,
@@ -181,7 +258,7 @@ const appendEncoded = Effect.fn("Thread.Store.appendEncoded")(function* (
       observedValue: contentBytes,
     });
   }
-  const storeBytes = totalStoreBytes(threads) + messageBytes;
+  const storeBytes = state.contentBytes + messageBytes;
 
   if (storeBytes > MAX_STORE_CONTENT_BYTES) {
     return yield* ThreadLimitExceeded.make({
@@ -209,31 +286,52 @@ const appendEncoded = Effect.fn("Thread.Store.appendEncoded")(function* (
     messages: [...current.messages, message],
   });
 
-  return [next, new Map(threads).set(threadId, next)] as const;
+  return [next, put(state, owner, next)] as const;
 });
 
 /** 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<ReadonlyMap<ThreadId, Thread>>(new Map());
-
-    yield* Effect.addFinalizer(() => SynchronizedRef.set(state, new Map()));
-
-    return Store.of({
+    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 };
+      });
+
+    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.fn(function* (threads) {
-            const existing = threads.get(threadId);
+            const existing = yield* access(threads, owner, threadId);
 
             if (existing !== undefined) return [existing, threads] as const;
-            if (threads.size >= MAX_THREADS) {
+            if (threads.threads.size >= MAX_THREADS) {
               return yield* ThreadLimitExceeded.make({
                 threadId,
                 limit: "threads",
                 limitValue: MAX_THREADS,
-                observedValue: threads.size + 1,
+                observedValue: threads.threads.size + 1,
               });
             }
 
@@ -245,7 +343,7 @@ export const layerMemory = Layer.effect(
               messages: [],
             });
 
-            return [created, new Map(threads).set(threadId, created)] as const;
+            return [created, put(threads, owner, created)] as const;
           }),
         ),
       append: Effect.fn("Thread.Store.append")(function* (threadId, message) {
@@ -255,9 +353,9 @@ export const layerMemory = Layer.effect(
         return yield* SynchronizedRef.modifyEffect(
           state,
           Effect.fn(function* (threads) {
-            const current = yield* findSnapshot(threads, threadId);
+            const current = yield* findSnapshot(threads, owner, threadId);
 
-            return yield* appendEncoded(threads, current, message, encoded, timestamp);
+            return yield* appendEncoded(threads, owner, current, message, encoded, timestamp);
           }),
         );
       }),
@@ -271,7 +369,7 @@ export const layerMemory = Layer.effect(
           return yield* SynchronizedRef.modifyEffect(
             state,
             Effect.fn(function* (threads) {
-              const current = yield* findSnapshot(threads, threadId);
+              const current = yield* findSnapshot(threads, owner, threadId);
 
               const currentEncoded = yield* Effect.forEach(current.messages, (entry) =>
                 encodeMessage(threadId, entry.message),
@@ -292,7 +390,7 @@ export const layerMemory = Layer.effect(
 
               const messages = [...current.messages];
               let contentBytes = current.contentBytes;
-              let storeBytes = totalStoreBytes(threads);
+              let storeBytes = threads.contentBytes;
               let nextSequence = current.nextSequence;
 
               for (const entry of incoming.slice(currentEncoded.length)) {
@@ -349,16 +447,18 @@ export const layerMemory = Layer.effect(
                 messages,
               });
 
-              return [snapshot, new Map(threads).set(threadId, snapshot)] as const;
+              return [snapshot, put(threads, owner, snapshot)] as const;
             }),
           );
         },
       ),
       snapshot: (threadId) =>
-        SynchronizedRef.get(state).pipe(Effect.flatMap((all) => findSnapshot(all, 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), threadId);
+          const snapshot = yield* findSnapshot(yield* SynchronizedRef.get(state), owner, threadId);
 
           return ThreadExport.make({
             format: "effect-agent/ephemeral-thread@1",
@@ -367,5 +467,7 @@ export const layerMemory = Layer.effect(
           });
         }),
     });
+
+    return view(root);
   }),
 );

package/src/core/ToolExposure.ts

@@ -1,4 +1,5 @@
-import { Context, Schema } from "effect";
+import * as Context from "effect/Context";
+import * as Schema from "effect/Schema";
 import type { Tool } from "effect/unstable/ai";
 
 /** Registered native names only. Empty selection deliberately clears non-pinned Tools. */

package/src/core/ToolResult.ts

@@ -1,5 +1,5 @@
 import * as Schema from "effect/Schema";
-import { AiError } from "effect/unstable/ai";
+import * as AiError from "effect/unstable/ai/AiError";
 
 import { ToolCallId } from "./Identifiers.ts";
 import { codePointUtf8Length, utf8ByteLength } from "./internal/utf8.ts";

package/src/core/Usage.ts

@@ -1,4 +1,5 @@
-import { Effect, Schema } from "effect";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
 
 import { RunId } from "./Identifiers.ts";
 

package/src/core/Worker.ts

@@ -1,4 +1,4 @@
-import { Schema } from "effect";
+import * as Schema from "effect/Schema";
 
 import { AgentPolicy } from "./AgentPolicy.ts";
 import { Update } from "./AgentUpdates.ts";

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

@@ -1,5 +1,6 @@
-import { Schema } from "effect";
-import { Tool, Toolkit } from "effect/unstable/ai";
+import * as Schema from "effect/Schema";
+import * as Tool from "effect/unstable/ai/Tool";
+import * as Toolkit from "effect/unstable/ai/Toolkit";
 
 import { Emitter, UpdateError } from "../AgentUpdates.ts";
 

package/src/core/internal/message-status.ts

@@ -1,4 +1,4 @@
-import { Schema } from "effect";
+import * as Schema from "effect/Schema";
 
 import { SettlementId, ThreadId } from "../Identifiers.ts";
 import { IdempotencyKey, Receipt } from "../Receipt.ts";

package/src/core/internal/strict-schema.ts

@@ -1,4 +1,6 @@
-import { Schema, SchemaParser, SchemaTransformation } from "effect";
+import * as Schema from "effect/Schema";
+import * as SchemaParser from "effect/SchemaParser";
+import * as SchemaTransformation from "effect/SchemaTransformation";
 
 /** Keep strict parsing on nested values even when an outer parser uses its defaults. */
 export const strictSchema = <S extends Schema.Top>(schema: S) =>

package/src/engine/ContextCompactor.ts

@@ -1,5 +1,11 @@
-import { Context, Effect, Layer, Option, Schema, Stream } from "effect";
-import { type LanguageModel, type Model, Prompt } from "effect/unstable/ai";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
+import type { LanguageModel, Model } from "effect/unstable/ai";
+import * as Prompt from "effect/unstable/ai/Prompt";
 
 import { type CompactionPolicy } from "../core/AgentPolicy.ts";
 import { type RunId, type ThreadId } from "../core/Identifiers.ts";

package/src/engine/ContextWindow.ts

@@ -1,4 +1,7 @@
-import { Context, type Effect, Encoding, Schema } from "effect";
+import type { Effect } from "effect";
+import * as Context from "effect/Context";
+import * as Encoding from "effect/Encoding";
+import * as Schema from "effect/Schema";
 
 import { RunId, ThreadId } from "../core/Identifiers.ts";
 

package/src/engine/DurableStep.ts

@@ -1,5 +1,6 @@
-import { Context, Schema } from "effect";
 import type { Effect, Option } from "effect";
+import * as Context from "effect/Context";
+import * as Schema from "effect/Schema";
 import type { Tool } from "effect/unstable/ai";
 
 import { ToolCallId } from "../core/Identifiers.ts";

package/src/engine/MessagingHost.ts

@@ -1,4 +1,5 @@
-import { Context, type Effect } from "effect";
+import type { Effect } from "effect";
+import * as Context from "effect/Context";
 
 import type { AnyDefinition } from "../core/Agent.ts";
 import type { ThreadId } from "../core/Identifiers.ts";

package/src/engine/RunEventSink.ts

@@ -1,5 +1,6 @@
-import { Context, Schema } from "effect";
 import type { Effect } from "effect";
+import * as Context from "effect/Context";
+import * as Schema from "effect/Schema";
 
 import {
   type AgentId,

package/src/engine/RunOptions.ts

@@ -1,4 +1,8 @@
-import { type Cause, Effect, Context, type DateTime, Layer, Schema } from "effect";
+import type { Cause, DateTime } from "effect";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
 import type { LanguageModel, Model, Prompt, Response } from "effect/unstable/ai";
 
 import { type AnyDefinition } from "../core/Agent.ts";

package/src/engine/SubagentHost.ts

@@ -1,5 +1,7 @@
 import type { Effect, Option } from "effect";
-import { Context, Schema, Stream } from "effect";
+import * as Context from "effect/Context";
+import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
 
 import type * as Agent from "../core/Agent.ts";
 import type { AgentPolicy } from "../core/AgentPolicy.ts";

package/src/engine/ThreadHistory.ts

@@ -1,4 +1,7 @@
-import { Context, Effect, Layer, Schema } from "effect";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
 import type { Prompt } from "effect/unstable/ai";
 
 import { ThreadId, type RunId } from "../core/Identifiers.ts";
@@ -57,6 +60,8 @@ export class ThreadHistory extends Context.Service<
   ThreadHistory,
   {
     readonly retention: "incremental" | "on-success";
+    /** Present only for the in-memory adapter; identifies its exact Store ownership view. */
+    readonly memoryStore?: ConversationStore["Service"];
     readonly open: (request: {
       readonly threadId: ThreadId;
       readonly runId: RunId;
@@ -64,12 +69,8 @@ export class ThreadHistory extends Context.Service<
     readonly load: (threadId: ThreadId) => Effect.Effect<Prompt.Prompt, ThreadHistoryError>;
   }
 >()("@effect-agent/engine/ThreadHistory") {
-  /**
-   * Retain bounded in-memory history across Runs. Provide once around the application so
-   * all Runs share the same store. The underlying Thread.Store service is exposed for
-   * snapshots and interactive hooks; separate Layer builds own separate stores.
-   */
-  static readonly layer = Layer.effect(
+  /** 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;
@@ -84,7 +85,11 @@ export class ThreadHistory extends Context.Service<
                 ? "limit"
                 : cause._tag === "ThreadHistoryDiverged"
                   ? "conflict"
-                  : "encoding",
+                  : cause._tag === "ThreadOwnershipError"
+                    ? cause.reason === "closed"
+                      ? "fenced"
+                      : "conflict"
+                    : "encoding",
           message:
             cause._tag === "ThreadNotFound"
               ? "Thread history is not present in this application Scope"
@@ -96,6 +101,7 @@ export class ThreadHistory extends Context.Service<
 
       return ThreadHistory.of({
         retention: "incremental",
+        memoryStore: threads,
         load: (threadId) =>
           threads.snapshot(threadId).pipe(Effect.map(toPrompt), Effect.mapError(historyError)),
         open: Effect.fn("ThreadHistory.open")(function* ({ threadId, runId }) {
@@ -108,12 +114,16 @@ export class ThreadHistory extends Context.Service<
               threads
                 .recordHistory(threadId, runId, history)
                 .pipe(Effect.asVoid, Effect.mapError(historyError)),
-            commit: () => Effect.void,
+            commit: () =>
+              threads.snapshot(threadId).pipe(Effect.asVoid, Effect.mapError(historyError)),
           };
         }),
       });
     }),
-  ).pipe(Layer.provideMerge(layerMemory));
+  );
+
+  /** Retain bounded history for the application Scope. Separate Layer builds own separate stores. */
+  static readonly layer = ThreadHistory.layerFromStore.pipe(Layer.provideMerge(layerMemory));
 }
 
 /** Retain in-memory conversation history for the application Scope. */

package/src/engine/ToolBroker.ts

@@ -1,5 +1,6 @@
 import type { Effect } from "effect";
-import { Context, Schema } from "effect";
+import * as Context from "effect/Context";
+import * as Schema from "effect/Schema";
 import type { Tool, Toolkit } from "effect/unstable/ai";
 
 /**

package/src/engine/ToolExposure.ts

@@ -1,4 +1,5 @@
-import { Context, type Effect } from "effect";
+import type { Effect } from "effect";
+import * as Context from "effect/Context";
 import type { Tool } from "effect/unstable/ai";
 
 import type { RunId, ThreadId } from "../core/Identifiers.ts";