@dxos/assistant 0.8.4-main.dedc0f3 → 0.8.4-main.dfabb4ec29

package/src/session/session.test.ts

@@ -1,308 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { AiTool, AiToolkit } from '@effect/ai';
-import { describe, it } from '@effect/vitest';
-import { Effect, Layer, Schema } from 'effect';
-
-import { AiService, ToolExecutionService, ToolResolverService } from '@dxos/ai';
-import { AiServiceTestingPreset } from '@dxos/ai/testing';
-import { Obj, Type } from '@dxos/echo';
-import { TracingService } from '@dxos/functions';
-import { log } from '@dxos/log';
-
-import { AiSession } from './session';
-
-// Define a calendar event artifact schema.
-const CalendarEventSchema = Schema.Struct({
-  title: Schema.String,
-  startTime: Schema.String,
-  endTime: Schema.String,
-  description: Schema.String,
-}).pipe(
-  Type.Obj({
-    typename: 'example.com/type/CalendarEvent',
-    version: '0.1.0',
-  }),
-);
-
-type CalendarEvent = Schema.Schema.Type<typeof CalendarEventSchema>;
-
-class TestToolkit extends AiToolkit.make(
-  AiTool.make('Calculator', {
-    description: 'Basic calculator tool',
-    parameters: {
-      input: Schema.String.annotations({
-        description: 'The calculation to perform.',
-      }),
-    },
-    success: Schema.Struct({
-      result: Schema.Number,
-    }),
-    failure: Schema.Never,
-  }),
-) {}
-
-// Tool handlers.
-const toolkitLayer = TestToolkit.toLayer({
-  Calculator: ({ input }) =>
-    Effect.gen(function* () {
-      const result = (() => {
-        // Restrict to basic arithmetic operations for safety.
-        const sanitizedInput = input.replace(/[^0-9+\-*/().\s]/g, '');
-        log.info('calculate', { sanitizedInput });
-
-        // eslint-disable-next-line @typescript-eslint/no-implied-eval
-        return Function(`"use strict"; return (${sanitizedInput})`)();
-      })();
-
-      return { result };
-    }),
-});
-
-describe.runIf(process.env.DX_RUN_SLOW_TESTS)('AiSession', () => {
-  it.effect('no tools', () =>
-    Effect.gen(function* () {
-      const session = new AiSession({ operationModel: 'configured' });
-      const response = yield* session.run({
-        prompt: 'Hello world!',
-        history: [],
-      });
-      log.info('response', { response });
-    }).pipe(
-      Effect.provide(
-        Layer.mergeAll(
-          toolkitLayer,
-          AiService.model('@anthropic/claude-3-5-sonnet-20241022').pipe(
-            Layer.provideMerge(ToolResolverService.layerEmpty),
-            Layer.provideMerge(ToolExecutionService.layerEmpty),
-            Layer.provideMerge(AiServiceTestingPreset('direct')),
-            Layer.provideMerge(TracingService.layerNoop),
-          ),
-        ),
-      ),
-    ),
-  );
-
-  it.effect('calculator', () =>
-    Effect.gen(function* () {
-      const session = new AiSession({ operationModel: 'configured' });
-      const toolkit = yield* TestToolkit;
-      const response = yield* session.run({
-        toolkit,
-        prompt: 'What is 10 + 20?',
-        history: [],
-      });
-      log.info('response', { response });
-    }).pipe(
-      Effect.provide(
-        Layer.mergeAll(
-          TracingService.layerNoop,
-          AiService.model('@anthropic/claude-3-5-sonnet-20241022').pipe(
-            Layer.provideMerge(AiServiceTestingPreset('direct')),
-          ),
-          ToolResolverService.layerEmpty,
-          ToolExecutionService.layerEmpty,
-          toolkitLayer,
-        ),
-      ),
-    ),
-  );
-
-  // TODO(dmaretskyi): Revive test.
-  /*
-  it.skip('create calendar itinerary', { timeout: 60_000 }, async () => {
-    // overrides: { model: 'llama3.1:8b' },
-    const session = new AiSession({ operationModel: 'configured' });
-    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: [
-        createTool('calendar', {
-          name: 'query',
-          description: 'Query the calendar for events',
-          schema: Schema.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: Schema.Struct({}),
-      tools: [
-        createTool('table', {
-          name: 'create',
-          description: 'Create a table',
-          schema: Schema.Struct({
-            data: Schema.Array(Schema.Any).annotations({ description: 'Array of data payloads to add as rows' }),
-          }),
-          execute: async ({ data }) => {
-            log('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: Schema.Struct({}),
-      tools: [
-        createTool('map', {
-          name: 'create',
-          description: 'Create a map',
-          schema: Schema.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('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: Schema.Struct({}),
-      tools: [],
-    });
-
-    // session.streamEvent.on((event) => {
-    //   printStreamEvent(event);
-    // });
-
-    const printer = new ConsolePrinter();
-    session.message.on((message) => printer.printMessage(message));
-    session.userMessage.on((message) => printer.printMessage(message));
-    session.block.on((block) => printer.printContentBlock(block));
-
-    // session.update.on((update) => {
-    //   log('update', { update });
-    // });
-
-    // Test creating an itinerary
-    const response = await session.run({
-      client: aiClient,
-      tools: [],
-      artifacts: [calendarArtifact, tableArtifact, mapArtifact, scriptArtifact],
-      requiredArtifactIds: [calendarArtifact.id, tableArtifact.id, mapArtifact.id, scriptArtifact.id],
-      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',
-      toolResolver: new ToolRegistry([]),
-    });
-
-    log('result', {
-      objects,
-      finalMessage: response.at(-1),
-    });
-  });
-  */
-});
-
-// Travel to rome, florence, livorno, siena, madrid for conferences
-
-const _CALENDAR_EVENTS: CalendarEvent[] = [
-  Obj.make(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',
-  }),
-  Obj.make(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',
-  }),
-  Obj.make(CalendarEventSchema, {
-    title: 'Travel to Livorno',
-    startTime: '2024-01-01T12:00:00Z',
-    endTime: '2024-01-01T13:00:00Z',
-    description: 'Travel to Livorno',
-  }),
-  Obj.make(CalendarEventSchema, {
-    title: 'Travel to Siena',
-    startTime: '2024-01-01T13:00:00Z',
-    endTime: '2024-01-01T14:00:00Z',
-    description: 'Travel to Siena',
-  }),
-  Obj.make(CalendarEventSchema, {
-    title: 'Travel to Madrid',
-    startTime: '2024-01-01T14:00:00Z',
-    endTime: '2024-01-01T15:00:00Z',
-    description: 'Travel to Madrid',
-  }),
-];
-
-// 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;
-//     }
-//   }
-// };

