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

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

@@ -1,93 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { ObjectId } from '@dxos/echo-schema';
-
-import { type GenerationStreamEvent } from '../types';
-
-/**
- * Mock server-side events (SSE) stream.
- */
-export const createTestSSEStream = (
-  pars: (string | object)[],
-  { splitBy = 'word' }: { splitBy?: 'word' | 'character' } = {},
-): ReadableStream => {
-  const encoder = new TextEncoder();
-
-  return new ReadableStream({
-    start: (controller) => {
-      const push = (event: GenerationStreamEvent) => {
-        controller.enqueue(encoder.encode(`event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`));
-      };
-
-      push({
-        type: 'message_start',
-        message: {
-          id: ObjectId.random(),
-          role: 'assistant',
-          content: [],
-        },
-      });
-
-      for (const block of pars) {
-        let index = 0;
-        if (typeof block === 'string') {
-          push({
-            type: 'content_block_start',
-            index,
-            content: {
-              type: 'text',
-              text: '',
-            },
-          });
-
-          for (const word of block.split(splitBy === 'word' ? /([ \t\n]+)/ : '')) {
-            push({
-              type: 'content_block_delta',
-              index,
-              delta: {
-                type: 'text_delta',
-                text: word,
-              },
-            });
-            index += word.length + 1;
-          }
-        } else {
-          push({
-            type: 'content_block_start',
-            index,
-            content: {
-              type: 'json',
-              json: '',
-            },
-          });
-
-          const text = JSON.stringify(block, null, 2);
-          for (const line of text.split('\n')) {
-            push({
-              type: 'content_block_delta',
-              index,
-              delta: {
-                type: 'input_json_delta',
-                partial_json: line,
-              },
-            });
-            index += line.length + 1;
-          }
-        }
-
-        push({
-          type: 'content_block_stop',
-          index,
-        });
-      }
-
-      push({
-        type: 'message_stop',
-      });
-
-      controller.close();
-    },
-  });
-};

package/src/ai-service/transform.ts

@@ -1,121 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as P from 'parsimmon';
-
-/**
- * Parsed block.
- */
-export type StreamBlock =
-  | {
-      type: 'tag';
-      tag: string;
-      attributes?: Record<string, string>;
-      content: StreamBlock[];
-      closing?: boolean;
-      selfClosing?: boolean;
-    }
-  | { type: 'text'; content: string }
-  | { type: 'json'; disposition?: string; content: string };
-
-const textChunk: P.Parser<StreamBlock> = P.regexp(/[^<]+/).map((content) => ({
-  type: 'text',
-  content,
-}));
-
-const attribute: P.Parser<[string, string]> = P.seq(
-  P.regexp(/[a-zA-Z_][a-zA-Z0-9_-]*/),
-  P.string('=').trim(P.optWhitespace),
-  P.alt(
-    P.regexp(/"[^"]*"/).map((s) => s.slice(1, -1)),
-    P.regexp(/'[^']*'/).map((s) => s.slice(1, -1)),
-  ),
-).map(([name, _, value]) => [name, value]);
-
-const tagName = P.regexp(/[a-zA-Z_][a-zA-Z0-9_-]*/);
-
-const selfClosingTag: P.Parser<StreamBlock> = P.seqMap(
-  //
-  P.string('<'),
-  tagName,
-  P.optWhitespace.then(attribute).many(),
-  P.optWhitespace.then(P.string('/>')),
-  P.optWhitespace,
-  (_, tag, attributes, __) => ({
-    type: 'tag',
-    tag,
-    attributes: Object.fromEntries(attributes),
-    content: [],
-    selfClosing: true,
-  }),
-);
-
-const openTag: P.Parser<StreamBlock> = P.seqMap(
-  //
-  P.string('<'),
-  tagName,
-  P.optWhitespace.then(attribute).many(),
-  P.string('>'),
-  P.regexp(/[^<]*/),
-  (_, tag, attributes, __, content) => ({
-    type: 'tag',
-    tag,
-    attributes: Object.fromEntries(attributes),
-    content: content.length ? [{ type: 'text', content }] : [],
-  }),
-);
-
-const closeTag: P.Parser<StreamBlock> = P.seqMap(
-  //
-  P.string('</'),
-  tagName,
-  P.string('>'),
-  P.optWhitespace,
-  (_, tag) => ({
-    type: 'tag',
-    tag,
-    content: [],
-    closing: true,
-  }),
-);
-
-const mixedChunk: P.Parser<StreamBlock> = P.alt(selfClosingTag, openTag, closeTag, textChunk);
-
-/**
- * Permissive streaming transformer that processes mixed content (plain text and XML fragments) from the AI service.
- */
-export class StreamTransform {
-  private _buffer = '';
-
-  transform(chunk: string): StreamBlock[] {
-    this._buffer += chunk;
-
-    const results: StreamBlock[] = [];
-    const parser = mixedChunk.many().skip(P.optWhitespace);
-    const result = parser.parse(this._buffer);
-    if (result.status) {
-      for (const chunk of result.value) {
-        results.push(chunk);
-      }
-
-      this._buffer = '';
-    }
-
-    return results;
-  }
-
-  // TODO(burdon): Process remaining buffer?
-  flush(): StreamBlock[] {
-    const remaining = this._buffer;
-    this._buffer = '';
-    return remaining.length > 0
-      ? [
-          {
-            type: 'text',
-            content: remaining,
-          },
-        ]
-      : [];
-  }
-}

