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

package/src/ai-service/parser.ts

@@ -1,369 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Message, type MessageContentBlock } from '@dxos/artifact';
-import { Event } from '@dxos/async';
-import { create } from '@dxos/echo-schema';
-import { invariant } from '@dxos/invariant';
-import { log } from '@dxos/log';
-import { isNotFalsy, safeParseJson } from '@dxos/util';
-
-import { type GenerationStream } from './service';
-import { StreamTransform, type StreamBlock } from './transform';
-import type { GenerationStreamEvent } from './types';
-
-/**
- * Parse mixed content of plain text, XML fragments, and JSON blocks.
- */
-export class MixedStreamParser {
-  /**
-   * New message.
-   */
-  public message = new Event<Message>();
-
-  /**
-   * Complete block added to Message.
-   */
-  public block = new Event<MessageContentBlock>();
-
-  /**
-   * Update partial block (while streaming).
-   */
-  public update = new Event<MessageContentBlock>();
-
-  public streamEvent = new Event<GenerationStreamEvent>();
-
-  /**
-   * Current message.
-   */
-  private _message?: Message | undefined;
-
-  private _emitBlock(contentBlock: MessageContentBlock, streamBlock?: StreamBlock) {
-    const messageBlock = streamBlock ? mergeMessageBlock(contentBlock, streamBlock) : contentBlock;
-    if (messageBlock) {
-      if (messageBlock.type === 'text' && messageBlock.text.length === 0) {
-        return;
-      }
-
-      invariant(this._message);
-      this._message.content.push(messageBlock);
-      this.block.emit(messageBlock);
-    }
-  }
-
-  private _emitUpdate(contentBlock: MessageContentBlock, streamBlock: StreamBlock) {
-    const messageBlock = mergeMessageBlock(contentBlock, streamBlock);
-    if (messageBlock) {
-      messageBlock.pending = true;
-      this.update.emit(messageBlock);
-    }
-  }
-
-  /**
-   * Parse stream until end.
-   */
-  async parse(stream: GenerationStream): Promise<Message[]> {
-    const transformer = new StreamTransform();
-
-    /**
-     * Current content message block.
-     */
-    let contentBlock: MessageContentBlock | undefined;
-
-    /**
-     * Current partial block used to accumulate content.
-     */
-    let streamBlock: StreamBlock | undefined;
-    const stack: StreamBlock[] = [];
-
-    const messagesCollected: Message[] = [];
-
-    for await (const event of stream) {
-      log('streamEvent', { event });
-      this.streamEvent.emit(event);
-
-      // log('event', { type: event.type, event });
-      switch (event.type) {
-        //
-        // Messages.
-        //
-
-        case 'message_start': {
-          if (this._message) {
-            log.warn('unexpected message_start');
-          }
-
-          this._message = create(Message, { role: event.message.role, content: [...event.message.content] });
-          this.message.emit(this._message);
-          break;
-        }
-
-        case 'message_delta': {
-          if (!this._message) {
-            log.warn('unexpected message_delta');
-          }
-
-          break;
-        }
-
-        case 'message_stop': {
-          if (!this._message) {
-            log.warn('unexpected message_stop');
-          } else {
-            messagesCollected.push(this._message);
-            this._message = undefined;
-          }
-          break;
-        }
-
-        //
-        // Content blocks.
-        //
-
-        case 'content_block_start': {
-          if (contentBlock) {
-            log.warn('unexpected content_block_start', { content: contentBlock });
-          }
-
-          // TODO(burdon): Parse initial content (factor out from content_block_delta).
-          contentBlock = event.content;
-          break;
-        }
-
-        case 'content_block_delta': {
-          if (!contentBlock) {
-            log.warn('unexpected content_block_delta');
-            break;
-          }
-
-          switch (event.delta.type) {
-            //
-            // Text
-            //
-            case 'text_delta': {
-              const chunks = transformer.transform(event.delta.text);
-              for (const chunk of chunks) {
-                log('text_delta', { chunk });
-
-                switch (streamBlock?.type) {
-                  //
-                  // XML Fragment.
-                  //
-                  case 'tag': {
-                    if (chunk.type === 'tag') {
-                      if (chunk.selfClosing) {
-                        streamBlock.content.push(chunk);
-                      } else if (chunk.closing) {
-                        if (stack.length > 0) {
-                          const top = stack.pop();
-                          invariant(top && top.type === 'tag');
-                          log('pop', { top });
-                          top.content.push(streamBlock);
-                          streamBlock = top;
-                        } else {
-                          this._emitBlock(contentBlock, streamBlock);
-                          streamBlock = undefined;
-                        }
-                      } else {
-                        stack.push(streamBlock);
-                        streamBlock = chunk;
-                      }
-                    } else {
-                      // Append text.
-                      if (streamBlock.content.length === 0) {
-                        streamBlock.content.push(chunk);
-                      } else {
-                        const last = streamBlock.content.at(-1);
-                        invariant(last);
-                        if (last.type === 'text') {
-                          last.content += chunk.content;
-                        } else {
-                          streamBlock.content.push(chunk);
-                        }
-                      }
-                    }
-                    break;
-                  }
-
-                  //
-                  // Text Fragment.
-                  //
-                  case 'text': {
-                    if (chunk.type === 'tag') {
-                      this._emitBlock(contentBlock, streamBlock);
-                      if (chunk.selfClosing) {
-                        this._emitBlock(contentBlock, chunk);
-                        streamBlock = undefined;
-                      } else {
-                        streamBlock = chunk;
-                      }
-                    } else {
-                      // Append text.
-                      streamBlock.content += chunk.content;
-                    }
-                    break;
-                  }
-
-                  //
-                  // No current chunk.
-                  //
-                  default: {
-                    if (chunk.type === 'tag' && chunk.selfClosing) {
-                      this._emitBlock(contentBlock, chunk);
-                    } else {
-                      streamBlock = chunk;
-                    }
-                  }
-                }
-              }
-              break;
-            }
-
-            //
-            // JSON
-            //
-            case 'input_json_delta': {
-              if (!contentBlock) {
-                log.warn('unexpected input_json_delta', { contentBlock });
-                break;
-              }
-
-              if (streamBlock?.type === 'json') {
-                streamBlock.content += event.delta.partial_json;
-              } else {
-                streamBlock = { type: 'json', content: event.delta.partial_json };
-              }
-              break;
-            }
-          }
-          break;
-        }
-
-        case 'content_block_stop': {
-          if (!contentBlock) {
-            log.warn('unexpected content_block_stop');
-            break;
-          }
-
-          this._emitBlock(contentBlock, streamBlock);
-          contentBlock = undefined;
-          streamBlock = undefined;
-          break;
-        }
-      }
-
-      if (contentBlock && streamBlock) {
-        this._emitUpdate(contentBlock, streamBlock);
-      }
-    } // for.
-
-    return messagesCollected;
-  }
-}
-
-/**
- * Convert stream block to message content block.
- */
-export const mergeMessageBlock = (
-  contentBlock: MessageContentBlock,
-  streamBlock: StreamBlock,
-): MessageContentBlock | undefined => {
-  log('mergeMessageBlock', { contentBlock, streamBlock });
-
-  switch (streamBlock.type) {
-    //
-    // Text
-    //
-    case 'text': {
-      return { ...contentBlock, type: 'text', text: streamBlock.content };
-    }
-
-    //
-    // XML
-    //
-    case 'tag': {
-      switch (streamBlock.tag) {
-        case 'cot': {
-          const content = streamBlock.content
-            .map((block) => {
-              switch (block.type) {
-                case 'text':
-                  return block.content;
-                default:
-                  return null;
-              }
-            })
-            .filter(isNotFalsy)
-            .join('\n');
-
-          return { ...contentBlock, type: 'text', disposition: 'cot', text: content };
-        }
-
-        case 'artifact': {
-          const { attributes } = streamBlock;
-          return { type: 'json', disposition: 'artifact', json: JSON.stringify(attributes) };
-        }
-
-        case 'suggest': {
-          if (streamBlock.content.length === 1 && streamBlock.content[0].type === 'text') {
-            return {
-              type: 'json',
-              disposition: 'suggest',
-              json: JSON.stringify({ text: streamBlock.content[0].content }),
-            };
-          }
-          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',
-            disposition: 'select',
-            json: JSON.stringify({
-              options: streamBlock.content.flatMap((content) =>
-                content.type === 'tag' && content.content.length === 1 && content.content[0].type === 'text'
-                  ? [content.content[0].content]
-                  : [],
-              ),
-            }),
-          };
-        }
-
-        case 'tool-list': {
-          return {
-            type: 'json',
-            disposition: 'tool_list',
-            json: JSON.stringify({}),
-          };
-        }
-      }
-
-      break;
-    }
-
-    //
-    // JSON
-    //
-    case 'json': {
-      switch (contentBlock.type) {
-        case 'tool_use': {
-          return { ...contentBlock, input: safeParseJson(streamBlock.content) ?? {} };
-        }
-      }
-
-      return { ...contentBlock, type: 'json', disposition: 'artifact', json: streamBlock.content };
-    }
-  }
-};

