@dxos/assistant-toolkit 0.8.4-main.03d5cd7b56

package/src/crud/graph.ts

@@ -0,0 +1,380 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Tool from '@effect/ai/Tool';
+import * as Toolkit from '@effect/ai/Toolkit';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Function from 'effect/Function';
+import * as Option from 'effect/Option';
+import * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
+
+import { Entity, Filter, Obj, Query, Type } from '@dxos/echo';
+import { Database } from '@dxos/echo';
+import { type Queue } from '@dxos/echo-db';
+import { isEncodedReference } from '@dxos/echo-protocol';
+import {
+  ReferenceAnnotationId,
+  RelationSourceDXNId,
+  RelationSourceId,
+  RelationTargetDXNId,
+  RelationTargetId,
+  createObject,
+  getTypeAnnotation,
+  getTypeIdentifierAnnotation,
+} from '@dxos/echo/internal';
+import { mapAst } from '@dxos/effect';
+import { ContextQueueService } from '@dxos/functions';
+import { DXN, ObjectId } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { deepMapValues, isNonNullable, trim } from '@dxos/util';
+
+// TODO(burdon): Unify with the graph schema.
+export const Subgraph = Schema.Struct({
+  /** Objects and relations. */
+  objects: Schema.Array(Schema.Any),
+});
+
+export interface Subgraph extends Schema.Schema.Type<typeof Subgraph> {}
+
+export type RelatedSchema = {
+  schema: Type.AnyEntity;
+  kind: 'reference' | 'relation';
+};
+
+/**
+ * Find all schemas that are related to the given schema.
+ *
+ * @param db
+ * @param schema
+ * @returns
+ */
+export const findRelatedSchema = async (db: Database.Database, anchor: Type.AnyEntity): Promise<RelatedSchema[]> => {
+  // TODO(dmaretskyi): Query stored schemas.
+  const allSchemas = await db.graph.schemaRegistry.query().run();
+
+  // TODO(dmaretskyi): Also do references.
+  return allSchemas
+    .filter((schema) => {
+      if (getTypeAnnotation(schema)?.kind !== Entity.Kind.Relation) {
+        return false;
+      }
+
+      return (
+        isSchemaAddressableByDxn(anchor, DXN.parse(getTypeAnnotation(schema)!.sourceSchema!)) ||
+        isSchemaAddressableByDxn(anchor, DXN.parse(getTypeAnnotation(schema)!.targetSchema!))
+      );
+    })
+    .map(
+      (schema): RelatedSchema => ({
+        kind: 'relation',
+        schema,
+      }),
+    );
+};
+
+/**
+ * Non-strict DXN comparison.
+ * Returns true if the DXN could be resolved to the schema.
+ */
+const isSchemaAddressableByDxn = (schema: Type.AnyEntity, dxn: DXN): boolean => {
+  if (getTypeIdentifierAnnotation(schema) === dxn.toString()) {
+    return true;
+  }
+
+  const t = dxn.asTypeDXN();
+  if (t) {
+    return t.type === Type.getTypename(schema);
+  }
+
+  return false;
+};
+
+/**
+ * Perform vector search in the local database.
+ */
+// TODO(dmaretskyi): Rename `GraphReadToolkit`.
+export const LocalSearchToolkit = Toolkit.make(
+  Tool.make('search_local_search', {
+    description: 'Search the local database for information using a vector index',
+    parameters: {
+      query: Schema.String.annotations({
+        description: 'The query to search for. Could be a question or a topic or a set of keywords.',
+      }),
+    },
+    success: Schema.Unknown,
+    failure: Schema.Never,
+    dependencies: [Database.Service],
+  }),
+);
+
+export const LocalSearchHandler = LocalSearchToolkit.toLayer({
+  search_local_search: Effect.fn(function* ({ query }) {
+    const objects = yield* Database.runQuery(Query.select(Filter.text(query, { type: 'vector' })));
+    const results = [...objects];
+
+    const option = yield* Effect.serviceOption(ContextQueueService);
+    if (Option.isSome(option)) {
+      const queueObjects = yield* Effect.promise(() => option.value.queue.queryObjects());
+      // TODO(dmaretskyi): Text search on the queue.
+      results.push(...queueObjects);
+    }
+
+    return trim`
+      <local_context>
+        ${JSON.stringify(results, null, 2)}
+      </local_context>
+    `;
+  }),
+});
+
+/**
+ * Attached as an annotation to the writer tool.
+ */
+class GraphWriterSchema extends Context.Tag('@dxos/assistant/GraphWriterSchema')<
+  GraphWriterSchema,
+  {
+    schema: Type.AnyEntity[];
+  }
+>() {}
+
+/**
+ * Forms typed objects that can be written to the graph database.
+ */
+export const makeGraphWriterToolkit = ({ schema }: { schema: Type.AnyEntity[] }) => {
+  return Toolkit.make(
+    Tool.make('graph_writer', {
+      description: 'Write to the local graph database',
+      parameters: createExtractionSchema(schema).fields,
+      success: Schema.Unknown,
+      failure: Schema.Never,
+      dependencies: [Database.Service, ContextQueueService],
+    }).annotateContext(Context.make(GraphWriterSchema, { schema })),
+  );
+};
+
+export const makeGraphWriterHandler = (
+  toolkit: ReturnType<typeof makeGraphWriterToolkit>,
+  {
+    onAppend,
+  }: {
+    onAppend?: (object: DXN[]) => void;
+  } = {},
+) => {
+  const { schema } = Context.get(
+    toolkit.tools.graph_writer.annotations as Context.Context<GraphWriterSchema>,
+    GraphWriterSchema,
+  );
+
+  return toolkit.toLayer({
+    graph_writer: Effect.fn(function* (input) {
+      const { db } = yield* Database.Service;
+      const { queue } = yield* ContextQueueService;
+      const data = yield* Effect.promise(() => sanitizeObjects(schema, input as any, db, queue));
+      yield* Effect.promise(() => queue.append(data as Obj.Unknown[]));
+
+      const dxns = data.map((obj) => Obj.getDXN(obj));
+      onAppend?.(dxns);
+      return dxns;
+    }),
+  });
+};
+
+/**
+ * Create a schema for structured data extraction.
+ */
+export const createExtractionSchema = (types: Type.AnyEntity[]) => {
+  return Schema.Struct({
+    ...Object.fromEntries(
+      types.map(preprocessSchema).map((schema, index) => [
+        `objects_${getSanitizedSchemaName(types[index])}`,
+        Schema.optional(Schema.Array(schema)).annotations({
+          description: `The objects of type: ${Type.getDXN(types[index])?.asTypeDXN()!.type}. ${SchemaAST.getDescriptionAnnotation(types[index].ast).pipe(Option.getOrElse(() => ''))}`,
+        }),
+      ]),
+    ),
+  });
+};
+
+export const getSanitizedSchemaName = (schema: Type.AnyEntity) => {
+  return Type.getDXN(schema)!
+    .asTypeDXN()!
+    .type.replaceAll(/[^a-zA-Z0-9]+/g, '_');
+};
+
+export const sanitizeObjects = async (
+  types: Type.AnyEntity[],
+  data: Record<string, readonly unknown[]>,
+  db: Database.Database,
+  queue?: Queue,
+): Promise<Obj.Unknown[]> => {
+  const entries = types
+    .map(
+      (type) =>
+        data[`objects_${getSanitizedSchemaName(type)}`]?.map((object: any) => ({
+          data: object,
+          schema: type,
+        })) ?? [],
+    )
+    .flat();
+
+  const idMap = new Map<string, string>();
+  const existingIds = new Set<ObjectId>();
+  const enitties = new Map<ObjectId, Entity.Unknown>();
+
+  const resolveId = (id: string): DXN | undefined => {
+    if (ObjectId.isValid(id)) {
+      existingIds.add(id);
+      return DXN.fromLocalObjectId(id);
+    }
+
+    const mappedId = idMap.get(id);
+    if (mappedId) {
+      return DXN.fromLocalObjectId(mappedId);
+    }
+
+    return undefined;
+  };
+
+  const res = entries
+    .map((entry) => {
+      // This entry mutates existing object.
+      if (ObjectId.isValid(entry.data.id)) {
+        return entry;
+      }
+
+      idMap.set(entry.data.id, ObjectId.random());
+      entry.data.id = idMap.get(entry.data.id);
+      return entry;
+    })
+    .map((entry) => {
+      const data = deepMapValues(entry.data, (value, recurse) => {
+        if (isEncodedReference(value)) {
+          const ref = value['/'];
+          const id = resolveId(ref);
+
+          if (id) {
+            // Link to an existing object.
+            return { '/': id.toString() };
+          } else {
+            // Search URIs?
+            return { '/': `search:?q=${encodeURIComponent(ref)}` };
+          }
+        }
+
+        return recurse(value);
+      });
+
+      if (Entity.getKind(entry.schema) === 'relation') {
+        const sourceDxn = resolveId(data.source);
+        if (!sourceDxn) {
+          log.warn('source not found', { source: data.source });
+        }
+        const targetDxn = resolveId(data.target);
+        if (!targetDxn) {
+          log.warn('target not found', { target: data.target });
+        }
+        delete data.source;
+        delete data.target;
+        data[RelationSourceDXNId] = sourceDxn;
+        data[RelationTargetDXNId] = targetDxn;
+      }
+
+      return {
+        data,
+        schema: entry.schema,
+      };
+    })
+    .filter((object) => !existingIds.has(object.data.id)); // TODO(dmaretskyi): This dissallows updating existing objects.
+
+  // TODO(dmaretskyi): Use ref resolver.
+  const dbObjects = await db.query(Query.select(Filter.id(...existingIds))).run();
+  const queueObjects = (await queue?.getObjectsById([...existingIds])) ?? [];
+  const objects = [...dbObjects, ...queueObjects].filter(isNonNullable);
+
+  // TODO(dmaretskyi): Returns everything if IDs are empty!
+  log.info('objects', { dbObjects, queueObjects, existingIds });
+  const missing = Array.from(existingIds).filter((id) => !objects.some((object) => object.id === id));
+  if (missing.length > 0) {
+    throw new Error(`Object IDs do not point to existing objects: ${missing.join(', ')}`);
+  }
+
+  return res.flatMap(({ data, schema }) => {
+    let skip = false;
+    if (RelationSourceDXNId in data) {
+      const id = (data[RelationSourceDXNId] as DXN).asEchoDXN()?.echoId;
+      const obj = objects.find((object) => object.id === id) ?? enitties.get(id!);
+      if (obj) {
+        delete data[RelationSourceDXNId];
+        data[RelationSourceId] = obj;
+      } else {
+        skip = true;
+      }
+    }
+    if (RelationTargetDXNId in data) {
+      const id = (data[RelationTargetDXNId] as DXN).asEchoDXN()?.echoId;
+      const obj = objects.find((object) => object.id === id) ?? enitties.get(id!);
+      if (obj) {
+        delete data[RelationTargetDXNId];
+        data[RelationTargetId] = obj;
+      } else {
+        skip = true;
+      }
+    }
+    if (!skip) {
+      const obj = createObject(schema, data);
+      enitties.set(obj.id, obj);
+      return [obj];
+    }
+    return [];
+  });
+};
+
+const SoftRef = Schema.Struct({
+  '/': Schema.String,
+}).annotations({
+  description: 'Reference to another object.',
+});
+
+const preprocessSchema = (schema: Schema.Schema.AnyNoContext) => {
+  const isRelationSchema = Entity.getKind(schema) === 'relation';
+
+  const go = (ast: SchemaAST.AST, visited = new Set<SchemaAST.AST>()): SchemaAST.AST => {
+    if (visited.has(ast)) {
+      // Already visited this node, prevent infinite recursion.
+      return ast;
+    }
+    visited.add(ast);
+
+    if (SchemaAST.getAnnotation(ast, ReferenceAnnotationId).pipe(Option.isSome)) {
+      return SoftRef.ast;
+    }
+
+    return mapAst(ast, (child) => go(child, visited));
+  };
+
+  return Schema.make<any, any, never>(mapAst(schema.ast, (ast) => go(ast))).pipe(
+    Schema.omit('id'),
+    Schema.extend(
+      Schema.Struct({
+        id: Schema.String.annotations({
+          description: 'The id of this object. Come up with a unique id based on your judgement.',
+        }),
+      }),
+    ),
+    isRelationSchema
+      ? Schema.extend(
+          Schema.Struct({
+            source: Schema.String.annotations({
+              description: 'The id of the source object for this relation.',
+            }),
+            target: Schema.String.annotations({
+              description: 'The id of the target object for this relation.',
+            }),
+          }),
+        )
+      : Function.identity<Schema.Schema.AnyNoContext>,
+  );
+};

