@dxos/assistant 0.8.1-main.ba2dec9 → 0.8.1-staging.5be625a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/assistant",
-  "version": "0.8.1-main.ba2dec9",
+  "version": "0.8.1-staging.5be625a",
   "description": "Natural language interface to DXOS",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -40,18 +40,18 @@
     "parjs": "^1.3.9",
     "parsimmon": "^1.18.1",
     "ulidx": "^2.3.0",
-    "@dxos/context": "0.8.1-main.ba2dec9",
-    "@dxos/artifact": "0.8.1-main.ba2dec9",
-    "@dxos/async": "0.8.1-main.ba2dec9",
-    "@dxos/debug": "0.8.1-main.ba2dec9",
-    "@dxos/echo-db": "0.8.1-main.ba2dec9",
-    "@dxos/echo-schema": "0.8.1-main.ba2dec9",
-    "@dxos/invariant": "0.8.1-main.ba2dec9",
-    "@dxos/live-object": "0.8.1-main.ba2dec9",
-    "@dxos/keys": "0.8.1-main.ba2dec9",
-    "@dxos/log": "0.8.1-main.ba2dec9",
-    "@dxos/util": "0.8.1-main.ba2dec9",
-    "@dxos/node-std": "0.8.1-main.ba2dec9"
+    "@dxos/artifact": "0.8.1-staging.5be625a",
+    "@dxos/async": "0.8.1-staging.5be625a",
+    "@dxos/debug": "0.8.1-staging.5be625a",
+    "@dxos/echo-db": "0.8.1-staging.5be625a",
+    "@dxos/echo-schema": "0.8.1-staging.5be625a",
+    "@dxos/context": "0.8.1-staging.5be625a",
+    "@dxos/keys": "0.8.1-staging.5be625a",
+    "@dxos/invariant": "0.8.1-staging.5be625a",
+    "@dxos/live-object": "0.8.1-staging.5be625a",
+    "@dxos/util": "0.8.1-staging.5be625a",
+    "@dxos/log": "0.8.1-staging.5be625a",
+    "@dxos/node-std": "0.8.1-staging.5be625a"
   },
   "devDependencies": {
     "@types/parsimmon": "^1.10.9",

package/src/ai-service/client.test.ts

@@ -11,12 +11,12 @@ import { invariant } from '@dxos/invariant';
 import { SpaceId } from '@dxos/keys';
 import { log } from '@dxos/log';
 
-import { DEFAULT_LLM_MODEL } from './defs';
+import { DEFAULT_EDGE_MODEL } from './defs';
 import { AIServiceEdgeClient } from './edge-client';
 import { OllamaClient } from './ollama-client';
 import { MixedStreamParser } from './parser';
 import { ToolTypes } from './types';
-import { AI_SERVICE_ENDPOINT } from '../testing';
+import { createTestOllamaClient, AI_SERVICE_ENDPOINT } from '../testing';
 
 // log.config({ filter: 'debug' });
 
@@ -40,7 +40,7 @@ describe.skip('AI Service Client', () => {
     ]);
 
     const stream = await client.exec({
-      model: DEFAULT_LLM_MODEL,
+      model: DEFAULT_EDGE_MODEL,
       spaceId,
       threadId,
       systemPrompt: 'You are a poet',
@@ -85,7 +85,7 @@ describe.skip('AI Service Client', () => {
 
     {
       const stream1 = await client.exec({
-        model: DEFAULT_LLM_MODEL,
+        model: DEFAULT_EDGE_MODEL,
         spaceId,
         threadId,
         systemPrompt: 'You are a helpful assistant.',
@@ -119,7 +119,7 @@ describe.skip('AI Service Client', () => {
 
     {
       const stream2 = await client.exec({
-        model: DEFAULT_LLM_MODEL,
+        model: DEFAULT_EDGE_MODEL,
         spaceId,
         threadId,
         systemPrompt: 'You are a helpful assistant.',
@@ -157,7 +157,7 @@ describe.skip('AI Service Client', () => {
     ]);
 
     const stream = await client.exec({
-      model: DEFAULT_LLM_MODEL,
+      model: DEFAULT_EDGE_MODEL,
       spaceId,
       threadId,
       tools: [
@@ -179,14 +179,14 @@ describe.skip('AI Service Client', () => {
   });
 });
 
-describe('Ollama Client', () => {
+describe.skip('Ollama Client', () => {
   test('basic', async (ctx) => {
     const isRunning = await OllamaClient.isRunning();
     if (!isRunning) {
       ctx.skip();
     }
 
-    const client = OllamaClient.createClient();
+    const client = createTestOllamaClient();
     const parser = new MixedStreamParser();
 
     const messages = await parser.parse(
@@ -207,7 +207,7 @@ describe('Ollama Client', () => {
       ctx.skip();
     }
 
-    const client = OllamaClient.createClient({
+    const client = createTestOllamaClient({
       tools: [
         defineTool('test', {
           name: 'encrypt',
@@ -242,7 +242,7 @@ describe('Ollama Client', () => {
       ctx.skip();
     }
 
-    const client = OllamaClient.createClient();
+    const client = createTestOllamaClient();
     const parser = new MixedStreamParser();
 
     const messages = await parser.parse(

package/src/ai-service/defs.ts

@@ -5,9 +5,9 @@
 // TODO(burdon): Share with Edge.
 // TODO(burdon): Move to service config retrieved by HTTP?
 
-export const DEFAULT_LLM_MODEL = '@anthropic/claude-3-5-sonnet-20241022';
+export const DEFAULT_EDGE_MODEL = '@anthropic/claude-3-5-sonnet-20241022';
 
-export const DEFAULT_LLM_MODELS = [
+export const DEFAULT_EDGE_MODELS = [
   // AI Gateway.
   // https://developers.cloudflare.com/ai-gateway
   '@anthropic/claude-3-5-haiku-20241022',
@@ -21,4 +21,19 @@ export const DEFAULT_LLM_MODELS = [
   '@ollama/llama-3-1-nemotron-70b-instruct',
   '@ollama/llama-3-1-nemotron-mini-4b-instruct',
   '@ollama/llama-3-2-3b',
-];
+] as const;
+
+// TODO(burdon): Config.
+export const DEFAULT_OLLAMA_ENDPOINT = 'http://localhost:11434';
+
+export const DEFAULT_OLLAMA_MODEL = 'llama3.2:1b';
+
+/**
+ * https://ollama.com/library
+ */
+export const DEFAULT_OLLAMA_MODELS = [
+  //
+  'llama3.2:1b',
+  'llama3:70b',
+  'deepseek-r1:latest',
+] as const;

package/src/ai-service/edge-client.ts

@@ -5,7 +5,7 @@
 import { Schema as S } from 'effect';
 
 import { Message } from '@dxos/artifact';
-import { invariant } from '@dxos/invariant';
+import { assertArgument, invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 
 import type { AIServiceClient, GenerationStream } from './service';
@@ -47,7 +47,8 @@ export class AIServiceEdgeClient implements AIServiceClient {
    * Process request and open message stream.
    */
   async exec(request: GenerateRequest): Promise<GenerationStream> {
-    log.info('requesting', { endpoint: this._endpoint });
+    assertArgument(typeof request.model === 'string', 'model is required');
+    log('requesting', { endpoint: this._endpoint });
     const controller = new AbortController();
     const response = await fetch(`${this._endpoint}/generate`, {
       signal: controller.signal,

package/src/ai-service/ollama-client.ts

@@ -2,21 +2,20 @@
 // Copyright 2025 DXOS.org
 //
 
+import { Schema as S } from 'effect';
+
 import { type MessageContentBlock, defineTool, type Tool, ToolResult } from '@dxos/artifact';
-import { ObjectId, S } from '@dxos/echo-schema';
+import { ObjectId } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 
+import { DEFAULT_OLLAMA_ENDPOINT } from './defs';
 import { MessageCollector, emitMessageAsEvents } from './message-collector';
 import { type AIServiceClient, type GenerationStream } from './service';
 import { GenerationStreamImpl } from './stream';
 import { ToolTypes, type GenerateRequest, type GenerationStreamEvent } from './types';
 import { isToolUse, runTools } from '../conversation';
 
-// TODO(burdon): Config.
-const DEFAULT_OLLAMA_URL = 'http://localhost:11434';
-const DEFAULT_OLLAMA_MODEL = 'llama3.2:1b';
-
 export type OllamaClientParams = {
   endpoint?: string;
 
@@ -42,23 +41,13 @@ export type OllamaClientParams = {
 };
 
 export class OllamaClient implements AIServiceClient {
-  /**
-   * Create a test client with small local model and no temperature for predictable results.
-   */
-  static createClient(options?: Pick<OllamaClientParams, 'tools'>) {
-    return new OllamaClient({
-      tools: options?.tools,
-      overrides: { model: DEFAULT_OLLAMA_MODEL, temperature: 0 },
-    });
-  }
-
   /**
    * Check if Ollama server is running and accessible.
    * @returns Promise that resolves to true if Ollama is running, false otherwise.
    */
   static async isRunning(): Promise<boolean> {
     try {
-      const response = await fetch(`${DEFAULT_OLLAMA_URL}/api/version`, {
+      const response = await fetch(`${DEFAULT_OLLAMA_ENDPOINT}/api/version`, {
         method: 'GET',
         headers: {
           'Content-Type': 'application/json',
@@ -78,8 +67,8 @@ export class OllamaClient implements AIServiceClient {
   private readonly _temperatureOverride?: number;
   private readonly _maxToolInvocations: number;
 
-  constructor({ endpoint, tools, overrides, maxToolInvocations }: OllamaClientParams) {
-    this._endpoint = endpoint ?? DEFAULT_OLLAMA_URL;
+  constructor({ endpoint, tools, overrides, maxToolInvocations }: OllamaClientParams = {}) {
+    this._endpoint = endpoint ?? DEFAULT_OLLAMA_ENDPOINT;
     this._tools = tools ?? [];
     this._modelOverride = overrides?.model;
     this._temperatureOverride = overrides?.temperature;
@@ -104,7 +93,7 @@ export class OllamaClient implements AIServiceClient {
       messages: [],
       stream: true,
       options: {
-        temperature: this._temperatureOverride ?? 0.7,
+        temperature: this._temperatureOverride,
       },
     };
 
@@ -201,10 +190,9 @@ export class OllamaClient implements AIServiceClient {
       signal,
     });
 
-    // log.info('ollama response', { response: await response.text() });
-
+    // TODO(burdon): Test if model is not found.
     if (!response.ok) {
-      throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
+      throw await parseErrorResponse(response);
     }
 
     if (!response.body) {
@@ -253,7 +241,7 @@ export class OllamaClient implements AIServiceClient {
           break;
         }
 
-        log.info('ollama data', { data });
+        log('ollama data', { data });
 
         // Ollama sends chunks of text, we convert them to our event format.
         if (data.message?.content) {
@@ -471,3 +459,41 @@ class OllamaDecoderStream extends TransformStream<string, OllamaResponseData> {
     });
   }
 }
+
+class ModelDoesNotSupportToolsError extends S.TaggedError<ModelDoesNotSupportToolsError>()(
+  'ModelDoesNotSupportToolsError',
+  {
+    model: S.String,
+  },
+) {}
+
+class ModelNotFoundError extends S.TaggedError<ModelNotFoundError>()('ModelNotFoundError', {
+  model: S.String,
+}) {}
+
+const parseOllamaError = (error: string): Error => {
+  {
+    const match = error.match(/^([^']+) does not support tools$/);
+    if (match) {
+      return new ModelDoesNotSupportToolsError({ model: match[1] });
+    }
+  }
+
+  {
+    const match = error.match(/^model "([^"]+)" not found, try pulling it first$/);
+    if (match) {
+      return new ModelNotFoundError({ model: match[1] });
+    }
+  }
+
+  throw new Error(`Ollama API error: ${error}`);
+};
+
+const parseErrorResponse = async (response: Response): Promise<Error> => {
+  if (response.headers.get('content-type')?.includes('application/json')) {
+    const body = await response.json();
+    return parseOllamaError(body.error);
+  }
+
+  throw new Error(`Ollama API error: ${response.status} ${response.statusText} ${await response.text()}`);
+};

package/src/ai-service/parser.ts

@@ -80,6 +80,7 @@ export class MixedStreamParser {
     const messagesCollected: Message[] = [];
 
     for await (const event of stream) {
+      log('streamEvent', { event });
       this.streamEvent.emit(event);
 
       // log.info('event', { type: event.type, event });

package/src/ai-service/types.ts

@@ -7,11 +7,11 @@ import { Schema as S } from 'effect';
 import { Tool, Message, type MessageContentBlock, SpaceIdSchema } from '@dxos/artifact';
 import { ObjectId } from '@dxos/echo-schema';
 
-import { DEFAULT_LLM_MODELS } from './defs';
+import { DEFAULT_EDGE_MODELS, DEFAULT_OLLAMA_MODELS } from './defs';
 
 export const createArtifactElement = (id: ObjectId) => `<artifact id=${id} />`;
 
-export const LLMModel = S.Literal(...DEFAULT_LLM_MODELS);
+export const LLMModel = S.Literal(...DEFAULT_EDGE_MODELS, ...DEFAULT_OLLAMA_MODELS);
 
 export type LLMModel = S.Schema.Type<typeof LLMModel>;
 

package/src/bin/chat.ts

@@ -10,7 +10,7 @@ import { ObjectId } from '@dxos/echo-schema';
 import { SpaceId } from '@dxos/keys';
 import { log } from '@dxos/log';
 
-import { AIServiceEdgeClient, ToolTypes, DEFAULT_LLM_MODEL } from '../ai-service';
+import { AIServiceEdgeClient, ToolTypes, DEFAULT_EDGE_MODEL } from '../ai-service';
 import { runLLM } from '../conversation';
 import {
   AI_SERVICE_ENDPOINT,
@@ -49,7 +49,7 @@ while (true) {
   await client.appendMessages([createUserMessage(spaceId, threadId, prompt.message)]);
 
   await runLLM({
-    model: DEFAULT_LLM_MODEL,
+    model: DEFAULT_EDGE_MODEL,
     spaceId,
     threadId,
     system: createSystemPrompt(schemaTypes),

package/src/conversation/conversation.test.ts

@@ -11,7 +11,7 @@ import { SpaceId } from '@dxos/keys';
 import { log } from '@dxos/log';
 
 import { runLLM, type ConversationEvent } from './conversation';
-import { AIServiceEdgeClient, DEFAULT_LLM_MODEL } from '../ai-service';
+import { AIServiceEdgeClient, DEFAULT_EDGE_MODEL } from '../ai-service';
 import { AI_SERVICE_ENDPOINT } from '../testing';
 
 // TODO(burdon): Local live LLM test.
@@ -25,7 +25,7 @@ describe.skip('Conversation tests', () => {
     const threadId = ObjectId.random();
 
     const result = await runLLM({
-      model: DEFAULT_LLM_MODEL,
+      model: DEFAULT_EDGE_MODEL,
       history: [createUserMessage(spaceId, threadId, 'Hello, how are you?')],
       tools: [],
       client,
@@ -56,7 +56,7 @@ describe.skip('Conversation tests', () => {
     const threadId = ObjectId.random();
 
     const result = await runLLM({
-      model: DEFAULT_LLM_MODEL,
+      model: DEFAULT_EDGE_MODEL,
       history: [createUserMessage(spaceId, threadId, 'What is the password? Ask the custodian.')],
       tools: [custodian],
       client,

package/src/index.ts

@@ -5,3 +5,4 @@
 export * from './ai-service';
 export * from './cypher';
 export * from './conversation';
+export * from './session';

package/src/session/index.ts

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

package/src/session/session.test.ts

@@ -0,0 +1,256 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Schema as S } from 'effect';
+import { inspect } from 'node:util';
+import { describe, test } from 'vitest';
+
+import {
+  ArtifactId,
+  defineArtifact,
+  defineTool,
+  ToolResult,
+  type Message,
+  type MessageContentBlock,
+} from '@dxos/artifact';
+import { AIServiceEdgeClient } from '@dxos/assistant';
+import { createStatic, EchoObject, ObjectId } from '@dxos/echo-schema';
+import { DXN } from '@dxos/keys';
+import { log } from '@dxos/log';
+
+import { AISession } from './session';
+import { AI_SERVICE_ENDPOINT } from '../testing';
+
+// Define a calendar event artifact schema
+const CalendarEventSchema = S.Struct({
+  title: S.String,
+  startTime: S.String,
+  endTime: S.String,
+  description: S.String,
+}).pipe(EchoObject('example.com/type/CalendarEvent', '0.1.0'));
+
+type CalendarEvent = S.Schema.Type<typeof CalendarEventSchema>;
+
+describe('AISession with Ollama', () => {
+  test('create calendar itinerary', { timeout: 60_000 }, async () => {
+    const aiClient = new AIServiceEdgeClient({ endpoint: AI_SERVICE_ENDPOINT.REMOTE });
+    // const aiClient = new OllamaClient({
+    //   overrides: { model: 'llama3.1:8b' },
+    // });
+    const session = new AISession({ operationModel: 'immediate' });
+
+    const objects = new Set<string>();
+
+    // Define calendar artifact
+    const calendarArtifact = defineArtifact({
+      id: 'artifact:dxos.org/plugin/calendar',
+      name: 'Calendar',
+      instructions: 'Use this to create and query calendar events.',
+      schema: CalendarEventSchema,
+      tools: [
+        defineTool('calendar', {
+          name: 'query',
+          description: 'Query the calendar for events',
+          schema: S.Struct({}),
+          execute: async () => {
+            return ToolResult.Success(CALENDAR_EVENTS);
+          },
+        }),
+      ],
+    });
+
+    const tableArtifact = defineArtifact({
+      id: 'artifact:dxos.org/plugin/table',
+      name: 'Table',
+      instructions: 'Use this to create and manage tables. Each table has a unique id.',
+      schema: S.Struct({}),
+      tools: [
+        defineTool('table', {
+          name: 'create',
+          description: 'Create a table',
+          schema: S.Struct({
+            data: S.Array(S.Any).annotations({ description: 'Array of data payloads to add as rows' }),
+          }),
+          execute: async ({ data }) => {
+            log.info('create table', { data });
+            const id = DXN.fromLocalObjectId(ObjectId.random()).toString();
+            objects.add(id);
+            // TODO(dmaretskyi): consider xml for refs instead of @dxn:echo:@:XXXXX
+            return ToolResult.Success(`table @${id}`);
+          },
+        }),
+      ],
+    });
+
+    const mapArtifact = defineArtifact({
+      id: 'artifact:dxos.org/plugin/map',
+      name: 'Map',
+      instructions:
+        'Use this to create and manage maps. Maps source data from tables. Table id is required to create a map.',
+      schema: S.Struct({}),
+      tools: [
+        defineTool('map', {
+          name: 'create',
+          description: 'Create a map',
+          schema: S.Struct({
+            source: ArtifactId.annotations({
+              description: 'The table that will be used as the source of the map',
+            }),
+          }),
+          execute: async ({ source }) => {
+            // TODO(dmaretskyi): Use effect-schema decode instead of manual parsing.
+            const sourceId = ArtifactId.toDXN(source);
+            if (!objects.has(sourceId.toString())) {
+              return ToolResult.Error(`table id=${source} not found`);
+            }
+            log.info('create map', { sourceId });
+            const id = DXN.fromLocalObjectId(ObjectId.random()).toString();
+            objects.add(id);
+            // TODO(dmaretskyi): consider xml for refs instead of @dxn:echo:@:XXXXX
+            return ToolResult.Success(`map @${id}`);
+          },
+        }),
+      ],
+    });
+
+    const scriptArtifact = defineArtifact({
+      id: 'artifact:dxos.org/plugin/script',
+      name: 'Script',
+      instructions: 'Use this to create and manage scripts',
+      schema: S.Struct({}),
+      tools: [],
+    });
+
+    // session.streamEvent.on((event) => {
+    //   printStreamEvent(event);
+    // });
+
+    session.message.on(printMessage);
+    session.userMessage.on(printMessage);
+    session.block.on(printContentBlock);
+
+    // session.update.on((update) => {
+    //   log.info('update', { update });
+    // });
+
+    // Test creating an itinerary
+    const response = await session.run({
+      client: aiClient,
+      tools: [],
+      artifacts: [calendarArtifact, tableArtifact, mapArtifact, scriptArtifact],
+      history: [],
+      generationOptions: {
+        model: '@anthropic/claude-3-5-haiku-20241022',
+      },
+      prompt: 'create a table and map for a travel itinerary based on events in my calendar',
+    });
+
+    log.info('result', {
+      objects,
+      finalMessage: response.at(-1),
+    });
+  });
+});
+
+// Travel to rome, florence, livorno, siena, madrid for conferences
+const CALENDAR_EVENTS: CalendarEvent[] = [
+  createStatic(CalendarEventSchema, {
+    title: 'Exploring Ancient Ruins in Rome',
+    startTime: '2024-01-01T10:00:00Z',
+    endTime: '2024-01-01T11:00:00Z',
+    description: 'Tech conference at the historic Colosseum with networking opportunities',
+  }),
+  createStatic(CalendarEventSchema, {
+    title: 'Renaissance Tech Summit in Florence',
+    startTime: '2024-01-01T11:00:00Z',
+    endTime: '2024-01-01T12:00:00Z',
+    description: 'Discussing AI innovations surrounded by Renaissance art',
+  }),
+  createStatic(CalendarEventSchema, {
+    title: 'Travel to Livorno',
+    startTime: '2024-01-01T12:00:00Z',
+    endTime: '2024-01-01T13:00:00Z',
+    description: 'Travel to Livorno',
+  }),
+  createStatic(CalendarEventSchema, {
+    title: 'Travel to Siena',
+    startTime: '2024-01-01T13:00:00Z',
+    endTime: '2024-01-01T14:00:00Z',
+    description: 'Travel to Siena',
+  }),
+  createStatic(CalendarEventSchema, {
+    title: 'Travel to Madrid',
+    startTime: '2024-01-01T14:00:00Z',
+    endTime: '2024-01-01T15:00:00Z',
+    description: 'Travel to Madrid',
+  }),
+];
+
+const printMessage = (message: Message) => {
+  console.log(`${message.role.toUpperCase()}\n`);
+  for (const content of message.content) {
+    printContentBlock(content);
+  }
+};
+
+const printContentBlock = (content: MessageContentBlock) => {
+  switch (content.type) {
+    case 'text':
+      console.log(content.text);
+      break;
+    case 'tool_use':
+      console.log(`⚙️ [Tool Use] ${content.name} ${inspect(content.input, { depth: null, colors: true })}`);
+      break;
+    case 'tool_result': {
+      let data: any;
+      try {
+        data = JSON.parse(content.content);
+      } catch {
+        data = content.content;
+      }
+      console.log(`⚙️ [Tool Result] ${content.toolUseId} ${inspect(data, { depth: null, colors: true })}`);
+      break;
+    }
+  }
+};
+
+// const printStreamEvent = (event: GenerationStreamEvent) => {
+//   switch (event.type) {
+//     case 'message_start': {
+//       process.stdout.write(`${event.message.role.toUpperCase()}\n\n`);
+//       for (const content of event.message.content) {
+//         printContentBlock(content);
+//       }
+//       break;
+//     }
+//     case 'content_block_start': {
+//       printContentBlock(event.content);
+//       break;
+//     }
+//     case 'content_block_delta': {
+//       switch (event.delta.type) {
+//         case 'text_delta': {
+//           process.stdout.write(event.delta.text);
+//           break;
+//         }
+//         case 'input_json_delta': {
+//           process.stdout.write(event.delta.partial_json);
+//           break;
+//         }
+//       }
+//       break;
+//     }
+//     case 'content_block_stop': {
+//       process.stdout.write('\n');
+//       break;
+//     }
+//     case 'message_delta': {
+//       break;
+//     }
+//     case 'message_stop': {
+//       process.stdout.write('\n\n');
+//       break;
+//     }
+//   }
+// };