@pi-oxide/pi-host-web 0.3.1 → 0.4.0

package/sdk/internal/providers/openai.ts

@@ -0,0 +1,177 @@
+// openaiCompatible() and openai() factories — OpenAI-compatible provider adapters.
+// openai() is a thin wrapper with baseUrl: "https://api.openai.com" (no /v1).
+// openaiCompatible() appends /v1/chat/completions to the baseUrl.
+// Correct message format: content: string | null, tool_calls: [...]
+// Response parsing with tool_calls into AgentContentBlock[].
+
+import type { AgentModel, ModelRequest, ModelResponse, AgentContentBlock } from "../../types.ts";
+import { createAgentError } from "../../errors.ts";
+
+export function openaiCompatible(config: {
+  apiKey: string;
+  baseUrl: string;
+  model: string;
+  maxTokens?: number;
+}): AgentModel {
+  return {
+    id: config.model,
+    contextWindow: 128000,
+    maxTokens: config.maxTokens ?? 4096,
+    capabilities: {
+      vision: config.model.includes("vision") || config.model.includes("gpt-4o"),
+      jsonMode: true,
+      functionCalling: true,
+      streaming: true,
+    },
+    async generate(request: ModelRequest): Promise<ModelResponse> {
+      // Convert AgentMessage[] -> OpenAI Chat Completions message format
+      const messages = request.messages.map((msg) => {
+        switch (msg.role) {
+          case "user": {
+            const text = msg.content
+              .filter((c): c is { type: "text"; text: string } => c.type === "text")
+              .map((c) => c.text)
+              .join("\n");
+            return { role: "user" as const, content: text };
+          }
+          case "assistant": {
+            const textBlocks = msg.content
+              .filter((c): c is { type: "text"; text: string } => c.type === "text")
+              .map((c) => c.text)
+              .join("");
+            const toolCalls = msg.content
+              .filter((c): c is { type: "tool_call"; id: string; name: string; arguments: unknown } => c.type === "tool_call")
+              .map((c) => ({
+                id: c.id,
+                type: "function" as const,
+                function: {
+                  name: c.name,
+                  arguments: JSON.stringify(c.arguments),
+                },
+              }));
+            return {
+              role: "assistant" as const,
+              content: textBlocks || null,
+              tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+            };
+          }
+          case "tool_result": {
+            const text = msg.content
+              .filter((c): c is { type: "text"; text: string } => c.type === "text")
+              .map((c) => c.text)
+              .join("\n");
+            return {
+              role: "tool" as const,
+              tool_call_id: msg.tool_call_id ?? "",
+              content: text,
+            };
+          }
+        }
+      });
+
+      // Convert AgentToolDefinition[] -> OpenAI functions format
+      const tools = request.tools.map((t) => ({
+        type: "function" as const,
+        function: {
+          name: t.name,
+          description: t.description,
+          parameters: t.inputSchema as object,
+        },
+      }));
+
+      const body = {
+        model: config.model,
+        messages,
+        tools: tools.length > 0 ? tools : undefined,
+        max_tokens: config.maxTokens,
+      };
+
+      try {
+        const resp = await fetch(`${config.baseUrl.replace(/\/+$/, "")}/v1/chat/completions`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${config.apiKey}`,
+          },
+          body: JSON.stringify(body),
+          signal: request.signal,
+        });
+
+        if (!resp.ok) {
+          const status = resp.status;
+          const text = await resp.text();
+          throw createAgentError(
+            status === 401 ? "model_auth_failed" :
+            status === 429 ? "model_rate_limited" :
+            "model_unavailable",
+            `HTTP ${status}: ${text}`,
+            { recoverable: status === 429 },
+          );
+        }
+
+        const data = await resp.json();
+        const choice = data.choices?.[0];
+        const message = choice?.message;
+
+        // Parse content and tool_calls from OpenAI response
+        const content: AgentContentBlock[] = [];
+
+        if (message?.content && typeof message.content === "string") {
+          content.push({ type: "text", text: message.content });
+        }
+
+        if (message?.tool_calls && Array.isArray(message.tool_calls)) {
+          for (const tc of message.tool_calls) {
+            if (tc.type === "function") {
+              content.push({
+                type: "tool_call",
+                id: tc.id ?? "",
+                name: tc.function?.name ?? "",
+                arguments: (() => {
+                  try {
+                    return JSON.parse(tc.function?.arguments ?? "{}");
+                  } catch {
+                    return {};
+                  }
+                })(),
+              });
+            }
+          }
+        }
+
+        return {
+          content,
+          stopReason: choice?.finish_reason === "tool_calls" ? "tool_call" :
+                      choice?.finish_reason === "stop" ? "end" :
+                      choice?.finish_reason === "length" ? "length" : "error",
+          usage: data.usage ? {
+            input: data.usage.prompt_tokens,
+            output: data.usage.completion_tokens,
+            cache_read: 0,
+            cache_write: 0,
+            total_tokens: data.usage.total_tokens,
+          } : undefined,
+          model: config.model,
+          raw: data,
+        };
+      } catch (e) {
+        if (e && typeof e === "object" && "code" in e) throw e;
+        throw createAgentError("model_unavailable", e instanceof Error ? e.message : String(e), { cause: e, recoverable: false });
+      }
+    },
+  };
+}
+
+// openai() passes baseUrl WITHOUT /v1; openaiCompatible() appends /v1/chat/completions
+export function openai(config: {
+  apiKey: string;
+  model: string;
+  maxTokens?: number;
+}): AgentModel {
+  return openaiCompatible({
+    apiKey: config.apiKey,
+    baseUrl: "https://api.openai.com",
+    model: config.model,
+    maxTokens: config.maxTokens,
+  });
+}

package/sdk/internal/providers/types.ts

@@ -0,0 +1,64 @@
+// Provider-neutral types for the LLM adapter interface.
+//
+// These types bridge the Rust agent core and any specific provider implementation.
+
+import type { ToolDefinition } from "../../../pi_host_web.js";
+
+/** Context from the Rust agent for a stream_llm action. */
+export interface LlmRequest {
+  system_prompt: string;
+  messages: AgentMessageShape[];
+  tools: ToolDefinition[];
+}
+
+/** The shape of a message as it flows through the Rust core. */
+export type AgentMessageShape =
+  | { role: "user"; content: ContentBlock[]; timestamp: number }
+  | {
+      role: "assistant";
+      content: ContentBlock[];
+      api: string;
+      provider: string;
+      model: string;
+      stop_reason: string;
+      error_message: string | null;
+      timestamp: number;
+      usage: TokenUsage;
+    }
+  | {
+      role: "tool_result";
+      tool_call_id: string;
+      tool_name: string;
+      content: ContentBlock[];
+      details: unknown;
+      is_error: boolean;
+      timestamp: number;
+    };
+
+export interface ContentBlock {
+  type: string;
+  text?: string;
+  id?: string;
+  name?: string;
+  arguments?: Record<string, unknown>;
+  media_type?: string;
+  data?: string;
+}
+
+export interface TokenUsage {
+  input: number;
+  output: number;
+  cache_read: number;
+  cache_write: number;
+  total_tokens: number;
+}
+
+/** Result from the provider — fed back into Rust via onLlmDone. */
+export interface ProviderResult {
+  /** The LlmResult JSON to pass to onLlmDone. */
+  llmResult: object;
+  /** Chunks to feed via feedLlmChunk before calling onLlmDone. */
+  chunks: object[];
+  /** Log entries from the provider call. */
+  log: string[];
+}

package/sdk/internal/stores/indexedDb.ts

@@ -0,0 +1,24 @@
+// IndexedDB wrapper — converts internal IndexedDBSessionBackend to public AgentStore.
+
+import { IndexedDBSessionBackend } from "./persistence.ts";
+import type { AgentStore, AgentSnapshot } from "../../types.ts";
+import type { PersistData } from "../../../pi_host_web.js";
+
+export function indexedDbStore(): AgentStore {
+  const backend = new IndexedDBSessionBackend();
+
+  return {
+    async loadSession(sessionId: string): Promise<AgentSnapshot | null> {
+      const data = await backend.load(sessionId);
+      if (!data) return null;
+      return { version: 1, data } as AgentSnapshot;
+    },
+
+    async saveSession(sessionId: string, snapshot: AgentSnapshot): Promise<void> {
+      await backend.save(sessionId, snapshot.data as unknown as PersistData);
+    },
+
+    // Artifact methods are not supported by the raw IndexedDBSessionBackend.
+    // If artifact support is needed, use a store that implements them.
+  };
+}

package/sdk/internal/stores/persistence.ts

@@ -0,0 +1,71 @@
+/**
+ * Session persistence backend for browser agents.
+ *
+ * Uses PersistData for the new Agent lifecycle.
+ */
+
+import type { PersistData } from "../../../pi_host_web.js";
+
+export interface SessionBackend {
+  save(sessionId: string, state: PersistData): Promise<void>;
+  load(sessionId: string): Promise<PersistData | null>;
+}
+
+const DB_NAME = "pi-oxide-browser-agent";
+const DB_VERSION = 3;
+const STORE_NAME = "sessions";
+
+export class IndexedDBSessionBackend implements SessionBackend {
+  private dbPromise: Promise<IDBDatabase>;
+
+  constructor() {
+    this.dbPromise = this.openDB();
+  }
+
+  private openDB(): Promise<IDBDatabase> {
+    return new Promise((resolve, reject) => {
+      const req = indexedDB.open(DB_NAME, DB_VERSION);
+      req.onupgradeneeded = () => {
+        const db = req.result;
+        if (db.objectStoreNames.contains("session")) {
+          db.deleteObjectStore("session");
+        }
+        if (db.objectStoreNames.contains("artifacts")) {
+          db.deleteObjectStore("artifacts");
+        }
+        if (!db.objectStoreNames.contains(STORE_NAME)) {
+          db.createObjectStore(STORE_NAME, { keyPath: "sessionId" });
+        }
+      };
+      req.onsuccess = () => resolve(req.result);
+      req.onerror = () => reject(req.error);
+    });
+  }
+
+  async save(sessionId: string, state: PersistData): Promise<void> {
+    const db = await this.dbPromise;
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(STORE_NAME, "readwrite");
+      tx.objectStore(STORE_NAME).put({
+        sessionId,
+        state,
+        updatedAt: Date.now(),
+      });
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+
+  async load(sessionId: string): Promise<PersistData | null> {
+    const db = await this.dbPromise;
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(STORE_NAME, "readonly");
+      const req = tx.objectStore(STORE_NAME).get(sessionId);
+      req.onsuccess = () => {
+        const result = req.result as { state: PersistData } | undefined;
+        resolve(result?.state ?? null);
+      };
+      req.onerror = () => reject(req.error);
+    });
+  }
+}

package/sdk/internal/tools/artifact.ts

@@ -0,0 +1,24 @@
+// artifactTools() pack — wraps createArtifactToolRegistry from service.ts.
+// Hides host handles; the actual handle is wired at build time by ToolRegistryBuilder.
+
+import type { AgentTools, AgentToolDefinition } from "../../types.ts";
+import { ARTIFACT_TOOLS } from "./service.ts";
+
+export function artifactTools(): AgentTools {
+  const definitions: AgentToolDefinition[] = ARTIFACT_TOOLS.map((t) => ({
+    name: t.name,
+    description: t.description,
+    inputSchema: t.parameters,
+    run: () => {
+      throw new Error("artifactTools handlers are wired at build time by ToolRegistryBuilder");
+    },
+  }));
+
+  return {
+    definitions,
+    getHandler() {
+      // Handlers are provided by createArtifactToolRegistry at build time.
+      return null;
+    },
+  };
+}