@dxos/assistant-toolkit 0.8.4-main.74a063c4e0 → 0.8.4-main.765dc60934

package/src/functions/agent/prompt.ts

@@ -12,22 +12,18 @@ import * as Layer from 'effect/Layer';
 import * as Option from 'effect/Option';
 import * as Schema from 'effect/Schema';
 
-import { AiService, ConsolePrinter, GenericToolkit, ModelName } from '@dxos/ai';
+import { AiService, OpaqueToolkit, ModelName } from '@dxos/ai';
 import {
-  AiConversation,
-  GenerationObserver,
-  functionInvocationServiceFromOperations,
+  AiSession,
   getOperationFromTool,
   makeToolExecutionService,
   makeToolResolverFromOperations,
 } from '@dxos/assistant';
-import { Template } from '@dxos/blueprints';
+import { Template, Trace, Operation } from '@dxos/compute';
 import { Database, Feed, Obj, Ref } from '@dxos/echo';
 import { acquireReleaseResource } from '@dxos/effect';
-import { TracingService } from '@dxos/functions';
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
-import { Operation } from '@dxos/operation';
 import { trim } from '@dxos/util';
 
 import { PromptError } from '../../errors';
@@ -36,8 +32,6 @@ import { AgentPrompt } from './definitions';
 
 const DEFAULT_MODEL: ModelName = '@anthropic/claude-opus-4-6';
 
