@sveda-ai/core 0.1.0

package/src/context.ts

@@ -0,0 +1,38 @@
+export interface SvedaContextReadable {
+  description: string;
+  value: unknown | (() => unknown);
+}
+
+export class SvedaContextRegistry {
+  private readables = new Map<string, SvedaContextReadable>();
+
+  register(description: string, value: unknown | (() => unknown)): () => void {
+    const readable: SvedaContextReadable = { description, value };
+    this.readables.set(description, readable);
+
+    return () => this.unregister(description);
+  }
+
+  unregister(description: string): void {
+    this.readables.delete(description);
+  }
+
+  snapshot(): Record<string, unknown> {
+    const context: Record<string, unknown> = {};
+
+    for (const readable of this.readables.values()) {
+      const value =
+        typeof readable.value === 'function'
+          ? (readable.value as () => unknown)()
+          : readable.value;
+
+      context[readable.description] = value;
+    }
+
+    return context;
+  }
+
+  clear(): void {
+    this.readables.clear();
+  }
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './client.js';
+export * from './context.js';
+export * from './streaming.js';
+export * from './tools.js';
+export * from './types.js';

package/src/streaming.ts

@@ -0,0 +1,77 @@
+import {
+  parseSvedaStreamLine,
+  vercelDataPartToSvedaEvent,
+  type SvedaStreamEvent,
+} from '@sveda-ai/protocol';
+
+export type SvedaStreamProtocolMode = 'sveda' | 'vercel';
+
+async function* iterateStreamLines(body: ReadableStream<Uint8Array>): AsyncGenerator<string> {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+
+      buffer += decoder.decode(value, { stream: true });
+
+      let newlineIndex = buffer.indexOf('\n');
+      while (newlineIndex >= 0) {
+        yield buffer.slice(0, newlineIndex);
+        buffer = buffer.slice(newlineIndex + 1);
+        newlineIndex = buffer.indexOf('\n');
+      }
+    }
+
+    const tail = buffer.trim();
+    if (tail) {
+      yield tail;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+function parseVercelLine(line: string): SvedaStreamEvent | null {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith('data:')) {
+    return null;
+  }
+
+  const payload = trimmed.slice(5).trim();
+  if (!payload || payload === '[DONE]') {
+    return null;
+  }
+
+  try {
+    const part = JSON.parse(payload) as { type?: string };
+    if (!part || typeof part.type !== 'string') {
+      return null;
+    }
+
+    return vercelDataPartToSvedaEvent(part as { type: string } & Record<string, unknown>);
+  } catch {
+    return null;
+  }
+}
+
+export async function* iterateSvedaStream(
+  response: Response,
+  mode: SvedaStreamProtocolMode = 'sveda'
+): AsyncGenerator<SvedaStreamEvent> {
+  if (!response.body) {
+    throw new Error('[sveda] Stream response has no body');
+  }
+
+  for await (const line of iterateStreamLines(response.body)) {
+    const event = mode === 'vercel' ? parseVercelLine(line) : parseSvedaStreamLine(line);
+    if (event) {
+      yield event;
+    }
+  }
+}

package/src/tools.ts

@@ -0,0 +1,63 @@
+import type { SvedaClientToolDefinition } from '@sveda-ai/protocol';
+
+export interface SvedaFrontendToolContext {
+  chatId: string;
+  toolCallId: string;
+}
+
+export interface SvedaFrontendTool {
+  name: string;
+  description: string;
+  parameters: Record<string, unknown>;
+  handler: (
+    input: Record<string, unknown>,
+    context: SvedaFrontendToolContext
+  ) => unknown | Promise<unknown>;
+}
+
+export class SvedaToolRegistry {
+  private tools = new Map<string, SvedaFrontendTool>();
+
+  register(tool: SvedaFrontendTool): () => void {
+    this.tools.set(tool.name, tool);
+
+    return () => this.unregister(tool.name);
+  }
+
+  unregister(name: string): void {
+    this.tools.delete(name);
+  }
+
+  has(name: string): boolean {
+    return this.tools.has(name);
+  }
+
+  get(name: string): SvedaFrontendTool | undefined {
+    return this.tools.get(name);
+  }
+
+  list(): SvedaClientToolDefinition[] {
+    return [...this.tools.values()].map(tool => ({
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters,
+    }));
+  }
+
+  async execute(
+    name: string,
+    input: Record<string, unknown>,
+    context: SvedaFrontendToolContext
+  ): Promise<unknown> {
+    const tool = this.tools.get(name);
+    if (!tool) {
+      throw new Error(`[sveda] Unknown frontend tool: ${name}`);
+    }
+
+    return tool.handler(input, context);
+  }
+
+  clear(): void {
+    this.tools.clear();
+  }
+}

package/src/types.ts

@@ -0,0 +1,58 @@
+import type { SvedaRenderHint, SvedaToolTarget } from '@sveda-ai/protocol';
+
+export type SvedaMessageRole = 'user' | 'assistant' | 'system' | 'tool';
+
+export type SvedaMessagePart =
+  | { type: 'text'; text: string }
+  | { type: 'reasoning'; text: string }
+  | {
+      type: 'tool-call';
+      toolCallId: string;
+      toolName: string;
+      target: SvedaToolTarget;
+      input: Record<string, unknown>;
+    }
+  | {
+      type: 'tool-result';
+      toolCallId: string;
+      toolName: string;
+      output: unknown;
+      renderHint?: SvedaRenderHint;
+      renderData?: Record<string, unknown>;
+    }
+  | { type: 'file'; name: string; mediaType?: string; url?: string };
+
+export interface SvedaDisplayMessage {
+  id: string;
+  role: SvedaMessageRole;
+  parts: SvedaMessagePart[];
+  createdAt?: string;
+}
+
+export type SvedaSessionStatus = 'idle' | 'submitted' | 'streaming' | 'error';
+
+export interface SvedaChatHistorySummary {
+  chatId: string;
+  title: string;
+  updatedAt?: string;
+  [key: string]: unknown;
+}
+
+export interface SvedaChatHistoryDetail extends SvedaChatHistorySummary {
+  messages: SvedaDisplayMessage[];
+}
+
+export function messageText(message: SvedaDisplayMessage): string {
+  return message.parts
+    .filter((part): part is Extract<SvedaMessagePart, { type: 'text' }> => part.type === 'text')
+    .map(part => part.text)
+    .join('');
+}
+
+export function createMessageId(): string {
+  if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+    return crypto.randomUUID();
+  }
+
+  return `msg_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+}