package/src/ai-service/service.ts

@@ -1,31 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { type GenerateRequest, type GenerationStreamEvent, type GenerateResponse } from './types';
-
-/**
- * Interface for AI service.
- * Generates chat completions, supports, history and tools.
- */
-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>;
-}
-
-/**
- * Streaming chat completion stream.
- */
-export interface GenerationStream extends AsyncIterable<GenerationStreamEvent> {
-  abort(): void;
-  complete(): Promise<void>;
-}

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

@@ -1,125 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { describe, test } from 'vitest';
-
-import { type Message } from '@dxos/artifact';
-import { log } from '@dxos/log';
-
-import { MixedStreamParser } from './parser';
-import { createGenerationStream } from './stream';
-import { createTestSSEStream } from './testing';
-import { type GenerationStreamEvent } from './types';
-
-// TODO(burdon): Tool request/response.
-
-const TEST_BLOCKS = [
-  [
-    // Text
-    'some text',
-    'on multiple lines.',
-
-    // XML
-    '<cot>',
-    '  1. Analyze content.',
-    '  2. Create plan.',
-    '  3. Generate artifacts.',
-    '</cot>',
-
-    // Text
-    'some more text.',
-
-    // XML
-    '<artifact id="123" />',
-
-    // XML
-    '<artifact id="456" />',
-
-    // Text
-    'and some more text.',
-
-    '<suggest>Plan me a trip to the Rio.</suggest>',
-    '<suggest>Show me steak recipes.</suggest>',
-    '<select><option>Yes</option><option>No</option></select>',
-  ].join('\n'),
-
-  // JSON
-  {
-    type: 'input',
-    value: {
-      level: 1,
-      optional: true,
-    },
-  },
-];
-
-describe('GenerationStream', () => {
-  test('should generate a stream of blocks', async ({ expect }) => {
-    const stream = createGenerationStream(new Response(createTestSSEStream(TEST_BLOCKS)));
-    const events: GenerationStreamEvent[] = [];
-    for await (const event of stream) {
-      events.push(event);
-    }
-
-    expect(events.map((event) => event.type === 'content_block_start').filter(Boolean)).to.have.length(2);
-  });
-
-  for (const splitBy of ['word'] as const) {
-    test(`should emit xml blocks (splitBy: ${splitBy})`, async ({ expect }) => {
-      const stream = createGenerationStream(new Response(createTestSSEStream(TEST_BLOCKS, { splitBy })));
-      const parser = new MixedStreamParser();
-
-      let message: Message | undefined;
-      parser.message.on((_message) => {
-        message = _message;
-      });
-
-      await parser.parse(stream);
-
-      for (const block of message?.content ?? []) {
-        log('block', { block });
-      }
-      expect(message?.content.map((block) => block.type)).to.deep.eq([
-        //
-        'text',
-        'text',
-        'text',
-        'json',
-        'text',
-        'json',
-        'text',
-        'json',
-        'text',
-        'json',
-        'text',
-        'json',
-        'json',
-      ]);
-    });
-  }
-
-  test.skip('invalid xml', async ({ expect }) => {
-    const BLOCKS = [
-      //
-      '<cot> thoughts <tool-list> more thoughts </cot> <tool-list/>',
-    ];
-
-    const stream = createGenerationStream(new Response(createTestSSEStream(BLOCKS, { splitBy: 'word' })));
-    const parser = new MixedStreamParser();
-
-    const result = await parser.parse(stream);
-    expect(result[0].content).to.deep.eq([
-      {
-        type: 'text',
-        disposition: 'cot',
-        text: 'thoughts more thoughts',
-      },
-      {
-        type: 'json',
-        disposition: 'tool_list',
-        json: '{}',
-      },
-    ]);
-  });
-});