package/src/ai-service/types.ts

@@ -1,112 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Schema } from 'effect';
-
-import { Tool, Message, type MessageContentBlock } from '@dxos/artifact';
-import { type 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 type LLMModel = Schema.Schema.Type<typeof LLMModel>;
-
-export const ToolTypes = Object.freeze({
-  // TODO(dmaretskyi): Not implemented yet.
-  // DatabaseQuery: 'database_query',
-  TextToImage: 'text_to_image',
-});
-
-/**
- * Client GPT request.
- */
-export const GenerateRequest = Schema.Struct({
-  /**
-   * Preferred model or system default.
-   */
-  model: Schema.optional(LLMModel),
-
-  /**
-   * Tools available for the LLM.
-   */
-  tools: Schema.optional(Schema.Array(Tool).pipe(Schema.mutable)),
-
-  /**
-   * System instructions to the LLM.
-   */
-  systemPrompt: Schema.optional(Schema.String),
-
-  /**
-   * History of messages to include in the context window.
-   */
-  // TODO(burdon): Rename messages.
-  history: Schema.optional(Schema.Array(Message)),
-
-  /**
-   * Current request.
-   */
-  prompt: Schema.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>;
-
-/**
- * Server-Sent Events (SSE) stream from the AI service.
- * https://docs.anthropic.com/en/api/streaming
- * https://platform.openai.com/docs/api-reference/streaming
- * https://html.spec.whatwg.org/multipage/server-sent-events.html#server-sent-events
- */
-// TODO(dmaretskyi): Effect schema.
-export type GenerationStreamEvent =
-  | {
-      // TODO(dmaretskyi): Normalize types to our schema.
-      type: 'message_start';
-      message: Omit<Message, 'spaceId' | 'threadId'>;
-    }
-  | {
-      type: 'message_delta';
-      delta: {
-        stopReason: 'tool_use' | 'end_turn';
-      };
-    }
-  | {
-      type: 'message_stop';
-    }
-  | {
-      type: 'content_block_start';
-      index: number;
-      content: MessageContentBlock;
-    }
-  | {
-      type: 'content_block_delta';
-      index: number;
-      delta:
-        | {
-            type: 'text_delta';
-            text: string;
-          }
-        | {
-            type: 'input_json_delta';
-            partial_json: string;
-          };
-    }
-  | {
-      type: 'content_block_stop';
-      index: number;
-    };

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

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

package/src/ai-service/util/sse.ts

@@ -1,341 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-// Copied from anthropic SDK source
-//
-
-/**
- * Server sent events (SSE) iterator.
- * @param response
- * @param controller
- */
-export async function* iterSSEMessages(
-  response: Response,
-  controller: AbortController,
-): AsyncGenerator<ServerSentEvent, void, unknown> {
-  if (!response.body) {
-    controller.abort();
-    throw new Error('Attempted to iterate over a response with no body');
-  }
-
-  const sseDecoder = new SSEDecoder();
-  const lineDecoder = new LineDecoder();
-
-  const iter = readableStreamAsyncIterable<Bytes>(response.body);
-  for await (const sseChunk of iterSSEChunks(iter)) {
-    for (const line of lineDecoder.decode(sseChunk)) {
-      const sse = sseDecoder.decode(line);
-      if (sse) {
-        yield sse;
-      }
-    }
-  }
-
-  for (const line of lineDecoder.flush()) {
-    const sse = sseDecoder.decode(line);
-    if (sse) {
-      yield sse;
-    }
-  }
-}
-
-export type ServerSentEvent = {
-  event: string | null;
-  data: string;
-  raw: string[];
-};
-
-/**
- * Given an async iterable iterator, iterates over it and yields full
- * SSE chunks, i.e. yields when a double new-line is encountered.
- */
-async function* iterSSEChunks(iterator: AsyncIterableIterator<Bytes>): AsyncGenerator<Uint8Array> {
-  let data = new Uint8Array();
-
-  for await (const chunk of iterator) {
-    if (chunk == null) {
-      continue;
-    }
-
-    const binaryChunk =
-      chunk instanceof ArrayBuffer
-        ? new Uint8Array(chunk)
-        : typeof chunk === 'string'
-          ? new TextEncoder().encode(chunk)
-          : chunk;
-
-    const newData = new Uint8Array(data.length + binaryChunk.length);
-    newData.set(data);
-    newData.set(binaryChunk, data.length);
-    data = newData;
-
-    let patternIndex;
-    while ((patternIndex = findDoubleNewlineIndex(data)) !== -1) {
-      yield data.slice(0, patternIndex);
-      data = data.slice(patternIndex);
-    }
-  }
-
-  if (data.length > 0) {
-    yield data;
-  }
-}
-
-const findDoubleNewlineIndex = (buffer: Uint8Array): number => {
-  // This function searches the buffer for the end patterns (\r\r, \n\n, \r\n\r\n)
-  // and returns the index right after the first occurrence of any pattern,
-  // or -1 if none of the patterns are found.
-  const newline = 0x0a; // \n
-  const carriage = 0x0d; // \r
-
-  for (let i = 0; i < buffer.length - 2; i++) {
-    if (buffer[i] === newline && buffer[i + 1] === newline) {
-      // \n\n
-      return i + 2;
-    }
-    if (buffer[i] === carriage && buffer[i + 1] === carriage) {
-      // \r\r
-      return i + 2;
-    }
-    if (
-      buffer[i] === carriage &&
-      buffer[i + 1] === newline &&
-      i + 3 < buffer.length &&
-      buffer[i + 2] === carriage &&
-      buffer[i + 3] === newline
-    ) {
-      // \r\n\r\n
-      return i + 4;
-    }
-  }
-
-  return -1;
-};
-
-class SSEDecoder {
-  private data: string[];
-  private event: string | null;
-  private chunks: string[];
-
-  constructor() {
-    this.event = null;
-    this.data = [];
-    this.chunks = [];
-  }
-
-  decode(line: string) {
-    if (line.endsWith('\r')) {
-      line = line.substring(0, line.length - 1);
-    }
-
-    if (!line) {
-      // empty line and we didn't previously encounter any messages
-      if (!this.event && !this.data.length) {
-        return null;
-      }
-
-      const sse: ServerSentEvent = {
-        event: this.event,
-        data: this.data.join('\n'),
-        raw: this.chunks,
-      };
-
-      this.event = null;
-      this.data = [];
-      this.chunks = [];
-
-      return sse;
-    }
-
-    this.chunks.push(line);
-
-    if (line.startsWith(':')) {
-      return null;
-    }
-
-    let [fieldname, _, value] = partition(line, ':');
-
-    if (value.startsWith(' ')) {
-      value = value.substring(1);
-    }
-
-    if (fieldname === 'event') {
-      this.event = value;
-    } else if (fieldname === 'data') {
-      this.data.push(value);
-    }
-
-    return null;
-  }
-}
-
-/** This is an internal helper function that's just used for testing */
-export const _decodeChunks = (chunks: string[]): string[] => {
-  const decoder = new LineDecoder();
-  const lines: string[] = [];
-  for (const chunk of chunks) {
-    lines.push(...decoder.decode(chunk));
-  }
-
-  return lines;
-};
-
-const partition = (str: string, delimiter: string): [string, string, string] => {
-  const index = str.indexOf(delimiter);
-  if (index !== -1) {
-    return [str.substring(0, index), delimiter, str.substring(index + delimiter.length)];
-  }
-
-  return [str, '', ''];
-};
-
-/**
- * Most browsers don't yet have async iterable support for ReadableStream,
- * and Node has a very different way of reading bytes from its "ReadableStream".
- *
- * This polyfill was pulled from https://github.com/MattiasBuelens/web-streams-polyfill/pull/122#issuecomment-1627354490
- */
-export function readableStreamAsyncIterable<T>(stream: any): AsyncIterableIterator<T> {
-  if (stream[Symbol.asyncIterator]) {
-    return stream;
-  }
-
-  const reader = stream.getReader();
-  return {
-    next: async () => {
-      try {
-        const result = await reader.read();
-        if (result?.done) {
-          reader.releaseLock();
-        } // release lock when stream becomes closed
-        return result;
-      } catch (e) {
-        reader.releaseLock(); // release lock when stream becomes errored
-        throw e;
-      }
-    },
-    return: async () => {
-      const cancelPromise = reader.cancel();
-      reader.releaseLock();
-      await cancelPromise;
-      return { done: true, value: undefined };
-    },
-    [Symbol.asyncIterator]() {
-      return this;
-    },
-  };
-}
-
-export type Bytes = string | ArrayBuffer | Uint8Array | Buffer | null | undefined;
-
-/**
- * A re-implementation of httpx's `LineDecoder` in Python that handles incrementally
- * reading lines from text.
- *
- * https://github.com/encode/httpx/blob/920333ea98118e9cf617f246905d7b202510941c/httpx/_decoders.py#L258
- */
-export class LineDecoder {
-  // prettier-ignore
-  static NEWLINE_CHARS = new Set(['\n', '\r']);
-  static NEWLINE_REGEXP = /\r\n|[\n\r]/g;
-
-  buffer: string[];
-  trailingCR: boolean;
-  textDecoder: any; // TextDecoder found in browsers; not typed to avoid pulling in either "dom" or "node" types.
-
-  constructor() {
-    this.buffer = [];
-    this.trailingCR = false;
-  }
-
-  decode(chunk: Bytes): string[] {
-    let text = this.decodeText(chunk);
-
-    if (this.trailingCR) {
-      text = '\r' + text;
-      this.trailingCR = false;
-    }
-    if (text.endsWith('\r')) {
-      this.trailingCR = true;
-      text = text.slice(0, -1);
-    }
-
-    if (!text) {
-      return [];
-    }
-
-    const trailingNewline = LineDecoder.NEWLINE_CHARS.has(text[text.length - 1] || '');
-    let lines = text.split(LineDecoder.NEWLINE_REGEXP);
-
-    // if there is a trailing new line then the last entry will be an empty
-    // string which we don't care about
-    if (trailingNewline) {
-      lines.pop();
-    }
-
-    if (lines.length === 1 && !trailingNewline) {
-      this.buffer.push(lines[0]!);
-      return [];
-    }
-
-    if (this.buffer.length > 0) {
-      lines = [this.buffer.join('') + lines[0], ...lines.slice(1)];
-      this.buffer = [];
-    }
-
-    if (!trailingNewline) {
-      this.buffer = [lines.pop() || ''];
-    }
-
-    return lines;
-  }
-
-  decodeText(bytes: Bytes): string {
-    if (bytes == null) {
-      return '';
-    }
-    if (typeof bytes === 'string') {
-      return bytes;
-    }
-
-    // Node:
-    if (typeof Buffer !== 'undefined') {
-      if (bytes instanceof Buffer) {
-        return bytes.toString();
-      }
-      if (bytes instanceof Uint8Array) {
-        return Buffer.from(bytes).toString();
-      }
-
-      throw new Error(
-        `Unexpected: received non-Uint8Array (${bytes.constructor.name}) stream chunk in an environment with a global "Buffer" defined, which this library assumes to be Node. Please report this error.`,
-      );
-    }
-
-    // Browser
-    if (typeof TextDecoder !== 'undefined') {
-      if (bytes instanceof Uint8Array || bytes instanceof ArrayBuffer) {
-        this.textDecoder ??= new TextDecoder('utf8');
-        return this.textDecoder.decode(bytes);
-      }
-
-      throw new Error(
-        `Unexpected: received non-Uint8Array/ArrayBuffer (${
-          (bytes as any).constructor.name
-        }) in a web platform. Please report this error.`,
-      );
-    }
-
-    throw new Error('Unexpected: neither Buffer nor TextDecoder are available as globals. Please report this error.');
-  }
-
-  flush(): string[] {
-    if (!this.buffer.length && !this.trailingCR) {
-      return [];
-    }
-
-    const lines = [this.buffer.join('')];
-    this.buffer = [];
-    this.trailingCR = false;
-    return lines;
-  }
-}