-const observer = GenerationObserver.fromPrinter(new ConsolePrinter({ tag: 'agent' }));
-
 export default AgentPrompt.pipe(
   Operation.withHandler(
     Effect.fnUntraced(
@@ -50,7 +44,7 @@ export default AgentPrompt.pipe(
 
         yield* Database.flush();
         const prompt = yield* Database.load(data.prompt);
-        yield* TracingService.emitStatus({ message: `Running ${prompt.id}` });
+        yield* Trace.emitStatus(`Running ${prompt.id}`);
 
         log.info('starting agent', { prompt: prompt.id, input });
 
@@ -69,16 +63,20 @@ export default AgentPrompt.pipe(
         );
 
         const promptInstructions = yield* Database.load(prompt.instructions.source);
-        const promptText = Template.process(promptInstructions.content, input);
+        let promptText = Template.process(promptInstructions.content, input);
+
+        if (input !== undefined) {
+          promptText += `\n<input>${JSON.stringify(input)}</input>`;
+        }
 
         let systemText = trim`
           You are an agent running in the non-interactive mode.
           The user is unable to see what you are doing, and cannot answer any questions.
           Do not ask questions.
-          Complete the task before you, and at the end call [complete_job] with the output.
-          If you are unable to complete the task, call [complete_job] with the failure reason.
-          If no output is required, call [complete_job] with { "success": "undefined" }
-          Do not stop until you call [complete_job].
+          Complete the task before you, and at the end call [completeJob] with the output.
+          If you are unable to complete the task, call [completeJob] with the failure reason.
+          If no output is required, call [completeJob] with an empty object: {}
+          Do not stop until you call [completeJob].
         `;
         if (data.systemInstructions) {
           systemText += `\n\n${data.systemInstructions}`;
@@ -102,53 +100,60 @@ export default AgentPrompt.pipe(
         });
 
         const runtime = yield* Effect.runtime<Feed.FeedService>();
-        const conversation = yield* acquireReleaseResource(() => new AiConversation({ feed, runtime }));
+        const session = yield* acquireReleaseResource(() => new AiSession.Session({ feed, runtime }));
 
         yield* Effect.promise(() =>
-          conversation.context.bind({
+          session.context.bind({
             blueprints: blueprints.map((blueprint) => Ref.make(blueprint)),
             objects: objects.map((object) => Ref.make(object as Obj.Unknown)),
           }),
         );
 
-        yield* conversation
+        yield* session
           .createRequest({
             prompt: promptText,
             system: systemText,
-            observer,
-            toolkit: promptToolkit.toolkit,
+            toolkit: promptToolkit,
           })
           .pipe(
             Effect.provide(
-              Layer.mergeAll(
-                modelLayer,
-                promptToolkit.layer,
-                ToolExecutionService({ feed }),
-                makeToolResolverFromOperations(),
-              ),
+              Layer.mergeAll(modelLayer, ToolExecutionService({ feed }), makeToolResolverFromOperations()),
             ),
           );
 
         return yield* Deferred.poll(resultSink).pipe(
           Effect.flatten,
-          Effect.catchTag('NoSuchElementException', () => Effect.die('Agent did not signal task completion.')),
           Effect.flatten,
-          Effect.mapError(
-            (err) =>
-              new PromptError(err.message ?? 'Agent failed with an unknown error.', {
-                description: err.context.description as string | undefined,
-                prompt: data.prompt.dxn.toString(),
-              }),
+          Effect.catchTag('NoSuchElementException', () =>
+            Effect.gen(function* () {
+              yield* session
+                .createRequest({
+                  prompt: 'You must signal task completion by calling [completeJob] with the output or failure reason.',
+                  system: systemText,
+                  toolkit: promptToolkit,
+                })
+                .pipe(
+                  Effect.provide(
+                    Layer.mergeAll(modelLayer, ToolExecutionService({ feed }), makeToolResolverFromOperations()),
+                  ),
+                );
+
+              return yield* Deferred.poll(resultSink).pipe(
+                Effect.flatten,
+                Effect.flatten,
+                Effect.catchTag('NoSuchElementException', () =>
+                  Effect.fail(new PromptError('Agent did not signal task completion.', {})),
+                ),
+              );
+            }),
           ),
         );
       },
+      Effect.tapBoth({
+        onSuccess: () => Database.flush(),
+        onFailure: () => Database.flush(),
+      }),
       Effect.scoped,
-      Effect.provide(
-        Layer.empty.pipe(
-          Layer.provideMerge(functionInvocationServiceFromOperations),
-          Layer.provideMerge(TracingService.layerNoop),
-        ),
-      ),
     ),
   ),
   Operation.opaqueHandler,
@@ -159,7 +164,7 @@ const makePromptAgentToolkit = (options: {
   resultSink: Deferred.Deferred<unknown, PromptError>;
 }) => {
   class PromptAgentToolkit extends Toolkit.make(
-    Tool.make('complete_job', {
+    Tool.make('completeJob', {
       parameters: {
         success: Schema.optional(Schema.Any), // TODO(dmaretskyi): Pipe output schema here.
         failure: Schema.optional(
@@ -176,7 +181,7 @@ const makePromptAgentToolkit = (options: {
     }),
   ) {}
   const layer = PromptAgentToolkit.toLayer({
-    complete_job: Effect.fnUntraced(function* (result) {
+    completeJob: Effect.fnUntraced(function* (result) {
       if (result.failure) {
         yield* Deferred.fail(
           options.resultSink,
@@ -190,7 +195,7 @@ const makePromptAgentToolkit = (options: {
     }),
   });
 
-  return GenericToolkit.make(PromptAgentToolkit, layer);
+  return OpaqueToolkit.make(PromptAgentToolkit, layer);
 };
 
 interface ToolExecutionServiceOptions {

package/src/functions/index.ts

@@ -3,5 +3,3 @@
 //
 
 export * from './agent';
-export * from './entity-extraction';
-export * from './exa';

package/src/sync/sync.ts

@@ -4,8 +4,7 @@
 
 import * as Effect from 'effect/Effect';
 
-import { Filter, Obj, Query, Ref } from '@dxos/echo';
-import { Database } from '@dxos/echo';
+import { Database, Filter, Obj, Query, Ref } from '@dxos/echo';
 import { failedInvariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 
@@ -29,10 +28,16 @@ export const syncObjects: (
     Effect.fnUntraced(function* (obj) {
       // Sync referenced objects.
       for (const key of Object.keys(obj)) {
-        if (typeof key !== 'string' || key === 'id') continue;
-        if (!Ref.isRef((obj as any)[key])) continue;
+        if (typeof key !== 'string' || key === 'id') {
+          continue;
+        }
+        if (!Ref.isRef((obj as any)[key])) {
+          continue;
+        }
         const ref: Ref.Unknown = (obj as any)[key];
-        if (!ref.target) continue;
+        if (!ref.target) {
+          continue;
+        }
         if (Obj.getDXN(ref.target).isLocalObjectId()) {
           // obj not persisted to db.
           const [target] = yield* syncObjects([ref.target], { foreignKeyId });
@@ -63,33 +68,38 @@ export const syncObjects: (
 });
 
 const copyObjectData = (existing: Obj.Unknown, newObj: Obj.Unknown) => {
-  Obj.change(existing, (obj) => {
+  Obj.update(existing, (existing) => {
     // Copy properties from newObj to existing.
     for (const key of Object.keys(newObj)) {
-      if (typeof key !== 'string' || key === 'id') continue;
+      if (typeof key !== 'string' || key === 'id') {
+        continue;
+      }
       if (
         typeof (newObj as any)[key] !== 'string' &&
         typeof (newObj as any)[key] !== 'number' &&
         typeof (newObj as any)[key] !== 'boolean' &&
         !Ref.isRef((newObj as any)[key])
-      )
+      ) {
         continue;
-      (obj as any)[key] = (newObj as any)[key];
+      }
+      (existing as any)[key] = (newObj as any)[key];
     }
 
     // Delete properties that don't exist in newObj.
-    for (const key of Object.keys(obj)) {
-      if (typeof key !== 'string' || key === 'id') continue;
+    for (const key of Object.keys(existing)) {
+      if (typeof key !== 'string' || key === 'id') {
+        continue;
+      }
       if (!(key in newObj)) {
-        delete (obj as any)[key];
+        delete (existing as any)[key];
       }
     }
 
     // Update foreign keys.
     for (const foreignKey of Obj.getMeta(newObj).keys) {
-      Obj.deleteKeys(obj, foreignKey.source);
+      Obj.deleteKeys(existing, foreignKey.source);
       // TODO(dmaretskyi): Doesn't work: `Obj.getMeta(existing).keys.push(foreignKey);`
-      Obj.getMeta(obj).keys.push({ ...foreignKey });
+      Obj.getMeta(existing).keys.push({ ...foreignKey });
     }
   });
 };

package/src/testing/plugins.tsx

@@ -9,7 +9,7 @@ import { Capabilities, Capability } from '@dxos/app-framework';
 import { Surface } from '@dxos/app-framework/ui';
 import { Format, type Obj, Type } from '@dxos/echo';
 import { Card } from '@dxos/react-ui';
-import { Json } from '@dxos/react-ui-syntax-highlighter';
+import { Syntax } from '@dxos/react-ui-syntax-highlighter';
 
 export const MapSchema = Schema.Struct({
   coordinates: Format.GeoPoint,
@@ -64,12 +64,14 @@ export const capabilities: Capability.Any[] = [
       position: 'fallback',
       component: ({ data }) => (
         <Card.Content>
-          <Json.Root data={data}>
-            <Json.Content>
-              <Json.Filter />
-              <Json.Data />
-            </Json.Content>
-          </Json.Root>
+          <Syntax.Root data={data}>
+            <Syntax.Content>
+              <Syntax.Filter />
+              <Syntax.Viewport>
+                <Syntax.Code />
+              </Syntax.Viewport>
+            </Syntax.Content>
+          </Syntax.Root>
         </Card.Content>
       ),
     }),

package/src/types/Agent.ts

@@ -0,0 +1,238 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+// @import-as-namespace
+
+import * as Effect from 'effect/Effect';
+import * as Function from 'effect/Function';
+import * as Schema from 'effect/Schema';
+
+import { AiContext } from '@dxos/assistant';
+import { type Blueprint } from '@dxos/compute';
+import { Annotation, Database, Feed, Format, Obj, Ref, Relation, Type } from '@dxos/echo';
+import { type ObjectNotFoundError } from '@dxos/echo/Err';
+import { FormInputAnnotation } from '@dxos/echo/internal';
+import { acquireReleaseResource } from '@dxos/effect';
+import { invariant } from '@dxos/invariant';
+import { Text } from '@dxos/schema';
+
+import * as Chat from './Chat';
+import * as Plan from './Plan';
+
+/**
+ * Agent schema definition.
+ */
+export const Agent = Schema.Struct({
+  name: Schema.optional(Schema.String),
+
+  /**
+   * When false, agent triggers are disabled after sync-triggers runs.
+   */
+  enabled: Schema.optional(Schema.Boolean).annotations({
+    title: 'Enabled',
+    description: 'Master switch for agent automation; propagated to all triggers on sync.',
+  }),
+
+  /**
+   * Instructions for the agent.
+   */
+  instructions: Ref.Ref(Text.Text).pipe(
+    Format.FormatAnnotation.set(Format.TypeFormat.Markdown),
+    Schema.annotations({ title: 'Instructions' }),
+  ),
+
+  /**
+   * Primary chat for the agent.
+   */
+  // TODO(dmaretskyi): Multiple chats; RB: branching hierarchy.
+  chat: Schema.optional(Ref.Ref(Chat.Chat).pipe(FormInputAnnotation.set(false))),
+
+  // TODO(burdon): Is this used? Should it be an artifact?
+  // Format.FormatAnnotation.set(Format.TypeFormat.Markdown)
+  plan: Ref.Ref(Plan.Plan).pipe(FormInputAnnotation.set(false)),
+
+  // TODO(burdon): Currently Memory.Memory objects are global to the space; make them artifacts?
+  artifacts: Schema.Array(
+    Schema.Struct({
+      // TODO(dmaretskyi): Consider gettings names from the artifact itself using Obj.getLabel.
+      name: Schema.String,
+      // TODO(burdon): Rename object.
+      data: Ref.Ref(Obj.Unknown),
+    }),
+  ).pipe(FormInputAnnotation.set(false)),
+
+  /**
+   * References to objects with a canonical queue property.
+   * Schema must have the QueueAnnotation.
+   */
+  // Change to trigger.
+  // TODO(dmaretskyi): Turn into an array of objects when form-data
+  subscriptions: Schema.Array(Ref.Ref(Obj.Unknown)).pipe(FormInputAnnotation.set(false)),
+
+  /**
+   * Cron expression for a timer trigger that invokes the agent worker on a schedule.
+   * The timer trigger bypasses the qualifier and goes straight to the agent worker.
+   */
+  // Change to trigger.
+  cron: Schema.optional(Schema.String).annotations({
+    title: 'Cron',
+    description: 'Cron expression for a timer trigger that invokes the agent on a schedule.',
+  }),
+
+  /**
+   * Allow the agent to filter events.
+   * Related events will be added to the input queue of the agent.
+   * It is recommended to enable this.
+   * @deprecated
+   */
+  filterEvents: Schema.optional(Schema.Boolean).annotations({
+    title: 'Filter events',
+    description: 'Allow the agent to filter events.',
+  }),
+
+  /**
+   * Input feed for subscriptions.
+   * @deprecated Subscriptions will write directly to the agent.
+   */
+  feed: Schema.optional(Ref.Ref(Feed.Feed).pipe(FormInputAnnotation.set(false))),
+}).pipe(
+  Type.object({
+    typename: 'org.dxos.type.agent',
+    version: '0.1.0',
+  }),
+  Annotation.LabelAnnotation.set(['name']),
+  Annotation.IconAnnotation.set({
+    icon: 'ph--drone--regular',
+    hue: 'sky',
+  }),
+);
+
+export interface Agent extends Schema.Schema.Type<typeof Agent> {}
+
+/**
+ * Creates a fully initialized Agent with chat, queue, and context bindings.
+ *
+ * @param props - Agent properties including spec, plan, blueprints, and context objects.
+ * @param blueprint - The blueprint to use for the agent context.
+ * @returns An Effect that yields the initialized Agent.
+ */
+export const makeInitialized = (
+  props: Omit<Obj.MakeProps<typeof Agent>, 'instructions' | 'plan' | 'artifacts' | 'subscriptions' | 'chat'> &
+    Partial<Pick<Obj.MakeProps<typeof Agent>, 'artifacts' | 'subscriptions'>> & {
+      instructions: string;
+      blueprints?: Ref.Ref<Blueprint.Blueprint>[];
+      contextObjects?: Ref.Ref<Obj.Any>[];
+    },
+  blueprint: Blueprint.Blueprint,
+): Effect.Effect<Agent, never, Feed.FeedService | Database.Service> =>
+  Effect.gen(function* () {
+    const agent = Obj.make(Agent, {
+      ...props,
+      instructions: Ref.make(Text.make({ content: props.instructions })),
+      plan: Ref.make(Plan.makePlan({ tasks: [] })),
+      artifacts: props.artifacts ?? [],
+      subscriptions: props.subscriptions ?? [],
+      filterEvents: props.filterEvents ?? true,
+      enabled: props.enabled ?? true,
+    });
+    yield* Database.add(agent);
+    const feed = yield* Database.add(Feed.make());
+    const runtime = yield* Effect.runtime<Feed.FeedService>();
+    const contextBinder = new AiContext.Binder({ feed, runtime });
+    // TODO(dmaretskyi): Blueprint registry.
+    const agentBlueprint = yield* Database.add(Obj.clone(blueprint, { deep: true }));
+    yield* Effect.promise(() =>
+      contextBinder.bind({
+        blueprints: [Ref.make(agentBlueprint), ...(props.blueprints ?? [])],
+        objects: [Ref.make(agent), ...(props.contextObjects ?? [])],
+      }),
+    );
+    const chat = yield* Database.add(
+      Chat.make({
+        [Obj.Parent]: agent,
+        feed: Ref.make(feed),
+      }),
+    );
+    Obj.setParent(feed, chat);
+    yield* Database.add(
+      Relation.make(Chat.CompanionTo, {
+        [Relation.Source]: chat,
+        [Relation.Target]: agent,
+      }),
+    );
+
+    const inputFeed = yield* Database.add(Feed.make());
+
+    Obj.update(agent, (agent) => {
+      agent.chat = Ref.make(chat);
+      agent.feed = Ref.make(inputFeed);
+    });
+
+    return agent;
+  });
+
+/**
+ * Resets the agent chat history by rebuilding the chat context.
+ * Preserves the existing blueprints and objects from the current chat context.
+ *
+ * @param agent - The agent whose chat history should be reset. Must have an existing chat.
+ * @returns An Effect that resets the chat history.
+ */
+export const resetChatHistory = (
+  agent: Agent,
+): Effect.Effect<void, ObjectNotFoundError, Feed.FeedService | Database.Service> =>
+  Effect.gen(function* () {
+    invariant(agent.chat, 'Agent must have an existing chat to reset.');
+
+    const existingFeed = yield* agent.chat.pipe(Database.load).pipe(
+      Effect.map((_) => _.feed),
+      Effect.flatMap(Database.load),
+    );
+    const runtime = yield* Effect.runtime<Feed.FeedService>();
+    const existingContextBinder = yield* acquireReleaseResource(
+      () =>
+        new AiContext.Binder({
+          feed: existingFeed,
+          runtime,
+        }),
+    );
+    const blueprints = existingContextBinder.getBlueprints().map((blueprint) => Ref.make(blueprint));
+    const objects = existingContextBinder.getObjects().map((object) => Ref.make(object));
+
+    const feed = yield* Database.add(Feed.make());
+    const contextBinder = new AiContext.Binder({ feed, runtime });
+    yield* Effect.promise(() =>
+      contextBinder.bind({
+        blueprints,
+        objects,
+      }),
+    );
+
+    const chat = yield* Database.add(
+      Chat.make({
+        feed: Ref.make(feed),
+      }),
+    );
+    Obj.setParent(feed, chat);
+    Obj.update(agent, (agent) => {
+      agent.chat = Ref.make(chat);
+    });
+
+    yield* Database.add(
+      Relation.make(Chat.CompanionTo, {
+        [Relation.Source]: chat,
+        [Relation.Target]: agent,
+      }),
+    );
+  }).pipe(Effect.scoped);
+
+export const getFromChatContext: Effect.Effect<Agent, Error, AiContext.Service> = Effect.gen(function* () {
+  const agents = yield* Function.pipe(AiContext.Service.findObjects(Agent));
+  if (agents.length !== 1) {
+    return yield* Effect.fail(new Error(`There should be exactly one agent in context. Got: ${agents.length}`));
+  }
+
+  const agent = agents[0];
+  return agent;
+});

package/src/types/Chat.ts

@@ -15,6 +15,7 @@ import { FormInputAnnotation, LabelAnnotation } from '@dxos/echo/internal';
 export const Chat = Schema.Struct({
   name: Schema.String.pipe(Schema.optional),
   feed: Ref.Ref(Feed.Feed).pipe(FormInputAnnotation.set(false)),
+  view: Schema.String.pipe(Schema.optional),
 }).pipe(
   Type.object({
     typename: 'org.dxos.type.assistant.chat',
@@ -22,7 +23,7 @@ export const Chat = Schema.Struct({
   }),
   LabelAnnotation.set(['name']),
   Annotation.IconAnnotation.set({
-    icon: 'ph--atom--regular',
+    icon: 'ph--sparkle--regular',
     hue: 'sky',
   }),
 );

package/src/types/McpServer.ts

@@ -0,0 +1,37 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+// @import-as-namespace
+
+import * as Schema from 'effect/Schema';
+
+import { McpServer as McpServerSpec } from '@dxos/compute';
+import { Annotation, Type } from '@dxos/echo';
+import { LabelAnnotation } from '@dxos/echo/internal';
+
+/**
+ * MCP server configuration stored as a space-level ECHO object.
+ *
+ * Composes the canonical connection spec from `@dxos/compute` (`url`, `protocol`, `apiKey`)
+ * and adds instance-level fields (`name`, `enabled`) plus ECHO annotations.
+ *
+ * NOTE: `apiKey` is stored in plaintext and replicated to all peers with access to the space.
+ * A future iteration should move secrets to per-device credential storage or use envelope encryption.
+ */
+export const McpServer = Schema.Struct({
+  ...McpServerSpec.McpServer.fields,
+  enabled: Schema.optional(Schema.Boolean),
+}).pipe(
+  Type.object({
+    typename: 'org.dxos.type.assistant.mcpServer',
+    version: '0.1.0',
+  }),
+  LabelAnnotation.set(['name']),
+  Annotation.IconAnnotation.set({
+    icon: 'ph--plugs-connected--regular',
+    hue: 'sky',
+  }),
+);
+
+export interface McpServer extends Schema.Schema.Type<typeof McpServer> {}

package/src/types/Memory.ts

@@ -13,11 +13,12 @@ export const Memory = Schema.Struct({
   title: Schema.String,
   content: Schema.String,
 }).pipe(
-  Type.object({ typename: 'dxos.org/type/Memory', version: '0.1.0' }),
+  Type.object({ typename: 'org.dxos.type.memory', version: '0.1.0' }),
   Annotation.LabelAnnotation.set(['title']),
   Annotation.IconAnnotation.set({
     icon: 'ph--brain--regular',
     hue: 'pink',
   }),
 );
+
 export interface Memory extends Schema.Schema.Type<typeof Memory> {}

package/src/types/Plan.ts

@@ -37,6 +37,7 @@ export const Task = Schema.Struct({
    */
   chat: Schema.optional(Ref.Ref(Chat.Chat)),
 });
+
 export interface Task extends Schema.Schema.Type<typeof Task> {}
 
 /**
@@ -72,7 +73,7 @@ export const generateTaskId = (plan: Plan): TaskId => {
 
 /**
  * Add new tasks to a plan, generating IDs for new tasks.
- * Use inside an `Obj.change` callback.
+ * Use inside an `Obj.update` callback.
  */
 export const addTasks = (
   plan: Obj.Mutable<Plan>,
@@ -94,7 +95,7 @@ interface MakePlanProps {
 
 export const makePlan = (props: MakePlanProps): Plan => {
   const plan = Obj.make(Plan, { tasks: [] });
-  Obj.change(plan, (plan) => {
+  Obj.update(plan, (plan) => {
     addTasks(plan, props.tasks);
   });
   return plan;

package/src/types/index.ts

@@ -3,6 +3,7 @@
 //
 
 export * as Chat from './Chat';
-export * as Project from './Project';
+export * as Agent from './Agent';
+export * as McpServer from './McpServer';
 export * as Plan from './Plan';
 export * as Memory from './Memory';

package/dist/lib/neutral/add-artifact-W2CRMEAZ.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/blueprints/project/functions/add-artifact.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { Database, Obj } from '@dxos/echo';\nimport { Operation } from '@dxos/operation';\n\nimport { Project } from '../../../types';\nimport { AddArtifact } from './definitions';\n\nexport default AddArtifact.pipe(\n  Operation.withHandler(\n    Effect.fnUntraced(function* ({ name, artifact }) {\n      if (!(yield* Database.load(artifact))) {\n        throw new Error('Artifact not found.');\n      }\n\n      const project = yield* Project.getFromChatContext;\n\n      Obj.change(project, (project) => {\n        project.artifacts.push({\n          name,\n          data: artifact,\n        });\n      });\n    }) as any,\n  ),\n);\n"],
-  "mappings": ";;;;;;;;;;;AAIA,YAAYA,YAAY;AAExB,SAASC,UAAUC,WAAW;AAC9B,SAASC,iBAAiB;AAK1B,IAAA,uBAAeC,YAAYC,KACzBC,UAAUC,YACDC,kBAAW,WAAW,EAAEC,MAAMC,SAAQ,GAAE;AAC7C,MAAI,EAAE,OAAOC,SAASC,KAAKF,QAAAA,IAAY;AACrC,UAAM,IAAIG,MAAM,qBAAA;EAClB;AAEA,QAAMC,UAAU,OAAOC,gBAAQC;AAE/BC,MAAIC,OAAOJ,SAAS,CAACA,aAAAA;AACnBA,IAAAA,SAAQK,UAAUC,KAAK;MACrBX;MACAY,MAAMX;IACR,CAAA;EACF,CAAA;AACF,CAAA,CAAA,CAAA;",
-  "names": ["Effect", "Database", "Obj", "Operation", "AddArtifact", "pipe", "Operation", "withHandler", "fnUntraced", "name", "artifact", "Database", "load", "Error", "project", "Project", "getFromChatContext", "Obj", "change", "artifacts", "push", "data"]
-}