package/src/session/session.ts

@@ -1,201 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { type AiError, AiLanguageModel, type AiTool, type AiToolkit } from '@effect/ai';
-import { Chunk, Effect, type Schema, Stream } from 'effect';
-
-import {
-  type AiInputPreprocessingError,
-  AiParser,
-  AiPreprocessor,
-  type AiToolNotFoundError,
-  type ToolExecutionService,
-  type ToolResolverService,
-  callTool,
-  getToolCalls,
-} from '@dxos/ai';
-import { type Blueprint } from '@dxos/blueprints';
-import { todo } from '@dxos/debug';
-import { Obj } from '@dxos/echo';
-import { TracingService } from '@dxos/functions';
-import { log } from '@dxos/log';
-import { DataType } from '@dxos/schema';
-
-import { type AiAssistantError } from '../errors';
-
-import { mapAiError } from './error-handling';
-import { formatSystemPrompt, formatUserPrompt } from './format';
-import { GenerationObserver } from './observer';
-
-export type AiSessionRunError = AiError.AiError | AiInputPreprocessingError | AiToolNotFoundError | AiAssistantError;
-
-export type AiSessionRunRequirements =
-  | AiLanguageModel.AiLanguageModel
-  | ToolExecutionService
-  | ToolResolverService
-  | TracingService;
-
-export type AiSessionRunParams<Tools extends AiTool.Any> = {
-  prompt: string;
-  system?: string;
-  history?: DataType.Message[];
-  objects?: Obj.Any[];
-  blueprints?: Blueprint.Blueprint[];
-  toolkit?: AiToolkit.ToHandler<Tools>;
-  observer?: GenerationObserver;
-};
-
-export type AiSessionOptions = {};
-
-/**
- * Contains message history, tools, current context.
- * Current context means the state of the app, time of day, and other contextual information.
- * It makes requests to the model, its a state machine.
- * It keeps track of the current goal.
- * It manages the context window.
- * Tracks the success criteria of reaching the goal, exposing metrics (stretch).
- * Could be run locally in the app or remotely.
- * Could be personal or shared.
- */
-export class AiSession {
-  /** Prevents concurrent execution of session. */
-  private readonly _semaphore = Effect.runSync(Effect.makeSemaphore(1));
-
-  /** Message history from queue. */
-  // TODO(burdon): Evolve into supporting a git-like graph of messages.
-  private _history: DataType.Message[] = [];
-
-  /** Pending messages for this session (incl. the current prompt). */
-  private _pending: DataType.Message[] = [];
-
-  constructor(private readonly _options: AiSessionOptions = {}) {}
-
-  run = <Tools extends AiTool.Any>({
-    prompt,
-    system: systemTemplate,
-    history = [],
-    objects = [],
-    blueprints = [],
-    toolkit,
-    observer = GenerationObserver.noop(),
-  }: AiSessionRunParams<Tools>): Effect.Effect<DataType.Message[], AiSessionRunError, AiSessionRunRequirements> =>
-    Effect.gen(this, function* () {
-      this._history = [...history];
-      this._pending = [];
-      const pending = this._pending;
-
-      const submitMessage = Effect.fnUntraced(function* (message: DataType.Message) {
-        pending.push(message);
-        yield* observer.onMessage(message);
-        yield* TracingService.emitConverationMessage(message);
-        return message;
-      });
-
-      // Submit the prompt.
-      // TODO(burdon): Remove if cancelled?
-      const promptMessage = yield* submitMessage(yield* formatUserPrompt({ prompt, history }));
-
-      // Generate system and prompt messages.
-      const system = yield* formatSystemPrompt({ system: systemTemplate, blueprints, objects });
-
-      // Tool call loop.
-      do {
-        log('request', {
-          prompt: promptMessage,
-          system: { snippet: createSnippet(system), length: system.length },
-          pending: this._pending.length,
-          history: this._history.length,
-          objects: objects?.length ?? 0,
-        });
-
-        const prompt = yield* AiPreprocessor.preprocessAiInput([...this._history, ...this._pending]);
-
-        // Execute the stream request.
-        const blocks = yield* AiLanguageModel.streamText({
-          prompt,
-          system,
-          toolkit,
-          disableToolCallResolution: true,
-        }).pipe(
-          Stream.catchTag(
-            'AiError',
-            Effect.fnUntraced(function* (err) {
-              return yield* Effect.fail(yield* mapAiError(err));
-            }),
-          ),
-          AiParser.parseResponse({
-            onBegin: () => observer.onBegin(),
-            onBlock: (block) => observer.onBlock(block),
-            onPart: (part) => observer.onPart(part),
-            onEnd: (summary) => observer.onEnd(summary),
-          }),
-          Stream.runCollect,
-          Effect.map(Chunk.toArray),
-        );
-
-        // Create the response message.
-        const response = yield* submitMessage(
-          Obj.make(DataType.Message, {
-            created: new Date().toISOString(),
-            sender: { role: 'assistant' },
-            blocks,
-          }),
-        );
-
-        // Parse the response for tool calls.
-        const toolCalls = getToolCalls(response);
-        if (toolCalls.length === 0) {
-          break;
-        } else if (!toolkit) {
-          throw new Error('No toolkit provided'); // TODO(burdon): Throw user error?
-        }
-
-        // Execute the tool calls.
-        // TODO(burdon): Retry errors? Write result when each completes individually?
-        const toolResults = yield* Effect.forEach(toolCalls, (toolCall) => {
-          return callTool(toolkit, toolCall).pipe(
-            Effect.provide(
-              TracingService.layerSubframe((context) => ({
-                ...context,
-                parentMessage: response.id,
-                toolCallId: toolCall.toolCallId,
-              })),
-            ),
-          );
-        });
-
-        // Add to queue and continue loop.
-        yield* submitMessage(
-          Obj.make(DataType.Message, {
-            created: new Date().toISOString(),
-            sender: { role: 'user' },
-            blocks: toolResults,
-          }),
-        );
-      } while (true);
-
-      log('done', { pending: this._pending.length });
-      return this._pending;
-    }).pipe(this._semaphore.withPermits(1), Effect.withSpan('AiSession.run'));
-
-  /**
-   * @deprecated
-   */
-  // TODO(burdon): Implement or remove.
-  async runStructured<S extends Schema.Schema.AnyNoContext>(
-    _schema: S,
-    _options: AiSessionRunParams<AiTool.Any>,
-  ): Promise<Schema.Schema.Type<S>> {
-    return todo();
-    // const parser = structuredOutputParser(schema);
-    // const result = await this.run({
-    //   ...options,
-    //   executableTools: [...(options.executableTools ?? []), parser.tool],
-    // });
-    // return parser.getResult(result);
-  }
-}
-
-const createSnippet = (text: string, len = 32) =>
-  text.length <= len * 2 ? text : [text.slice(0, len), '...', text.slice(-len)].join('');

package/src/session/version-pin.test.ts

@@ -1,7 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { describe } from 'vitest';
-
-describe('VersionPin', () => {});