agent-accelerator 0.1.0

package/src/streaming/event-stream.ts

@@ -0,0 +1,211 @@
+import type { StreamEvent, AgentResponse } from "../types/response.ts";
+
+/** Listener invoked for a matching stream event type or `*`. */
+export type StreamEventListener = (event: StreamEvent) => void;
+
+type Resolver = {
+  resolve: (value: IteratorResult<StreamEvent>) => void;
+  reject: (err: Error) => void;
+};
+
+/** Async-iterable event stream returned by Agent.stream and streaming Agent.run. */
+export class AssistantMessageEventStream implements AsyncIterable<StreamEvent> {
+  private queue: StreamEvent[] = [];
+  private resolvers: Resolver[] = [];
+  private listeners: Map<string, Set<StreamEventListener>> = new Map();
+  private finished = false;
+  private error: Error | null = null;
+  private cancelled = false;
+  private cancelHandlers = new Set<() => void>();
+  private finalResultPromise: Promise<AgentResponse>;
+  private resolveFinalResult!: (result: AgentResponse) => void;
+  private rejectFinalResult!: (err: Error) => void;
+
+  /**
+   * Creates an empty event stream. `Agent.stream()` creates and completes
+   * streams automatically; this constructor is useful for custom adapters.
+   *
+   * @example
+   * ```ts
+   * const stream = new AssistantMessageEventStream();
+   * stream.on("text_delta", (event) => process.stdout.write(event.delta ?? ""));
+   * ```
+   */
+  constructor() {
+    this.finalResultPromise = new Promise<AgentResponse>((resolve, reject) => {
+      this.resolveFinalResult = resolve;
+      this.rejectFinalResult = reject;
+    });
+    // Prevent unhandled rejection when no one awaits result()
+    this.finalResultPromise.catch(() => {});
+  }
+
+  /** Publishes an event to listeners and async iterators. */
+  push(event: StreamEvent): void {
+    if (this.finished) return;
+
+    if (event.type === "error") {
+      this.error = (event.error instanceof Error ? event.error : new Error(String(event.error))) ?? new Error("Unknown error in stream");
+      // Reject final result but don't finish iterator yet — let iterators receive error event then fail
+      // Still deliver error event to listeners/consumers before marking finished? Keep consistent with agent-accel: error terminates stream
+      try { this.rejectFinalResult(this.error); } catch {}
+    }
+
+    // Trigger registered event listener callbacks
+    const specificListeners = this.listeners.get(event.type);
+    if (specificListeners) {
+      for (const listener of specificListeners) {
+        try { listener(event); } catch {}
+      }
+    }
+    const allListeners = this.listeners.get("*");
+    if (allListeners) {
+      for (const listener of allListeners) {
+        try { listener(event); } catch {}
+      }
+    }
+
+    if (event.type === "error") {
+      // Mark finished after delivering error event, reject pending resolvers
+      this.finished = true;
+      while (this.resolvers.length > 0) {
+        const r = this.resolvers.shift()!;
+        // First deliver error event if they were waiting, then reject next call
+        // For simplicity, reject immediately — consumer will see error via result() or next()
+        r.reject(this.error!);
+      }
+      // Also queue error event for later pulls if no resolver
+      if (this.queue.length === 0) this.queue.push(event);
+      else this.queue.push(event);
+      return;
+    }
+
+    if (this.resolvers.length > 0) {
+      const resolver = this.resolvers.shift()!;
+      resolver.resolve({ value: event, done: false });
+    } else {
+      this.queue.push(event);
+    }
+  }
+
+  /** Completes the stream and resolves result() with the final response. */
+  end(finalResponse?: AgentResponse): void {
+    if (this.finished) return;
+    this.finished = true;
+
+    if (finalResponse) {
+      this.resolveFinalResult(finalResponse);
+    } else {
+      // Resolve with empty if no response — should not happen, but prevent hanging
+      // Do not reject; just finish
+    }
+
+    // Flush any waiting resolvers as done
+    while (this.resolvers.length > 0) {
+      const resolver = this.resolvers.shift()!;
+      resolver.resolve({ value: undefined as any, done: true });
+    }
+  }
+
+  /** Fails the stream and rejects pending consumers. */
+  fail(error: Error): void {
+    if (this.finished) return;
+    // Delegate to push for unified error handling (listeners + queue + rejection)
+    this.push({ type: "error", error } as StreamEvent);
+  }
+
+  /** True once cancel() has been called. Background work should stop. */
+  isCancelled(): boolean {
+    return this.cancelled;
+  }
+
+  /** Registers a callback invoked once on cancel(). Returns an unsubscribe fn. */
+  onCancel(handler: () => void): () => void {
+    if (this.cancelled) {
+      try { handler(); } catch {}
+      return () => {};
+    }
+    this.cancelHandlers.add(handler);
+    return () => { this.cancelHandlers.delete(handler); };
+  }
+
+  /** Cancels the stream: stops background work and rejects result() with AbortError.
+   * Safe to call multiple times. Breaking out of for-await calls this automatically. */
+  cancel(reason?: unknown): void {
+    if (this.finished || this.cancelled) return;
+    this.cancelled = true;
+    for (const h of [...this.cancelHandlers]) {
+      try { h(); } catch {}
+    }
+    this.cancelHandlers.clear();
+    const err = reason instanceof Error ? reason : null;
+    const abortErr: Error =
+      err && (err.name === "AbortError" || /abort|cancel/i.test(err.message))
+        ? err
+        : Object.assign(new Error("Stream aborted"), { name: "AbortError" });
+    this.fail(abortErr);
+  }
+
+  /** Registers a listener for an event type or `*`. */
+  on(event: string, listener: StreamEventListener): this {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, new Set());
+    }
+    this.listeners.get(event)!.add(listener);
+    return this;
+  }
+
+  /** Removes a previously registered listener. */
+  off(event: string, listener: StreamEventListener): this {
+    this.listeners.get(event)?.delete(listener);
+    return this;
+  }
+
+  /** Resolves when the stream finishes with the normalized AgentResponse. */
+  result(): Promise<AgentResponse> {
+    return this.finalResultPromise;
+  }
+
+  [Symbol.asyncIterator](): AsyncIterator<StreamEvent> {
+    let iteratorDone = false;
+    return {
+      return: (): Promise<IteratorResult<StreamEvent>> => {
+        if (!iteratorDone) {
+          iteratorDone = true;
+          this.cancel();
+        }
+        return Promise.resolve({ value: undefined as any, done: true });
+      },
+      throw: (err?: unknown): Promise<IteratorResult<StreamEvent>> => {
+        if (!iteratorDone) {
+          iteratorDone = true;
+          this.cancel(err);
+        }
+        return Promise.reject(err);
+      },
+      next: (): Promise<IteratorResult<StreamEvent>> => {
+        if (this.queue.length > 0) {
+          const value = this.queue.shift()!;
+          // If queued error, next call should reject, but deliver error event first?
+          // Deliver error event then on next call reject
+          if (value.type === "error" && this.error) {
+            // Return error event as value, next next() will reject
+            return Promise.resolve({ value, done: false });
+          }
+          return Promise.resolve({ value, done: false });
+        }
+
+        if (this.finished) {
+          if (this.error) {
+            return Promise.reject(this.error);
+          }
+          return Promise.resolve({ value: undefined as any, done: true });
+        }
+
+        return new Promise<IteratorResult<StreamEvent>>((resolve, reject) => {
+          this.resolvers.push({ resolve, reject });
+        });
+      },
+    };
+  }
+}

