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

package/src/bin/chat.ts

@@ -1,79 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import inquirer from 'inquirer';
-import { writeFileSync } from 'node:fs';
-
-import { createUserMessage } from '@dxos/artifact';
-import { ObjectId } from '@dxos/echo-schema';
-import { SpaceId } from '@dxos/keys';
-import { log } from '@dxos/log';
-
-import { AIServiceEdgeClient, ToolTypes, DEFAULT_EDGE_MODEL } from '../ai-service';
-import { runLLM } from '../conversation';
-import {
-  AI_SERVICE_ENDPOINT,
-  createLogger,
-  createCypherTool,
-  createSystemPrompt,
-  createTestData,
-  Contact,
-  Org,
-  Project,
-  Task,
-} from '../testing';
-
-// TOOD(burdon): Get from config.
-const client = new AIServiceEdgeClient({
-  endpoint: AI_SERVICE_ENDPOINT.LOCAL,
-});
-
-const dataSource = createTestData();
-
-const cypherTool = createCypherTool(dataSource);
-
-const schemaTypes = [Org, Project, Task, Contact];
-
-const spaceId = SpaceId.random();
-const threadId = ObjectId.random();
-
-while (true) {
-  const prompt = await inquirer.prompt([
-    {
-      type: 'input',
-      name: 'message',
-      message: 'Enter a message:',
-    },
-  ]);
-  await client.appendMessages([createUserMessage(spaceId, threadId, prompt.message)]);
-
-  await runLLM({
-    model: DEFAULT_EDGE_MODEL,
-    spaceId,
-    threadId,
-    system: createSystemPrompt(schemaTypes),
-    tools: [
-      cypherTool,
-      {
-        name: 'text-to-image',
-        type: ToolTypes.TextToImage,
-      },
-    ],
-    client,
-    logger: createLogger({
-      stream: true,
-      filter: (e) => {
-        return true;
-      },
-      onImage: (img) => {
-        const path = `/tmp/image-${img.id}.jpeg`;
-        writeFileSync(path, Buffer.from(img.source.data, 'base64'));
-        log('Saved image', { path });
-        // Print image in iTerm using ANSI escape sequence
-        const imageData = img.source.data;
-        process.stdout.write('\x1b]1337;File=inline=1:' + imageData + '\x07');
-      },
-    }),
-  });
-}

package/src/conversation/conversation.test.ts

@@ -1,73 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { Schema as S } from 'effect';
-import { describe, test } from 'vitest';
-
-import { createUserMessage, defineTool, ToolResult } from '@dxos/artifact';
-import { ObjectId } from '@dxos/echo-schema';
-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';
-
-// TODO(burdon): Local live LLM test.
-describe.skip('Conversation tests', () => {
-  const client = new AIServiceEdgeClient({
-    endpoint: AI_SERVICE_ENDPOINT.LOCAL,
-  });
-
-  test('basic', async ({ expect }) => {
-    const spaceId = SpaceId.random();
-    const threadId = ObjectId.random();
-
-    const result = await runLLM({
-      model: DEFAULT_EDGE_MODEL,
-      history: [createUserMessage(spaceId, threadId, 'Hello, how are you?')],
-      tools: [],
-      client,
-      logger: messageLogger,
-    });
-
-    log('result', { result });
-    expect(result.history.length).to.equal(2);
-  });
-
-  test('tool call', async ({ expect }) => {
-    const custodian = defineTool('testing', {
-      name: 'custodian',
-      description: 'Custodian can tell you the password if you say the magic word',
-      schema: S.Struct({
-        magicWord: S.String.annotations({ description: 'The magic word. Should be exactly "pretty please"' }),
-      }),
-      execute: async ({ magicWord }) => {
-        if (magicWord === 'pretty please') {
-          return ToolResult.Success('The password is: "The sky is gray"');
-        } else {
-          return ToolResult.Error('Wrong magic word');
-        }
-      },
-    });
-
-    const spaceId = SpaceId.random();
-    const threadId = ObjectId.random();
-
-    const result = await runLLM({
-      model: DEFAULT_EDGE_MODEL,
-      history: [createUserMessage(spaceId, threadId, 'What is the password? Ask the custodian.')],
-      tools: [custodian],
-      client,
-      logger: messageLogger,
-    });
-    log('result', { result });
-  });
-
-  const messageLogger = (event: ConversationEvent) => {
-    if (event.type === 'message') {
-      log('message', { message: event.message });
-    }
-  };
-});

package/src/conversation/conversation.ts