package/src/crud/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './graph';

package/src/errors.ts

@@ -0,0 +1,25 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { BaseError } from '@dxos/errors';
+import { DXN } from '@dxos/keys';
+
+/**
+ * Agent could not execute prompt.
+ */
+export class PromptError extends BaseError.extend('PromptError') {
+  constructor(
+    message: string,
+    context: {
+      description?: string;
+      prompt?: DXN.String;
+      chat?: DXN.String;
+    },
+  ) {
+    super({
+      message,
+      context,
+    });
+  }
+}

package/src/functions/READ_THIS.md

@@ -0,0 +1,5 @@
+###
+
+Can we move all functions into the corresponding blueprint folder?
+
+###

package/src/functions/agent/definitions.ts

@@ -0,0 +1,56 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { AiService, OpaqueToolkit, ModelName } from '@dxos/ai';
+import { Routine, Trace, Operation, OperationRegistry } from '@dxos/compute';
+import { Database, Feed, Ref } from '@dxos/echo';
+import { Text } from '@dxos/schema';
+
+import * as Chat from '../../types/Chat';
+
+// TODO(dmaretskyi): Rename to RunRoutine.
+export const AgentPrompt = Operation.make({
+  meta: {
+    key: 'org.dxos.function.prompt',
+    name: 'Run Routine',
+    description: 'Agentic worker that executes a provided prompt using blueprints and tools.',
+  },
+  input: Schema.Struct({
+    prompt: Ref.Ref(Routine.Routine),
+
+    /**
+     * When set, runs in this chat (history, queue, and bound context). Routine blueprints and context objects are merged into the conversation for this request.
+     */
+    chat: Schema.optional(Ref.Ref(Chat.Chat)),
+
+    /**
+     * @default @anthropic/claude-opus-4-6
+     */
+
+    model: Schema.optional(ModelName),
+    /**
+     * Input object or data.
+     * References get auto-resolved.
+     */
+    input: Schema.Any.pipe(Schema.annotations({ title: 'Input' })),
+
+    systemInstructions: Schema.optional(Schema.String).annotations({
+      description: 'Additional system instructions to add to the system prompt.',
+    }),
+  }),
+  output: Schema.Any,
+  // ECHO types that the handler loads via Database.load(). Declaring them here ensures the
+  // runtime registers their schema before remote invocation (e.g. via the EDGE function service).
+  types: [Routine.Routine, Text.Text, Feed.Feed, Chat.Chat],
+  services: [
+    AiService.AiService,
+    Database.Service,
+    Feed.FeedService,
+    OpaqueToolkit.OpaqueToolkitProvider,
+    OperationRegistry.Service,
+    Trace.TraceService,
+  ],
+}).pipe(Operation.intrinsic);