package/src/streaming/sse-parser.ts

@@ -0,0 +1,97 @@
+/** Parsed Server-Sent Events message. */
+export interface SSEMessage {
+  id?: string;
+  event?: string;
+  data: string;
+}
+
+/**
+ * Incremental SSE parser that preserves events split across network chunks.
+ *
+ * @example
+ * ```ts
+ * const parser = new SSEParser();
+ * const events = parser.feed("event: message\\ndata: hello\\n\\n");
+ * ```
+ */
+export class SSEParser {
+  private buffer = "";
+  // Persist across feed() calls — otherwise split SSE messages lose state (S1 fix)
+  private currentEvent: string | undefined = undefined;
+  private currentData: string[] = [];
+  private currentId: string | undefined = undefined;
+
+  /** Feeds a chunk and returns all complete messages found in it. */
+  feed(chunk: string): SSEMessage[] {
+    this.buffer += chunk;
+    const messages: SSEMessage[] = [];
+
+    let start = 0;
+    while (start < this.buffer.length) {
+      const newlineIdx = this.buffer.indexOf("\n", start);
+      if (newlineIdx === -1) {
+        break;
+      }
+
+      let lineEnd = newlineIdx;
+      if (lineEnd > start && this.buffer.charCodeAt(lineEnd - 1) === 13) {
+        lineEnd--;
+      }
+
+      const line = this.buffer.slice(start, lineEnd);
+      start = newlineIdx + 1;
+
+      if (line.length === 0) {
+        if (this.currentData.length > 0) {
+          messages.push({
+            id: this.currentId,
+            event: this.currentEvent,
+            data: this.currentData.join("\n"),
+          });
+          this.currentEvent = undefined;
+          this.currentData = [];
+          this.currentId = undefined;
+        }
+      } else if (line.charCodeAt(0) === 58) {
+        // Comment / ping
+        continue;
+      } else if (line.startsWith("data:")) {
+        const val = line.slice(5);
+        this.currentData.push(val.startsWith(" ") ? val.slice(1) : val.trimStart());
+      } else if (line.startsWith("event:")) {
+        const val = line.slice(6);
+        this.currentEvent = (val.startsWith(" ") ? val.slice(1) : val).trim();
+      } else if (line.startsWith("id:")) {
+        const val = line.slice(3);
+        this.currentId = (val.startsWith(" ") ? val.slice(1) : val).trim();
+      }
+    }
+
+    this.buffer = this.buffer.slice(start);
+    return messages;
+  }
+
+  /** Flushes any unterminated final event. */
+  flush(): SSEMessage[] {
+    const messages: SSEMessage[] = [];
+    // S7: flush pending currentData first, then treat remaining buffer as final lines (avoid duplication)
+    if (this.buffer.trim() !== "") {
+      // Feed remaining buffer as if terminated
+      const pending = this.feed(this.buffer + "\n\n");
+      messages.push(...pending);
+      this.buffer = "";
+    }
+    if (this.currentData.length > 0) {
+      messages.push({
+        id: this.currentId,
+        event: this.currentEvent,
+        data: this.currentData.join("\n"),
+      });
+      this.currentEvent = undefined;
+      this.currentData = [];
+      this.currentId = undefined;
+    }
+    this.buffer = "";
+    return messages;
+  }
+}