package/src/ai-service/stream.ts

@@ -1,118 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { Trigger } from '@dxos/async';
-import { log } from '@dxos/log';
-
-import type { GenerationStream } from './service';
-import { type GenerationStreamEvent } from './types';
-import { iterSSEMessages } from './util';
-
-/**
- * Creates a stream from an SSE response.
- */
-export const createGenerationStream = (response: Response, controller = new AbortController()): GenerationStream => {
-  const iterator = async function* () {
-    for await (const sse of iterSSEMessages(response, controller)) {
-      if (sse.event === 'completion') {
-        try {
-          yield JSON.parse(sse.data);
-        } catch (err) {
-          log.error('could not parse message into JSON:', { data: sse.data, raw: sse.raw });
-          throw err;
-        }
-      }
-
-      if (
-        sse.event === 'message_start' ||
-        sse.event === 'message_delta' ||
-        sse.event === 'message_stop' ||
-        sse.event === 'content_block_start' ||
-        sse.event === 'content_block_delta' ||
-        sse.event === 'content_block_stop'
-      ) {
-        try {
-          yield JSON.parse(sse.data);
-        } catch (err) {
-          log.error('could not parse message into JSON:', { data: sse.data, raw: sse.raw });
-          throw err;
-        }
-      }
-
-      if (sse.event === 'ping') {
-        continue;
-      }
-
-      if (sse.event === 'error') {
-        throw new Error(`Message generation error: ${sse.data}`);
-      }
-    }
-  };
-
-  return new GenerationStreamImpl(controller, iterator);
-};
-
-/**
- * Server-Sent Events (SSE) stream from the AI service.
- * https://html.spec.whatwg.org/multipage/server-sent-events.html#server-sent-events
- */
-export class GenerationStreamImpl implements GenerationStream {
-  /**
-   * Trigger event when the stream is done.
-   */
-  private readonly _done = new Trigger();
-
-  /**
-   * Iterator over the stream.
-   */
-  private _iterator?: AsyncIterator<GenerationStreamEvent> = undefined;
-
-  constructor(
-    private readonly _controller: AbortController,
-    private readonly _getIterator: () => AsyncIterableIterator<GenerationStreamEvent>,
-  ) {}
-
-  /**
-   * Returns an iterator over the stream.
-   */
-  [Symbol.asyncIterator](): AsyncIterator<GenerationStreamEvent> {
-    return this._createIterator();
-  }
-
-  /**
-   * Aborts the stream.
-   */
-  abort() {
-    this._controller.abort();
-  }
-
-  /**
-   * Returns the complete message list generated by the AI service.
-   */
-  async complete() {
-    await this._done.wait();
-  }
-
-  /**
-   * Creates an iterator over the stream.
-   */
-  private _createIterator(): AsyncIterator<GenerationStreamEvent> {
-    const self = this;
-    return (this._iterator ??= (() => {
-      const generator = async function* (this: GenerationStreamImpl) {
-        try {
-          for await (const event of self._getIterator()) {
-            yield event;
-          }
-          this._done.wake();
-        } catch (err: any) {
-          this._done.throw(err);
-          throw err;
-        }
-      };
-
-      return generator.call(this);
-    })());
-  }
-}

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

@@ -1,6 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-export * from './mock';
-export * from './test-stream';

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

@@ -1,30 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import {
-  type GenerationStream,
-  type AIServiceClient,
-  type GenerateRequest,
-  createGenerationStream,
-  type GenerateResponse,
-} from '@dxos/assistant';
-
-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> {
-    return createGenerationStream(new Response(createTestSSEStream(this._responses)));
-  }
-}