package/src/functions/agent/index.ts

@@ -0,0 +1,9 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { OperationHandlerSet } from '@dxos/compute';
+
+export * from './definitions';
+
+export const AgentHandlers = OperationHandlerSet.lazy(() => import('./prompt'));

package/src/functions/agent/prompt.conversations.json

@@ -0,0 +1 @@
+{"conversations":[{"parameters":{"model":"@anthropic/claude-opus-4-6","stream":true,"tools":[{"name":"completeJob","inputSchema":{"type":"object","required":[],"properties":{"success":{"$id":"/schemas/any","title":"any"},"failure":{"type":"object","required":["message"],"properties":{"message":{"type":"string","description":"Short message describing the error."},"description":{"type":"string","description":"Optional longer message describing in detail what went wrong"}},"additionalProperties":false}},"additionalProperties":false}}]},"prompt":{"content":[{"role":"system","content":"You are an agent running in the non-interactive mode.\nThe user is unable to see what you are doing, and cannot answer any questions.\nDo not ask questions.\nComplete the task before you, and at the end call [completeJob] with the output.\nIf you are unable to complete the task, call [completeJob] with the failure reason.\nIf no output is required, call [completeJob] with an empty object: {}\nDo not stop until you call [completeJob].","options":{}},{"role":"user","content":"Reply with a single word: ack.\n<input>{}</input>","options":{"anthropic":{"cacheControl":{"ttl":"5m","type":"ephemeral"}}}}]},"response":[{"type":"response-metadata","id":"msg_01BNfgUBNqETGfNka6Y58SUS","modelId":"claude-opus-4-6","timestamp":"1970-01-01T00:00:00.000Z","metadata":{}},{"type":"reasoning-start","id":"0","metadata":{}},{"type":"reasoning-delta","id":"0","delta":"The","metadata":{}},{"type":"reasoning-delta","id":"0","delta":" user wants me to reply with a single word \"ack\" and complete the job.","metadata":{}},{"type":"reasoning-delta","id":"0","delta":"","metadata":{"anthropic":{"type":"thinking","signature":"EoQCClkIDRgCKkDmvWuElJmvgQqKv/OM8h45Qm9vFiau8OtHTiKeFGzABfFt5k5Oc9XiWXg1jeCrSXFmAcI3XEaKXp6jF8PCj/O0Mg9jbGF1ZGUtb3B1cy00LTY4ABIMidROWDebGP+ji8voGgyiyrnCLJU9DZTeWc0iMJ5ewfC96fa6DHSOj+APcM0VyN0tJiYPjIJI7DxYTiu277zCDVNdAUxNb/k45dQGripZikOeASjJaTuovSm8Ni01mepSojCietSMDfM1xBLbnyPHKxucO7akJRwDczuw8req/NjtOhY492FCt1lagajkZq8/rsICFxutxbPXyHXSY04cd/2+oY9cRAQYAQ=="}}},{"type":"reasoning-end","id":"0","metadata":{}},{"type":"tool-params-start","id":"toolu_01VQiUHtyF77TZd49DrKhnPR","name":"completeJob","providerExecuted":false,"metadata":{}},{"type":"tool-params-delta","id":"toolu_01VQiUHtyF77TZd49DrKhnPR","delta":"","metadata":{}},{"type":"tool-params-delta","id":"toolu_01VQiUHtyF77TZd49DrKhnPR","delta":"{\"success","metadata":{}},{"type":"tool-params-delta","id":"toolu_01VQiUHtyF77TZd49DrKhnPR","delta":"\": \"ack\"}","metadata":{}},{"type":"tool-params-end","id":"toolu_01VQiUHtyF77TZd49DrKhnPR","metadata":{}},{"type":"finish","reason":"tool-calls","usage":{"inputTokens":757,"outputTokens":89,"totalTokens":846},"metadata":{"anthropic":{"usage":{"cache_creation":{"ephemeral_1h_input_tokens":0,"ephemeral_5m_input_tokens":0},"cache_creation_input_tokens":0,"cache_read_input_tokens":0,"input_tokens":757,"output_tokens":9,"server_tool_use":null,"service_tier":"standard"}}}}]},{"parameters":{"model":"@anthropic/claude-opus-4-6","stream":true,"tools":[{"name":"completeJob","inputSchema":{"type":"object","required":[],"properties":{"success":{"$id":"/schemas/any","title":"any"},"failure":{"type":"object","required":["message"],"properties":{"message":{"type":"string","description":"Short message describing the error."},"description":{"type":"string","description":"Optional longer message describing in detail what went wrong"}},"additionalProperties":false}},"additionalProperties":false}}]},"prompt":{"content":[{"role":"system","content":"You are an agent running in the non-interactive mode.\nThe user is unable to see what you are doing, and cannot answer any questions.\nDo not ask questions.\nComplete the task before you, and at the end call [completeJob] with the output.\nIf you are unable to complete the task, call [completeJob] with the failure reason.\nIf no output is required, call [completeJob] with an empty object: {}\nDo not stop until you call [completeJob].","options":{}},{"role":"user","content":"Reply with a single word: ack.\n<input>{}</input>","options":{}},{"role":"assistant","content":[{"type":"reasoning","text":"The user wants me to reply with a single word \"ack\" and complete the job.","options":{}},{"type":"tool-call","id":"toolu_01VQiUHtyF77TZd49DrKhnPR","name":"completeJob","params":{"success":"ack"},"providerExecuted":false,"options":{}}],"options":{}},{"role":"tool","content":[{"type":"tool-result","id":"toolu_01VQiUHtyF77TZd49DrKhnPR","name":"completeJob","isFailure":false,"result":{},"providerExecuted":false,"options":{}}],"options":{"anthropic":{"cacheControl":{"ttl":"5m","type":"ephemeral"}}}}]},"response":[{"type":"response-metadata","id":"msg_017Q7gpzDqQTqmKWouYU2oKt","modelId":"claude-opus-4-6","timestamp":"1970-01-01T00:00:00.000Z","metadata":{}},{"type":"finish","reason":"stop","usage":{"inputTokens":824,"outputTokens":2,"totalTokens":826},"metadata":{"anthropic":{"usage":{"cache_creation":{"ephemeral_1h_input_tokens":0,"ephemeral_5m_input_tokens":0},"cache_creation_input_tokens":0,"cache_read_input_tokens":0,"input_tokens":824,"output_tokens":2,"server_tool_use":null,"service_tier":"standard"}}}}]}]}