package/src/tokens/counter.ts

@@ -0,0 +1,136 @@
+import type { Message, ContentPart } from "../types/message.ts";
+import type { ProviderContext } from "../types/message.ts";
+
+/**
+ * High-speed token estimation utility.
+ * For English text, average is ~4 characters per token or ~0.75 words per token.
+ * Code and symbols average ~2-3 characters per token.
+ */
+/**
+ * Estimates token count from text without contacting a provider tokenizer.
+ *
+ * @example `const tokens = estimateTokensFromText(prompt);`
+ */
+export function estimateTokensFromText(text: string): number {
+  if (!text || text.length === 0) return 0;
+  const chars = text.length;
+  let words = 0;
+  let inWord = false;
+  let codeMarkers = 0;
+
+  for (let i = 0; i < chars; i++) {
+    const code = text.charCodeAt(i);
+    // Whitespace: space(32), tab(9), LF(10), CR(13)
+    if (code === 32 || code === 9 || code === 10 || code === 13) {
+      if (inWord) {
+        words++;
+        inWord = false;
+      }
+    } else {
+      inWord = true;
+      // Code markers: { (123), } (125), ; (59), = (61), < (60), > (62), / (47), \ (92)
+      if (code === 123 || code === 125 || code === 59 || code === 61 || code === 60 || code === 62 || code === 47 || code === 92) {
+        codeMarkers++;
+      }
+    }
+  }
+  if (inWord) words++;
+
+  const isCodeHeavy = codeMarkers > chars * 0.05;
+  const charDivisor = isCodeHeavy ? 3.0 : 3.8;
+  const wordFactor = isCodeHeavy ? 1.6 : 1.3;
+  return Math.ceil(Math.max(chars / charDivisor, words * wordFactor));
+}
+
+/**
+ * Estimates tokens for one multimodal, thinking, or tool content part.
+ *
+ * @example `const tokens = estimateTokensFromPart({ type: "text", text: prompt });`
+ */
+export function estimateTokensFromPart(part: ContentPart): number {
+  switch (part.type) {
+    case "text":
+      return estimateTokensFromText(part.text);
+    case "thinking":
+      return estimateTokensFromText(part.thinking);
+    case "image":
+      // Standard vision token cost ~258 tokens per low-res / 1000-1600 per high-res tile
+      return 258;
+    case "audio":
+      // ~25 tokens per second of audio
+      return 150;
+    case "video":
+      // ~250 tokens per frame / minute
+      return 500;
+    case "file":
+      return 400;
+    case "tool_call":
+      return (
+        estimateTokensFromText(part.name) +
+        estimateTokensFromText(JSON.stringify(part.arguments)) +
+        15
+      );
+    case "tool_result":
+      return (
+        estimateTokensFromText(part.name) +
+        estimateTokensFromText(
+          typeof part.result === "string" ? part.result : JSON.stringify(part.result)
+        ) +
+        10
+      );
+    default:
+      return 0;
+  }
+}
+
+/**
+ * Estimates tokens for one normalized message including metadata overhead.
+ *
+ * @example `const tokens = estimateTokensFromMessage({ role: "user", content: "Hi" });`
+ */
+export function estimateTokensFromMessage(message: Message): number {
+  let count = 4; // Message metadata overhead (role, markers)
+  if (typeof message.content === "string") {
+    count += estimateTokensFromText(message.content);
+  } else if (Array.isArray(message.content)) {
+    for (const part of message.content) {
+      count += estimateTokensFromPart(part);
+    }
+  }
+  return count;
+}
+
+/**
+ * Estimates tokens for text, messages, or a complete ProviderContext.
+ *
+ * @example `const tokens = countTokens({ messages });`
+ */
+export function countTokens(
+  input: string | Message[] | ProviderContext
+): number {
+  if (typeof input === "string") {
+    return estimateTokensFromText(input);
+  }
+
+  if (Array.isArray(input)) {
+    let total = 0;
+    for (const msg of input) {
+      total += estimateTokensFromMessage(msg);
+    }
+    return total;
+  }
+
+  let total = 0;
+  if (input.systemPrompt) {
+    total += estimateTokensFromText(input.systemPrompt) + 5;
+  }
+  if (input.messages) {
+    for (const msg of input.messages) {
+      total += estimateTokensFromMessage(msg);
+    }
+  }
+  if (input.tools) {
+    total += estimateTokensFromText(JSON.stringify(input.tools)) + 20;
+  }
+  return total;
+}