@dxos/assistant 0.8.2-main.fbd8ed0 → 0.8.2-staging.4d6ad0f

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 '../experimental';
-import {
-  AI_SERVICE_ENDPOINT,
-  createLogger,
-  createCypherTool,
-  createSystemPrompt,
-  createTestData,
-  Contact,
-  Organization,
-  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 = [Organization, 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 runLLM({
-    model: DEFAULT_EDGE_MODEL,
-    spaceId,
-    threadId,
-    system: createSystemPrompt(schemaTypes),
-    tools: [
-      cypherTool,
-      {
-        name: 'text-to-image',
-        type: ToolTypes.TextToImage,
-      },
-    ],
-    client,
-    history: [createUserMessage(spaceId, threadId, prompt.message)],
-    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/experimental/conversation/conversation.test.ts

@@ -1,73 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { Schema } 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: Schema.Struct({
-        magicWord: Schema.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/experimental/conversation/conversation.ts

@@ -1,142 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { type Message, type Tool } from '@dxos/artifact';
-import { 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.execStream({
-      model: params.model,
-      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(),
-            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(),
-            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,
-  };
-};

package/src/experimental/conversation/index.ts

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

package/src/experimental/conversation/types.ts

@@ -1,126 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { Schema } from 'effect';
-
-import { type Message, type MessageContentBlock } from '@dxos/artifact';
-import { toJsonSchema, JsonSchemaType, ObjectId } from '@dxos/echo-schema';
-import { log } from '@dxos/log';
-
-export const createUserMessage = (text: string): Message => ({
-  id: ObjectId.random(),
-  role: 'user',
-  content: [{ type: 'text', text }],
-});
-
-/**
- * @deprecated Use {@link LLMTool} instead.
- */
-export const ToolDefinition = Schema.Struct({
-  name: Schema.String,
-  description: Schema.String,
-  parameters: JsonSchemaType,
-  execute: Schema.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 Schema.Schema.AnyNoContext> = {
-  name: string;
-  description: string;
-  schema: Params;
-  execute: (params: Schema.Schema.Type<Params>, context: ToolExecutionContext) => Promise<ToolResult>;
-};
-
-export const defineTool = <Params extends Schema.Schema.AnyNoContext>({
-  name,
-  description,
-  schema,
-  execute,
-}: DefineToolParams<Params>): ToolDefinition => {
-  return {
-    name,
-    description,
-    parameters: toFunctionParameterSchema(schema),
-    execute: (params, context) => {
-      const sanitized = Schema.decodeSync(schema)(params);
-      return execute(sanitized, context);
-    },
-  };
-};
-
-/**
- * Adapts schems to be able to pass to AI providers.
- */
-const toFunctionParameterSchema = (schema: Schema.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/experimental/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;
-}

package/src/experimental/cypher/combinators.test.ts

@@ -1,137 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-/* eslint-disable unused-imports/no-unused-vars */
-/* eslint-disable @typescript-eslint/consistent-type-imports */
-
-import { createRequire } from 'node:module';
-import { type Parjser } from 'parjs';
-import { describe, test } from 'vitest';
-
-import { log } from '@dxos/log';
-
-import {
-  cypherQuery,
-  identifier,
-  matchClause,
-  nodePattern,
-  properties,
-  returnClause,
-  whereClause,
-} from './combinators';
-
-describe('Cypher Combinators', () => {
-  // TODO(dmaretskyi): Must be like this or it breaks vitest.
-  const require = createRequire(import.meta.url);
-  const { string, regexp, whitespace } = require('parjs') as typeof import('parjs');
-  const { between, many, manySepBy, or, map, then, recover } =
-    require('parjs/combinators') as typeof import('parjs/combinators');
-
-  test('string', ({ expect }) => {
-    expect(string('hello').parse('hello')).toMatchObject({ isOk: true });
-  });
-
-  test('string with whitespace', ({ expect }) => {
-    const ws = whitespace(); // Parses whitespace
-    // many;
-    // const optionalWs = many(100)(ws);
-
-    expect(string('hello').parse('hello')).toMatchObject({ isOk: true });
-  });
-
-  test('optional vairable tag', ({ expect }) => {
-    const node = identifier.pipe(
-      then(':'),
-      recover(() => ({ kind: 'Soft' })),
-      or(''),
-      then(identifier),
-      between('(', ')'),
-    );
-    const relation = identifier.pipe(
-      then(':'),
-      recover(() => ({ kind: 'Soft' })),
-      or(''),
-      then(identifier),
-      between('[', ']'),
-    );
-    const parser = or(node)(relation);
-    const input = '[a:b]';
-    const result = parser.parse(input);
-    log('result', { result });
-  });
-
-  test('properties', ({ expect }) => {
-    const input = "{name: 'John'}";
-    const result = properties.parse(input);
-    log('result', { result });
-    expect(result).toMatchObject({ isOk: true });
-  });
-
-  test('node pattern', ({ expect }) => {
-    testParser(nodePattern, '(:Person)');
-    testParser(nodePattern, '(n:Person)');
-    testParser(nodePattern, "(n:Person {name: 'John'})");
-  });
-
-  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)');
-  });
-
-  test('where clause', ({ expect }) => {
-    testParser(whereClause, 'WHERE n.name = "John"');
-    testParser(whereClause, 'WHERE o.name = "DXOS" AND p.name = "Composer"');
-  });
-
-  test('return clause', ({ expect }) => {
-    testParser(returnClause, 'RETURN n, m');
-    testParser(returnClause, 'RETURN m.name AS employee');
-
-    const cases = ['RETURN n, m'];
-    for (const input of cases) {
-      const result = returnClause.parse(input);
-      log('result', { result });
-      expect(result).toMatchObject({ isOk: true });
-    }
-  });
-
-  test('query', async ({ expect }) => {
-    testParser(cypherQuery, 'MATCH (n:Person) RETURN n');
-    testParser(
-      cypherQuery,
-      `
-      MATCH (n:Person {name: 'John'})-[r:KNOWS]->(m:Person)
-      RETURN n, m
-    `,
-    );
-    testParser(
-      cypherQuery,
-      `
-      MATCH (n:Person)-[r:KNOWS]->(m:Person)
-      WHERE n.name = "John"
-      RETURN n, m
-    `,
-    );
-    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',
-    );
-    testParser(
-      cypherQuery,
-      'MATCH (n:Organization {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",
-    );
-  });
-});
-
-const testParser = (parser: Parjser<any>, input: string) => {
-  const result = parser.parse(input);
-  if (!result.isOk) {
-    throw new Error(`Failed to parse: ${result}`);
-  }
-};