package/src/functions/agent/prompt.test.ts

@@ -0,0 +1,81 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, expect, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+
+import { ContextBinding } from '@dxos/assistant';
+import { Routine, Operation, OperationHandlerSet } from '@dxos/compute';
+import { Database, Feed, Obj, Ref } from '@dxos/echo';
+import { TestHelpers } from '@dxos/effect/testing';
+import { QueueService } from '@dxos/functions';
+import { AssistantTestLayer } from '@dxos/functions-runtime/testing';
+import { ObjectId } from '@dxos/keys';
+import { Text } from '@dxos/schema';
+import { Message } from '@dxos/types';
+
+import * as Chat from '../../types/Chat';
+import { AgentPrompt } from './definitions';
+import defaultAgentPrompt from './prompt';
+
+ObjectId.dangerouslyDisableRandomness();
+
+const operationHandlerSet = OperationHandlerSet.make(defaultAgentPrompt);
+
+const TestLayer = AssistantTestLayer({
+  operationHandlers: operationHandlerSet,
+  types: [Chat.Chat, Message.Message, ContextBinding, Text.Text],
+  aiServicePreset: 'edge-remote',
+});
+
+const countQueueMessages = (queue: { queryObjects: () => Promise<Obj.Unknown[]> }) =>
+  Effect.promise(async () => {
+    const items = await queue.queryObjects();
+    return items.filter(Obj.instanceOf(Message.Message)).length;
+  });
+
+describe('Agent prompt', () => {
+  it.effect(
+    'chat mode appends assistant messages to the chat queue',
+    Effect.fnUntraced(
+      function* (_) {
+        const feed = yield* Database.add(Feed.make());
+        const queueDxn = Feed.getQueueDxn(feed)!;
+        const queue = yield* QueueService.getQueue<Message.Message | ContextBinding>(queueDxn);
+        const messageCountBefore = yield* countQueueMessages(queue);
+
+        const chat = yield* Database.add(
+          Chat.make({
+            feed: Ref.make(feed),
+          }),
+        );
+
+        const prompt = yield* Database.add(
+          Routine.make({
+            name: 'chat-mode-test',
+            instructions: 'Reply with a single word: ack.',
+            blueprints: [],
+            context: [],
+          }),
+        );
+
+        yield* Database.flush();
+
+        const result = yield* Operation.invoke(AgentPrompt, {
+          prompt: Ref.make(prompt),
+          input: {},
+          chat: Ref.make(chat),
+        });
+
+        const messageCountAfter = yield* countQueueMessages(queue);
+
+        expect(messageCountAfter).toBeGreaterThan(messageCountBefore);
+        expect(result).toBe('ack');
+      },
+      Effect.provide(TestLayer),
+      TestHelpers.provideTestContext,
+    ),
+    { timeout: 60_000 },
+  );
+});