@@ -1,257 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-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';
-
-export type CreateLLMConversationParams = {
-  model: LLMModel;
-
-  spaceId?: SpaceId;
-  threadId?: ObjectId;
-
-  /**
-   * System prompt that specifies instructions for the LLM.
-   */
-  system?: string;
-
-  tools: Tool[];
-  history?: Message[];
-  client: AIServiceClient;
-
-  logger?: (event: ConversationEvent) => void;
-};
-
-export type ConversationEvent =
-  | {
-      type: 'message';
-      message: Message;
-    }
-  | GenerationStreamEvent;
-
-// TODO(burdon): Replace with processor from plugin-automation?
-export const runLLM = async (params: CreateLLMConversationParams) => {
-  let conversationResult: any = null;
-  const history = params.history ?? [];
-
-  const generate = async () => {
-    log('llm generate', { tools: params.tools });
-    const beginTs = Date.now();
-    const stream = await params.client.exec({
-      model: params.model,
-      spaceId: params.spaceId,
-      threadId: params.threadId,
-      history,
-      systemPrompt: params.system,
-      tools: params.tools as any,
-    });
-
-    for await (const event of stream) {
-      params.logger?.(event);
-    }
-
-    // TODO(burdon): !!!
-    await stream.complete();
-    const messages: Message[] = [];
-    const message = messages.at(-1);
-    invariant(message);
-
-    log('llm result', { time: Date.now() - beginTs, message });
-    invariant(message);
-    params.logger?.({ type: 'message', message });
-    history.push(
-      ...messages.map(
-        (message): Message => ({ ...message, content: message.content.filter((block) => block.type !== 'image') }),
-      ),
-    );
-
-    const isToolUse = message.content.at(-1)?.type === 'tool_use';
-    if (isToolUse) {
-      const toolCalls = message.content.filter((block) => block.type === 'tool_use');
-      invariant(toolCalls.length === 1);
-      const toolCall = toolCalls[0];
-      const tool = params.tools.find((tool) => tool.name === toolCall.name);
-      if (!tool) {
-        throw new Error(`Tool not found: ${toolCall.name}`);
-      }
-
-      invariant(tool.execute);
-      const toolResult = await tool.execute(toolCall.input);
-      switch (toolResult.kind) {
-        case 'error': {
-          log.warn('tool error', { message: toolResult.message });
-          const resultMessage: Message = {
-            id: ObjectId.random(),
-            spaceId: params.spaceId,
-            threadId: params.threadId,
-            role: 'user',
-            content: [
-              {
-                type: 'tool_result',
-                toolUseId: toolCall.id,
-                content: toolResult.message,
-                isError: true,
-              },
-            ],
-          };
-          params.logger?.({ type: 'message', message: resultMessage });
-          history.push(resultMessage);
-
-          return true;
-        }
-
-        case 'success': {
-          log('tool success', { result: toolResult.result });
-          const resultMessage: Message = {
-            id: ObjectId.random(),
-            spaceId: params.spaceId,
-            threadId: params.threadId,
-            role: 'user',
-            content: [
-              {
-                type: 'tool_result',
-                toolUseId: toolCall.id,
-                content: JSON.stringify(toolResult.result),
-              },
-            ],
-          };
-          params.logger?.({ type: 'message', message: resultMessage });
-          history.push(resultMessage);
-
-          return true;
-        }
-
-        case 'break': {
-          log('tool break', { result: toolResult.result });
-          conversationResult = toolResult.result;
-          return false;
-        }
-      }
-    }
-
-    return false;
-  };
-
-  // eslint-disable-next-line no-empty
-  while (await generate()) {}
-
-  return {
-    result: conversationResult,
-    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/conversation/index.ts

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

package/src/conversation/types.ts

@@ -1,129 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-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 = (spaceId: SpaceId, threadId: ObjectId, text: string): Message => ({
-  id: ObjectId.random(),
-  spaceId,
-  threadId,
-  role: 'user',
-  content: [{ type: 'text', text }],
-});
-
-/**
- * @deprecated Use {@link LLMTool} instead.
- */
-export const ToolDefinition = S.Struct({
-  name: S.String,
-  description: S.String,
-  parameters: JsonSchemaType,
-  execute: S.Any,
-});
-
-/**
- * @deprecated Use {@link LLMTool} instead.
- */
-export type ToolDefinition = {
-  name: string;
-  description: string;
-  parameters: JsonSchemaType;
-  execute: (params: unknown, context: ToolExecutionContext) => Promise<ToolResult>;
-};
-
-declare global {
-  /**
-   * Extensions to the tool execution context.
-   *
-   * Different modules can extend this definition to add their own properties.
-   *
-   * @example
-   * ```ts
-   * declare global {
-   *   interface ToolContextExtensions {
-   *     chess: {
-   *       board: string;
-   *     };
-   *   }
-   * }
-   * ```
-   *
-   * @see https://www.typescriptlang.org/docs/handbook/declaration-merging.html#global-augmentation
-   */
-  interface ToolContextExtensions {}
-}
-
-export type ToolExecutionContext = {
-  extensions: ToolContextExtensions;
-};
-
-export type ToolResult =
-  | { kind: 'success'; result: unknown; extractContentBlocks?: MessageContentBlock[] }
-  | { kind: 'error'; message: string }
-  | { kind: 'break'; result: unknown };
-
-export const ToolResult = Object.freeze({
-  /**
-   * The tool execution was successful.
-   * Gives the result back to the LLM.
-   */
-  Success: (result: unknown, extractContentBlocks?: MessageContentBlock[]): ToolResult => ({
-    kind: 'success',
-    result,
-    extractContentBlocks,
-  }),
-
-  Error: (message: string): ToolResult => ({ kind: 'error', message }),
-  /**
-   * Stop the conversation and return the result.
-   */
-  Break: (result: unknown): ToolResult => ({ kind: 'break', result }),
-});
-
-export type DefineToolParams<Params extends S.Schema.AnyNoContext> = {
-  name: string;
-  description: string;
-  schema: Params;
-  execute: (params: S.Schema.Type<Params>, context: ToolExecutionContext) => Promise<ToolResult>;
-};
-
-export const defineTool = <Params extends S.Schema.AnyNoContext>({
-  name,
-  description,
-  schema,
-  execute,
-}: DefineToolParams<Params>): ToolDefinition => {
-  return {
-    name,
-    description,
-    parameters: toFunctionParameterSchema(schema),
-    execute: (params, context) => {
-      const sanitized = S.decodeSync(schema)(params);
-      return execute(sanitized, context);
-    },
-  };
-};
-
-/**
- * Adapts schems to be able to pass to AI providers.
- */
-const toFunctionParameterSchema = (schema: S.Schema.All) => {
-  const jsonSchema = toJsonSchema(schema);
-  log('tool schema', { jsonSchema });
-  delete jsonSchema.anyOf;
-  delete jsonSchema.$id;
-  jsonSchema.type = 'object';
-  jsonSchema.properties ??= {};
-  for (const key in jsonSchema.properties) {
-    if (typeof jsonSchema.properties![key].description !== 'string') {
-      throw new Error(`Property missing description: ${key}`);
-    }
-  }
-  return jsonSchema;
-};

package/src/cypher/ast.ts

@@ -1,75 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-// TODO(burdon): Why interface not type?
-
-export interface AstNode<Kind extends string> {
-  astKind: Kind;
-}
-
-export interface Identifier extends AstNode<'Identifier'> {
-  name: string;
-}
-
-export interface Property {
-  key: Identifier;
-  value: StringLiteral;
-}
-
-export interface Properties extends AstNode<'Properties'> {
-  properties: Property[];
-}
-
-export interface NodePattern extends AstNode<'NodePattern'> {
-  variable: Identifier | null;
-  label: Identifier;
-  properties: Properties | null;
-}
-
-export interface RelationshipPattern extends AstNode<'RelationshipPattern'> {
-  variable: Identifier | null;
-  label: Identifier;
-  properties: Properties | null;
-}
-
-export interface GraphPatternConnector extends AstNode<'GraphPatternConnector'> {
-  direction: '-' | '->' | '<-';
-}
-
-export interface GraphPattern extends AstNode<'GraphPattern'> {
-  segments: (NodePattern | RelationshipPattern)[] & {
-    separators: GraphPatternConnector[];
-  };
-}
-
-export interface MatchClause extends AstNode<'MatchClause'> {
-  pattern: GraphPattern;
-}
-
-export interface StringLiteral extends AstNode<'StringLiteral'> {
-  value: string;
-}
-
-export interface MemberExpression extends AstNode<'MemberExpression'> {
-  path: Identifier[];
-}
-
-export interface EqualsPredicate extends AstNode<'EqualsPredicate'> {
-  left: MemberExpression;
-  right: StringLiteral;
-}
-
-export interface WhereClause extends AstNode<'WhereClause'> {
-  predicates: EqualsPredicate[];
-}
-
-export interface ReturnClause extends AstNode<'ReturnClause'> {
-  fields: MemberExpression[];
-}
-
-export interface CypherQuery extends AstNode<'CypherQuery'> {
-  matchClause: MatchClause;
-  whereClause: WhereClause | null;
-  returnClause: ReturnClause;
-}