@dxos/assistant 0.8.2-main.fbd8ed0 → 0.8.2-staging.7ac8446

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

@@ -2,12 +2,15 @@
 // Copyright 2024 DXOS.org
 //
 
+import { Schema as S } from 'effect';
+
+import { Message } from '@dxos/artifact';
 import { assertArgument, invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 
 import type { AIServiceClient, GenerationStream } from './service';
 import { createGenerationStream } from './stream';
-import { type GenerateRequest, type GenerateResponse } from './types';
+import { type GenerateRequest } from './types';
 
 export type AIServiceEdgeClientOptions = {
   endpoint: string;
@@ -22,16 +25,28 @@ export class AIServiceEdgeClient implements AIServiceClient {
   }
 
   /**
-   * Generate non-streaming response.
+   * @deprecated
    */
-  async exec(request: GenerateRequest): Promise<GenerateResponse> {
-    throw new Error('Not implemented');
+  // TODO(burdon): Remove.
+  async appendMessages(messages: Message[]): Promise<void> {
+    const url = `${this._endpoint}/message`;
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        messages: await S.encodePromise(S.Array(Message))(messages),
+      }),
+    });
+
+    if (!res.ok) {
+      throw new Error(`${await res.text()} [${url}]`);
+    }
   }
 
   /**
    * Process request and open message stream.
    */
-  async execStream(request: GenerateRequest): Promise<GenerationStream> {
+  async exec(request: GenerateRequest): Promise<GenerationStream> {
     assertArgument(typeof request.model === 'string', 'model is required');
     log('requesting', { endpoint: this._endpoint });
     const controller = new AbortController();
@@ -46,15 +61,7 @@ export class AIServiceEdgeClient implements AIServiceClient {
       }),
     });
 
-    if (!response.ok) {
-      throw await parseErrorResponse(response);
-    }
-
     invariant(response.body instanceof ReadableStream);
     return createGenerationStream(response, controller);
   }
 }
-
-const parseErrorResponse = async (response: Response): Promise<Error> => {
-  throw new Error(`AI Service error: ${response.status} ${response.statusText} ${await response.text()}`);
-};

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

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
+import { Schema as S } from 'effect';
 
 import { type MessageContentBlock, defineTool, type Tool, ToolResult } from '@dxos/artifact';
 import { ObjectId } from '@dxos/echo-schema';
@@ -13,8 +13,8 @@ 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 GenerateResponse, type GenerationStreamEvent } from './types';
-import { isToolUse, runTools } from '../session';
+import { ToolTypes, type GenerateRequest, type GenerationStreamEvent } from './types';
+import { isToolUse, runTools } from '../conversation';
 
 export type OllamaClientParams = {
   endpoint?: string;
@@ -300,14 +300,7 @@ export class OllamaClient implements AIServiceClient {
     }
   }
 
-  /**
-   * Generate non-streaming response.
-   */
-  async exec(request: GenerateRequest): Promise<GenerateResponse> {
-    throw new Error('Not implemented');
-  }
-
-  async execStream(request: GenerateRequest): Promise<GenerationStream> {
+  async exec(request: GenerateRequest): Promise<GenerationStream> {
     const controller = new AbortController();
 
     try {
@@ -388,8 +381,8 @@ const WELL_KNOWN_TOOLS: Record<string, Tool> = {
   [ToolTypes.TextToImage]: defineTool('system', {
     name: 'text-to-image',
     description: 'Generate an image from a text prompt',
-    schema: Schema.Struct({
-      prompt: Schema.String.annotations({ description: 'The text prompt describing the image to generate' }),
+    schema: S.Struct({
+      prompt: S.String.annotations({ description: 'The text prompt describing the image to generate' }),
     }),
     execute: async ({ prompt }) => {
       const image = await fetch(SAMPLE_IMAGE_URL).then(async (res) => Buffer.from(await res.arrayBuffer()));
@@ -467,15 +460,15 @@ class OllamaDecoderStream extends TransformStream<string, OllamaResponseData> {
   }
 }
 
-class ModelDoesNotSupportToolsError extends Schema.TaggedError<ModelDoesNotSupportToolsError>()(
+class ModelDoesNotSupportToolsError extends S.TaggedError<ModelDoesNotSupportToolsError>()(
   'ModelDoesNotSupportToolsError',
   {
-    model: Schema.String,
+    model: S.String,
   },
 ) {}
 
-class ModelNotFoundError extends Schema.TaggedError<ModelNotFoundError>()('ModelNotFoundError', {
-  model: Schema.String,
+class ModelNotFoundError extends S.TaggedError<ModelNotFoundError>()('ModelNotFoundError', {
+  model: S.String,
 }) {}
 
 const parseOllamaError = (error: string): Error => {

package/src/ai-service/parser.ts

@@ -4,7 +4,7 @@
 
 import { Message, type MessageContentBlock } from '@dxos/artifact';
 import { Event } from '@dxos/async';
-import { create } from '@dxos/echo-schema';
+import { createStatic } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 import { isNotFalsy, safeParseJson } from '@dxos/util';
@@ -94,7 +94,7 @@ export class MixedStreamParser {
             log.warn('unexpected message_start');
           }
 
-          this._message = create(Message, { role: event.message.role, content: [...event.message.content] });
+          this._message = createStatic(Message, { role: event.message.role, content: [...event.message.content] });
           this.message.emit(this._message);
           break;
         }
@@ -316,17 +316,6 @@ export const mergeMessageBlock = (
           break;
         }
 
-        case 'proposal': {
-          if (streamBlock.content.length === 1 && streamBlock.content[0].type === 'text') {
-            return {
-              type: 'json',
-              disposition: 'proposal',
-              json: JSON.stringify({ text: streamBlock.content[0].content }),
-            };
-          }
-          break;
-        }
-
         case 'select': {
           return {
             type: 'json',

package/src/ai-service/service.ts

@@ -2,29 +2,13 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type GenerateRequest, type GenerationStreamEvent, type GenerateResponse } from './types';
+import { type GenerateRequest, type GenerationStreamEvent } from './types';
 
-/**
- * Interface for AI service.
- * Generates chat completions, supports, history and tools.
- */
+// TODO(burdon): Create wrapper for edge/ollama. Create session?
 export interface AIServiceClient {
-  /**
-   * Generate chat completions, supports, history and tools.
-   * Generate non-streaming response.
-   */
-  exec(request: GenerateRequest): Promise<GenerateResponse>;
-
-  /**
-   * Generate chat completions, supports, history and tools.
-   * Process request and open message stream.
-   */
-  execStream(request: GenerateRequest): Promise<GenerationStream>;
+  exec(request: GenerateRequest): Promise<GenerationStream>;
 }
 
-/**
- * Streaming chat completion stream.
- */
 export interface GenerationStream extends AsyncIterable<GenerationStreamEvent> {
   abort(): void;
   complete(): Promise<void>;

package/src/ai-service/testing/mock.ts

@@ -7,7 +7,6 @@ import {
   type AIServiceClient,
   type GenerateRequest,
   createGenerationStream,
-  type GenerateResponse,
 } from '@dxos/assistant';
 
 import { createTestSSEStream } from './test-stream';
@@ -15,16 +14,9 @@ import { createTestSSEStream } from './test-stream';
 export class MockAIService implements AIServiceClient {
   constructor(private readonly _responses: string[]) {}
 
-  /**
-   * Generate non-streaming response.
-   */
-  async exec(request: GenerateRequest): Promise<GenerateResponse> {
-    throw new Error('Not implemented');
-  }
-
   // TODO(burdon): Match response to request.
   // TODO(burdon): See MockGpt (from conductor).
-  async execStream(request: GenerateRequest): Promise<GenerationStream> {
+  async exec(request: GenerateRequest): Promise<GenerationStream> {
     return createGenerationStream(new Response(createTestSSEStream(this._responses)));
   }
 }

package/src/ai-service/types.ts

@@ -2,18 +2,18 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
+import { Schema as S } from 'effect';
 
-import { Tool, Message, type MessageContentBlock } from '@dxos/artifact';
-import { type ObjectId } from '@dxos/echo-schema';
+import { Tool, Message, type MessageContentBlock, SpaceIdSchema } from '@dxos/artifact';
+import { ObjectId } from '@dxos/echo-schema';
 
 import { DEFAULT_EDGE_MODELS, DEFAULT_OLLAMA_MODELS } from './defs';
 
 export const createArtifactElement = (id: ObjectId) => `<artifact id=${id} />`;
 
-export const LLMModel = Schema.Literal(...DEFAULT_EDGE_MODELS, ...DEFAULT_OLLAMA_MODELS);
+export const LLMModel = S.Literal(...DEFAULT_EDGE_MODELS, ...DEFAULT_OLLAMA_MODELS);
 
-export type LLMModel = Schema.Schema.Type<typeof LLMModel>;
+export type LLMModel = S.Schema.Type<typeof LLMModel>;
 
 export const ToolTypes = Object.freeze({
   // TODO(dmaretskyi): Not implemented yet.
@@ -24,47 +24,38 @@ export const ToolTypes = Object.freeze({
 /**
  * Client GPT request.
  */
-export const GenerateRequest = Schema.Struct({
+export const GenerateRequest = S.Struct({
+  spaceId: S.optional(SpaceIdSchema),
+  threadId: S.optional(ObjectId),
+
   /**
    * Preferred model or system default.
    */
-  model: Schema.optional(LLMModel),
+  model: S.optional(LLMModel),
 
   /**
    * Tools available for the LLM.
    */
-  tools: Schema.optional(Schema.Array(Tool).pipe(Schema.mutable)),
+  tools: S.optional(S.Array(Tool).pipe(S.mutable)),
 
   /**
    * System instructions to the LLM.
    */
-  systemPrompt: Schema.optional(Schema.String),
+  systemPrompt: S.optional(S.String),
 
   /**
    * History of messages to include in the context window.
    */
   // TODO(burdon): Rename messages.
-  history: Schema.optional(Schema.Array(Message)),
+  history: S.optional(S.Array(Message)),
 
   /**
    * Current request.
    */
-  prompt: Schema.optional(Message),
+  prompt: S.optional(Message),
 });
-export type GenerateRequest = Schema.Schema.Type<typeof GenerateRequest>;
-
-/**
- * Non-streaming response.
- */
-export const GenerateResponse = Schema.Struct({
-  messages: Schema.Array(Message),
 
-  /**
-   * Number of tokens used in the response.
-   */
-  tokenCount: Schema.optional(Schema.Number),
-});
-export type GenerateResponse = Schema.Schema.Type<typeof GenerateResponse>;
+export type GenerateRequest = S.Schema.Type<typeof GenerateRequest>;
 
 /**
  * Server-Sent Events (SSE) stream from the AI service.

package/src/bin/chat.ts

@@ -11,7 +11,7 @@ import { SpaceId } from '@dxos/keys';
 import { log } from '@dxos/log';
 
 import { AIServiceEdgeClient, ToolTypes, DEFAULT_EDGE_MODEL } from '../ai-service';
-import { runLLM } from '../experimental';
+import { runLLM } from '../conversation';
 import {
   AI_SERVICE_ENDPOINT,
   createLogger,
@@ -19,7 +19,7 @@ import {
   createSystemPrompt,
   createTestData,
   Contact,
-  Organization,
+  Org,
   Project,
   Task,
 } from '../testing';
@@ -33,7 +33,7 @@ const dataSource = createTestData();
 
 const cypherTool = createCypherTool(dataSource);
 
-const schemaTypes = [Organization, Project, Task, Contact];
+const schemaTypes = [Org, Project, Task, Contact];
 
 const spaceId = SpaceId.random();
 const threadId = ObjectId.random();
@@ -46,6 +46,7 @@ while (true) {
       message: 'Enter a message:',
     },
   ]);
+  await client.appendMessages([createUserMessage(spaceId, threadId, prompt.message)]);
 
   await runLLM({
     model: DEFAULT_EDGE_MODEL,
@@ -60,7 +61,6 @@ while (true) {
       },
     ],
     client,
-    history: [createUserMessage(spaceId, threadId, prompt.message)],
     logger: createLogger({
       stream: true,
       filter: (e) => {

package/src/{experimental/conversation → conversation}/conversation.test.ts

@@ -2,7 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema } from 'effect';
+import { Schema as S } from 'effect';
 import { describe, test } from 'vitest';
 
 import { createUserMessage, defineTool, ToolResult } from '@dxos/artifact';
@@ -11,8 +11,8 @@ import { SpaceId } from '@dxos/keys';
 import { log } from '@dxos/log';
 
 import { runLLM, type ConversationEvent } from './conversation';
-import { AIServiceEdgeClient, DEFAULT_EDGE_MODEL } from '../../ai-service';
-import { AI_SERVICE_ENDPOINT } from '../../testing';
+import { AIServiceEdgeClient, DEFAULT_EDGE_MODEL } from '../ai-service';
+import { AI_SERVICE_ENDPOINT } from '../testing';
 
 // TODO(burdon): Local live LLM test.
 describe.skip('Conversation tests', () => {
@@ -40,8 +40,8 @@ describe.skip('Conversation tests', () => {
     const custodian = defineTool('testing', {
       name: 'custodian',
       description: 'Custodian can tell you the password if you say the magic word',
-      schema: Schema.Struct({
-        magicWord: Schema.String.annotations({ description: 'The magic word. Should be exactly "pretty please"' }),
+      schema: S.Struct({
+        magicWord: S.String.annotations({ description: 'The magic word. Should be exactly "pretty please"' }),
       }),
       execute: async ({ magicWord }) => {
         if (magicWord === 'pretty please') {

package/src/{experimental/conversation → conversation}/conversation.ts

@@ -2,13 +2,13 @@
 // Copyright 2024 DXOS.org
 //
 
-import { type Message, type Tool } from '@dxos/artifact';
-import { ObjectId } from '@dxos/echo-schema';
+import { type Tool, ToolResult, Message } from '@dxos/artifact';
+import { createStatic, ObjectId } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
 import { type SpaceId } from '@dxos/keys';
 import { log } from '@dxos/log';
 
-import { type AIServiceClient, type GenerationStreamEvent, type LLMModel } from '../../ai-service';
+import { type AIServiceClient, type GenerationStreamEvent, type LLMModel } from '../ai-service';
 
 export type CreateLLMConversationParams = {
   model: LLMModel;
@@ -43,8 +43,10 @@ export const runLLM = async (params: CreateLLMConversationParams) => {
   const generate = async () => {
     log('llm generate', { tools: params.tools });
     const beginTs = Date.now();
-    const stream = await params.client.execStream({
+    const stream = await params.client.exec({
       model: params.model,
+      spaceId: params.spaceId,
+      threadId: params.threadId,
       history,
       systemPrompt: params.system,
       tools: params.tools as any,
@@ -86,6 +88,8 @@ export const runLLM = async (params: CreateLLMConversationParams) => {
           log.warn('tool error', { message: toolResult.message });
           const resultMessage: Message = {
             id: ObjectId.random(),
+            spaceId: params.spaceId,
+            threadId: params.threadId,
             role: 'user',
             content: [
               {
@@ -106,6 +110,8 @@ export const runLLM = async (params: CreateLLMConversationParams) => {
           log('tool success', { result: toolResult.result });
           const resultMessage: Message = {
             id: ObjectId.random(),
+            spaceId: params.spaceId,
+            threadId: params.threadId,
             role: 'user',
             content: [
               {
@@ -140,3 +146,112 @@ export const runLLM = async (params: CreateLLMConversationParams) => {
     history,
   };
 };
+
+export const isToolUse = (message: Message, { onlyToolNames }: { onlyToolNames?: string[] } = {}) => {
+  const block = message.content.at(-1);
+  invariant(block);
+  return block.type === 'tool_use' && (!onlyToolNames || onlyToolNames.includes(block.name));
+};
+
+export type RunToolsOptions = {
+  message: Message;
+  tools: Tool[];
+  extensions?: ToolContextExtensions;
+};
+
+export type RunToolsResult =
+  | {
+      type: 'continue';
+      message: Message;
+    }
+  | {
+      type: 'break';
+      result: unknown;
+    };
+
+export const runTools = async ({ message, tools, extensions }: RunToolsOptions): Promise<RunToolsResult> => {
+  const toolCalls = message.content.filter((block) => block.type === 'tool_use');
+  invariant(toolCalls.length === 1);
+  const toolCall = toolCalls[0];
+  const tool = tools.find((tool) => tool.name === toolCall.name);
+  if (!tool) {
+    const resultMessage = createStatic(Message, {
+      role: 'user',
+      content: [
+        {
+          type: 'tool_result',
+          toolUseId: toolCall.id,
+          content: `Tool not found: ${toolCall.name}`,
+          isError: true,
+        },
+      ],
+    });
+
+    // TODO(burdon): Retry count?
+    return {
+      type: 'continue',
+      message: resultMessage,
+    };
+  }
+
+  let toolResult: ToolResult;
+  try {
+    invariant(tool.execute);
+    toolResult = await tool.execute(toolCall.input, { extensions });
+  } catch (error: any) {
+    log('tool error', { error });
+    toolResult = ToolResult.Error(error.message);
+  }
+
+  switch (toolResult.kind) {
+    case 'error': {
+      log('tool error', { message: toolResult.message });
+      const resultMessage = createStatic(Message, {
+        role: 'user',
+        content: [
+          {
+            type: 'tool_result',
+            toolUseId: toolCall.id,
+            content: toolResult.message,
+            isError: true,
+          },
+        ],
+      });
+
+      // TODO(burdon): Retry count?
+      return {
+        type: 'continue',
+        message: resultMessage,
+      };
+    }
+
+    case 'success': {
+      log('tool success', { result: toolResult.result });
+      const resultMessage = createStatic(Message, {
+        role: 'user',
+        content: [
+          {
+            type: 'tool_result',
+            toolUseId: toolCall.id,
+            content:
+              typeof toolResult.result === 'string' ? toolResult.result : JSON.stringify(toolResult.result) ?? '',
+          },
+          ...(toolResult.extractContentBlocks ?? []),
+        ],
+      });
+
+      return {
+        type: 'continue',
+        message: resultMessage,
+      };
+    }
+
+    case 'break': {
+      log('tool break', { result: toolResult.result });
+      return {
+        type: 'break',
+        result: toolResult.result,
+      };
+    }
+  }
+};

package/src/{experimental/conversation → conversation}/types.ts

@@ -2,14 +2,17 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema } from 'effect';
+import { Schema as S } from 'effect';
 
 import { type Message, type MessageContentBlock } from '@dxos/artifact';
 import { toJsonSchema, JsonSchemaType, ObjectId } from '@dxos/echo-schema';
+import type { SpaceId } from '@dxos/keys';
 import { log } from '@dxos/log';
 
-export const createUserMessage = (text: string): Message => ({
+export const createUserMessage = (spaceId: SpaceId, threadId: ObjectId, text: string): Message => ({
   id: ObjectId.random(),
+  spaceId,
+  threadId,
   role: 'user',
   content: [{ type: 'text', text }],
 });
@@ -17,11 +20,11 @@ export const createUserMessage = (text: string): Message => ({
 /**
  * @deprecated Use {@link LLMTool} instead.
  */
-export const ToolDefinition = Schema.Struct({
-  name: Schema.String,
-  description: Schema.String,
+export const ToolDefinition = S.Struct({
+  name: S.String,
+  description: S.String,
   parameters: JsonSchemaType,
-  execute: Schema.Any,
+  execute: S.Any,
 });
 
 /**
@@ -83,14 +86,14 @@ export const ToolResult = Object.freeze({
   Break: (result: unknown): ToolResult => ({ kind: 'break', result }),
 });
 
-export type DefineToolParams<Params extends Schema.Schema.AnyNoContext> = {
+export type DefineToolParams<Params extends S.Schema.AnyNoContext> = {
   name: string;
   description: string;
   schema: Params;
-  execute: (params: Schema.Schema.Type<Params>, context: ToolExecutionContext) => Promise<ToolResult>;
+  execute: (params: S.Schema.Type<Params>, context: ToolExecutionContext) => Promise<ToolResult>;
 };
 
-export const defineTool = <Params extends Schema.Schema.AnyNoContext>({
+export const defineTool = <Params extends S.Schema.AnyNoContext>({
   name,
   description,
   schema,
@@ -101,7 +104,7 @@ export const defineTool = <Params extends Schema.Schema.AnyNoContext>({
     description,
     parameters: toFunctionParameterSchema(schema),
     execute: (params, context) => {
-      const sanitized = Schema.decodeSync(schema)(params);
+      const sanitized = S.decodeSync(schema)(params);
       return execute(sanitized, context);
     },
   };
@@ -110,7 +113,7 @@ export const defineTool = <Params extends Schema.Schema.AnyNoContext>({
 /**
  * Adapts schems to be able to pass to AI providers.
  */
-const toFunctionParameterSchema = (schema: Schema.Schema.All) => {
+const toFunctionParameterSchema = (schema: S.Schema.All) => {
   const jsonSchema = toJsonSchema(schema);
   log('tool schema', { jsonSchema });
   delete jsonSchema.anyOf;

package/src/{experimental/cypher → cypher}/combinators.test.ts

@@ -77,7 +77,7 @@ describe('Cypher Combinators', () => {
   test('match clause', ({ expect }) => {
     testParser(matchClause, 'MATCH (n:Person)');
     testParser(matchClause, 'MATCH (n:Person)-[r:KNOWS]->(m:Person)');
-    testParser(matchClause, 'MATCH (o:Organization)-[:HAS_EMPLOYEE]->(e:Employee)');
+    testParser(matchClause, 'MATCH (o:Org)-[:HAS_EMPLOYEE]->(e:Employee)');
   });
 
   test('where clause', ({ expect }) => {
@@ -116,15 +116,15 @@ describe('Cypher Combinators', () => {
     );
     testParser(
       cypherQuery,
-      'MATCH (o:Organization)-[:HAS_EMPLOYEE]->(e:Employee)-[:WORKS_ON]->(p:Project) WHERE o.name = "DXOS" AND p.name = "Composer" RETURN e.name, e.id, p.name, p.id',
+      'MATCH (o:Org)-[:HAS_EMPLOYEE]->(e:Employee)-[:WORKS_ON]->(p:Project) WHERE o.name = "DXOS" AND p.name = "Composer" RETURN e.name, e.id, p.name, p.id',
     );
     testParser(
       cypherQuery,
-      'MATCH (n:Organization {name: "DXOS"})-[:HAS_EMPLOYEE]->(m:Employee)<-[:WORKS_ON]-(p:Project {name: "Composer"}) RETURN m.name AS employee',
+      'MATCH (n:Org {name: "DXOS"})-[:HAS_EMPLOYEE]->(m:Employee)<-[:WORKS_ON]-(p:Project {name: "Composer"}) RETURN m.name AS employee',
     );
     testParser(
       cypherQuery,
-      "MATCH (org:Organization {name: 'DXOS'})-[:ORG_EMPLOYEES]->(c:Contact)<-[:TASK_ASSIGNEE]-(t:Task)-[:TASK_PROJECT]->(p:Project {name: 'Composer'}) RETURN c.name",
+      "MATCH (org:Org {name: 'DXOS'})-[:ORG_EMPLOYEES]->(c:Contact)<-[:TASK_ASSIGNEE]-(t:Task)-[:TASK_PROJECT]->(p:Project {name: 'Composer'}) RETURN c.name",
     );
   });
 });