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

package/sdk/internal/events.ts

@@ -0,0 +1,241 @@
+// EventMapper — converts raw WASM AgentEvent[] into semantic SDK events.
+// Accumulates RunState (messages, toolCalls, artifacts, usage).
+// Emits all status states: idle, loading, thinking, calling_model, running_tool, saving, completed, aborted, failed.
+// Artifact events from turn_end markers (new API: artifacts tracked via tool result details).
+// Usage accumulation from model responses.
+
+import type {
+  AgentEvent as RawAgentEvent,
+  AgentMessage as WasmAgentMessage,
+  Content,
+} from "../../pi_host_web.js";
+import type {
+  AgentMessage,
+  AgentContentBlock,
+  AgentToolRun,
+  AgentArtifactRef,
+  AgentStatus,
+  AgentRunResult,
+  TokenUsage,
+} from "../types.ts";
+
+export interface SemanticEvent {
+  type: string;
+  payload: unknown;
+}
+
+export interface RunState {
+  messages: AgentMessage[];
+  toolCalls: AgentToolRun[];
+  artifacts: AgentArtifactRef[];
+  usage: TokenUsage;
+  text: string;
+  currentMessage: AgentMessage | null;
+  currentTool: AgentToolRun | null;
+}
+
+export class EventMapper {
+  createRunState(): RunState {
+    return {
+      messages: [],
+      toolCalls: [],
+      artifacts: [],
+      usage: { input: 0, output: 0, cache_read: 0, cache_write: 0, total_tokens: 0 },
+      text: "",
+      currentMessage: null,
+      currentTool: null,
+    };
+  }
+
+  map(rawEvent: RawAgentEvent, state: RunState): SemanticEvent[] {
+    const events: SemanticEvent[] = [];
+
+    switch (rawEvent.type) {
+      case "agent_start": {
+        events.push({ type: "status", payload: { state: "loading", message: "Agent starting..." } as AgentStatus });
+        break;
+      }
+
+      case "turn_start": {
+        events.push({ type: "status", payload: { state: "thinking", message: "Thinking..." } as AgentStatus });
+        break;
+      }
+
+      case "message_start": {
+        const msg = this.convertWasmMessage(rawEvent.message);
+        state.currentMessage = msg;
+        state.messages.push(msg);
+        events.push({ type: "messageStart", payload: msg });
+        events.push({ type: "status", payload: { state: "thinking" } as AgentStatus });
+        break;
+      }
+
+      case "message_update": {
+        const delta = rawEvent.delta;
+        if (delta.kind === "text_delta" && delta.text) {
+          state.text += delta.text;
+          events.push({ type: "text", payload: delta.text });
+        } else if (delta.kind === "tool_call_start" && delta.tool_call) {
+          // Track tool call in current message
+        } else if (delta.kind === "thinking_delta") {
+          events.push({ type: "status", payload: { state: "thinking", message: "Thinking..." } as AgentStatus });
+        }
+        break;
+      }
+
+      case "message_end": {
+        const msg = this.convertWasmMessage(rawEvent.message);
+        state.currentMessage = msg;
+        // Update the last message in state
+        const idx = state.messages.findIndex((m) => m.id === msg.id);
+        if (idx >= 0) {
+          state.messages[idx] = msg;
+        } else {
+          state.messages.push(msg);
+        }
+        events.push({ type: "messageEnd", payload: msg });
+        break;
+      }
+
+      case "tool_execution_start": {
+        const tool: AgentToolRun = {
+          id: rawEvent.tool_call_id,
+          name: rawEvent.tool_name,
+          title: rawEvent.tool_name,
+          input: rawEvent.args ?? {},
+          status: "running",
+          startedAt: Date.now(),
+        };
+        state.currentTool = tool;
+        state.toolCalls.push(tool);
+        events.push({ type: "toolStart", payload: tool });
+        events.push({ type: "status", payload: { state: "running_tool", message: `Running ${rawEvent.tool_name}...` } as AgentStatus });
+        break;
+      }
+
+      case "tool_execution_update": {
+        const tool = state.toolCalls.find((t) => t.id === rawEvent.tool_call_id);
+        if (tool) {
+          tool.output = (tool.output ?? "") + rawEvent.chunk;
+          events.push({ type: "toolUpdate", payload: tool });
+        }
+        break;
+      }
+
+      case "tool_execution_end": {
+        const tool = state.toolCalls.find((t) => t.id === rawEvent.tool_call_id);
+        if (tool) {
+          tool.status = rawEvent.is_error ? "failed" : "completed";
+          tool.endedAt = Date.now();
+          // Extract output from result
+          const resultText = rawEvent.result.content
+            .filter((c): c is { type: "text"; text: string } => c.type === "text")
+            .map((c) => c.text)
+            .join("\n");
+          tool.output = resultText;
+          events.push({ type: "toolEnd", payload: tool });
+        }
+        break;
+      }
+
+      case "tool_execution_cancelled": {
+        const tool = state.toolCalls.find((t) => t.id === rawEvent.tool_call_id);
+        if (tool) {
+          tool.status = "cancelled";
+          tool.endedAt = Date.now();
+          events.push({ type: "toolEnd", payload: tool });
+        }
+        break;
+      }
+
+      case "turn_end": {
+        // Extract final message
+        const finalMsg = this.convertWasmMessage(rawEvent.message);
+        const idx = state.messages.findIndex((m) => m.id === finalMsg.id);
+        if (idx >= 0) {
+          state.messages[idx] = finalMsg;
+        } else {
+          state.messages.push(finalMsg);
+        }
+
+        // Extract tool results
+        for (const tr of rawEvent.tool_results) {
+          const tool = state.toolCalls.find((t) => t.id === tr.tool_call_id);
+          if (tool) {
+            tool.status = tr.is_error ? "failed" : "completed";
+            tool.endedAt = Date.now();
+            const resultText = tr.content
+              .filter((c): c is { type: "text"; text: string } => c.type === "text")
+              .map((c) => c.text)
+              .join("\n");
+            tool.output = resultText;
+          }
+        }
+
+        events.push({ type: "status", payload: { state: "completed" } as AgentStatus });
+        break;
+      }
+
+      case "save_point": {
+        events.push({ type: "status", payload: { state: "saving", message: "Saving session..." } as AgentStatus });
+        break;
+      }
+
+      case "settled": {
+        events.push({ type: "status", payload: { state: "completed" } as AgentStatus });
+        break;
+      }
+
+      case "queue_update": {
+        // Debug channel — not a primary semantic event
+        break;
+      }
+
+      case "agent_end": {
+        events.push({ type: "status", payload: { state: "idle" } as AgentStatus });
+        break;
+      }
+    }
+
+    return events;
+  }
+
+  buildRunResult(state: RunState, turnResult: { aborted: boolean }): AgentRunResult {
+    if (turnResult.aborted) {
+      return {
+        status: "aborted",
+        text: state.text,
+        toolCalls: state.toolCalls,
+        artifacts: state.artifacts,
+        usage: state.usage,
+      };
+    }
+
+    return {
+      status: "completed",
+      message: state.currentMessage ?? undefined,
+      text: state.text,
+      toolCalls: state.toolCalls,
+      artifacts: state.artifacts,
+      usage: state.usage,
+    };
+  }
+
+  private convertWasmMessage(msg: WasmAgentMessage): AgentMessage {
+    const id = `msg-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+    return {
+      id,
+      role: msg.role,
+      content: msg.content.map((c) => this.convertContent(c)),
+      timestamp: Date.now(),
+      tool_call_id: msg.role === "tool_result" ? (msg as unknown as { tool_call_id: string }).tool_call_id : undefined,
+    };
+  }
+
+  private convertContent(c: Content): AgentContentBlock {
+    if (c.type === "text") return { type: "text", text: c.text };
+    if (c.type === "tool_call") return { type: "tool_call", id: c.id, name: c.name, arguments: c.arguments };
+    if (c.type === "image") return { type: "image", mimeType: c.media_type, data: c.data };
+    return { type: "text", text: "" };
+  }
+}

package/sdk/internal/providers/anthropic.ts

@@ -0,0 +1,440 @@
+/**
+ * Anthropic Messages API adapter.
+ *
+ * Converts between Rust agent core message format and the Anthropic Messages API.
+ * Works with any Anthropic-compatible endpoint (including Fireworks.ai).
+ *
+ * This adapter does NOT stream. It makes a single request and returns the full
+ * response as chunks + final result, matching the existing AgentHost pattern.
+ */
+
+import type { ToolDefinition } from "../../../pi_host_web.js";
+import type {
+	AgentMessageShape,
+	ContentBlock,
+	LlmRequest,
+	ProviderResult,
+	TokenUsage,
+} from "./types.ts";
+
+// --- Anthropic API types ---
+
+interface AnthropicMessage {
+	role: "user" | "assistant";
+	content: string | AnthropicContentBlock[];
+}
+
+type AnthropicContentBlock =
+	| { type: "text"; text: string }
+	| {
+			type: "tool_use";
+			id: string;
+			name: string;
+			input: Record<string, unknown>;
+	  }
+	| {
+			type: "tool_result";
+			tool_use_id: string;
+			content: string | AnthropicContentBlock[];
+			is_error?: boolean;
+	  };
+
+interface AnthropicTool {
+	name: string;
+	description: string;
+	input_schema: object;
+}
+
+interface AnthropicResponse {
+	id: string;
+	type: "message";
+	role: "assistant";
+	content: AnthropicContentBlock[];
+	model: string;
+	stop_reason: "end_turn" | "max_tokens" | "stop_sequence" | "tool_use" | null;
+	usage: {
+		input_tokens: number;
+		output_tokens: number;
+		cache_creation_input_tokens?: number;
+		cache_read_input_tokens?: number;
+	};
+}
+
+interface AnthropicError {
+	type: "error";
+	error: { type: string; message: string };
+}
+
+// --- Conversion: Rust messages -> Anthropic messages ---
+
+/**
+ * Convert Rust agent messages to Anthropic Messages API format.
+ *
+ * Anthropic requires that multiple tool_result responses to a single assistant
+ * message with multiple tool_use blocks be grouped into ONE user message
+ * containing an array of tool_result blocks. Sending separate consecutive
+ * user messages each with a single tool_result block triggers an API error:
+ *   "messages: Unexpected role change from user to user"
+ *
+ * See: https://docs.anthropic.com/en/docs/build-with-claude/tool-use#handling-tool-use-and-tool-result-content-blocks
+ */
+export function convertMessages(
+	messages: AgentMessageShape[],
+): AnthropicMessage[] {
+	const result: AnthropicMessage[] = [];
+
+	let i = 0;
+	while (i < messages.length) {
+		const msg = messages[i];
+
+		switch (msg.role) {
+			case "user": {
+				const text = extractText(msg.content);
+				result.push({ role: "user", content: text });
+				i++;
+				break;
+			}
+			case "assistant": {
+				const blocks: AnthropicContentBlock[] = [];
+				for (const block of msg.content) {
+					if (block.type === "text" && block.text !== undefined) {
+						blocks.push({ type: "text", text: block.text });
+					} else if (block.type === "tool_call" && block.id && block.name) {
+						blocks.push({
+							type: "tool_use",
+							id: block.id,
+							name: block.name,
+							input: block.arguments ?? {},
+						});
+					}
+				}
+				result.push({ role: "assistant", content: blocks });
+				i++;
+				break;
+			}
+			case "tool_result": {
+				// Gather consecutive tool_result messages into a single user message.
+				// Anthropic requires all tool_results for a given assistant turn to be
+				// in one user message with an array of tool_result content blocks.
+				const toolResults: AnthropicContentBlock[] = [];
+				while (i < messages.length && messages[i].role === "tool_result") {
+					const tr = messages[i] as Extract<
+						AgentMessageShape,
+						{ role: "tool_result" }
+					>;
+					const text = extractText(tr.content);
+					toolResults.push({
+						type: "tool_result",
+						tool_use_id: tr.tool_call_id,
+						content: text,
+						is_error: tr.is_error,
+					});
+					i++;
+				}
+				result.push({ role: "user", content: toolResults });
+				break;
+			}
+		}
+	}
+
+	return result;
+}
+
+// --- Conversion: Rust tool definitions -> Anthropic tools ---
+
+export function convertTools(tools: ToolDefinition[]): AnthropicTool[] {
+	return tools.map((t) => ({
+		name: t.name,
+		description: `${t.label}: ${t.description}`,
+		input_schema: t.parameters,
+	}));
+}
+
+// --- Conversion: Anthropic response -> Rust LlmResult ---
+
+export function convertResponse(
+	resp: AnthropicResponse,
+	providerName: string,
+	modelId: string,
+): { llmResult: object; chunks: object[] } {
+	const content: ContentBlock[] = [];
+
+	for (const block of resp.content) {
+		if (block.type === "text") {
+			content.push({ type: "text", text: block.text });
+		} else if (block.type === "tool_use") {
+			content.push({
+				type: "tool_call",
+				id: block.id,
+				name: block.name,
+				arguments: block.input,
+			});
+		}
+	}
+
+	const stopReason = resp.stop_reason === "tool_use" ? "tool_use" : "end_turn";
+
+	const usage: TokenUsage = {
+		input: resp.usage.input_tokens,
+		output: resp.usage.output_tokens,
+		cache_read: resp.usage.cache_read_input_tokens ?? 0,
+		cache_write: resp.usage.cache_creation_input_tokens ?? 0,
+		total_tokens: resp.usage.input_tokens + resp.usage.output_tokens,
+	};
+
+	const assistantMsg = {
+		content,
+		api: providerName,
+		provider: providerName,
+		model: modelId,
+		stop_reason: stopReason,
+		error_message: null,
+		timestamp: Date.now(),
+		usage,
+	};
+
+	// Build streaming chunks: a Start chunk + TextDelta chunks for each text block
+	const chunks: object[] = [];
+	chunks.push({
+		kind: "start",
+		content: [{ type: "text", text: "" }],
+		api: providerName,
+		provider: providerName,
+		model: modelId,
+		stop_reason: stopReason,
+		error_message: null,
+		timestamp: 0,
+		usage: {
+			input: 0,
+			output: 0,
+			cache_read: 0,
+			cache_write: 0,
+			total_tokens: 0,
+		},
+	});
+
+	for (const block of resp.content) {
+		if (block.type === "text" && block.text.length > 0) {
+			chunks.push({ kind: "text_delta", text: block.text });
+		}
+	}
+
+	return {
+		llmResult: { Ok: assistantMsg },
+		chunks,
+	};
+}
+
+// --- Main call ---
+
+export interface AnthropicConfig {
+	apiKey: string;
+	baseUrl: string;
+	model: string;
+	maxTokens?: number;
+}
+
+/**
+ * Call the Anthropic Messages API and return a ProviderResult.
+ */
+export async function callAnthropic(
+	request: LlmRequest,
+	config: AnthropicConfig,
+): Promise<ProviderResult> {
+	const log: string[] = [];
+	const providerName = "anthropic";
+
+	const body = {
+		model: config.model,
+		max_tokens: config.maxTokens ?? 4096,
+		system: request.system_prompt,
+		messages: convertMessages(request.messages),
+		tools: convertTools(request.tools),
+	};
+
+	log.push(
+		`anthropic_request: model=${config.model}, messages=${body.messages.length}, tools=${body.tools.length}`,
+	);
+
+	let resp: Response;
+	try {
+		resp = await fetch(`${config.baseUrl}/v1/messages`, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				"x-api-key": config.apiKey,
+				"anthropic-version": "2023-06-01",
+			},
+			body: JSON.stringify(body),
+		});
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		log.push(`anthropic_network_error: ${msg}`);
+		return {
+			llmResult: {
+				Err: { error: { code: "network_error", message: msg }, aborted: false },
+			},
+			chunks: [],
+			log,
+		};
+	}
+
+	if (!resp.ok) {
+		let errorBody: AnthropicError | null = null;
+		try {
+			errorBody = (await resp.json()) as AnthropicError;
+		} catch {
+			// ignore parse failure
+		}
+		const code = `http_${resp.status}`;
+		const message =
+			errorBody?.error?.message ?? `HTTP ${resp.status}: ${resp.statusText}`;
+		log.push(`anthropic_error: ${code} - ${message}`);
+		return {
+			llmResult: {
+				Err: { error: { code, message }, aborted: false },
+			},
+			chunks: [],
+			log,
+		};
+	}
+
+	const data = (await resp.json()) as AnthropicResponse;
+	log.push(
+		`anthropic_response: stop_reason=${data.stop_reason}, content_blocks=${data.content.length}`,
+	);
+
+	const { llmResult, chunks } = convertResponse(
+		data,
+		providerName,
+		config.model,
+	);
+	return { llmResult, chunks, log };
+}
+
+// --- SDK factory ---
+
+import type { AgentModel, ModelRequest, ModelResponse } from "../../types.ts";
+import { createAgentError } from "../../errors.ts";
+
+export function anthropic(config: {
+  apiKey: string;
+  model: string;
+  baseUrl?: string;
+  maxTokens?: number;
+}): AgentModel {
+  const anthropicConfig: AnthropicConfig = {
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl ?? "https://api.anthropic.com",
+    model: config.model,
+    maxTokens: config.maxTokens,
+  };
+
+  return {
+    id: config.model,
+    contextWindow: 200000,
+    maxTokens: config.maxTokens ?? 4096,
+    capabilities: {
+      vision: config.model.includes("vision") || config.model.startsWith("claude-3-5"),
+      jsonMode: true,
+      functionCalling: true,
+      streaming: true,
+    },
+    async generate(request: ModelRequest): Promise<ModelResponse> {
+      const llmRequest = {
+        system_prompt: request.instructions,
+        messages: request.messages.map((msg): AgentMessageShape => {
+          const content = msg.content.map((c): ContentBlock => {
+            if (c.type === "text") return { type: "text", text: c.text };
+            if (c.type === "tool_call") return { type: "tool_call", id: c.id, name: c.name, arguments: c.arguments as Record<string, unknown> };
+            if (c.type === "image") return { type: "image", media_type: c.mimeType, data: c.data };
+            return { type: "text", text: "" };
+          });
+          const timestamp = msg.timestamp ?? Date.now();
+          if (msg.role === "user") {
+            return { role: "user", content, timestamp };
+          }
+          if (msg.role === "assistant") {
+            return {
+              role: "assistant",
+              content,
+              api: "sdk",
+              provider: "sdk",
+              model: request.tools[0]?.name ?? "sdk-model",
+              stop_reason: "end_turn",
+              error_message: null,
+              timestamp,
+              usage: { input: 0, output: 0, cache_read: 0, cache_write: 0, total_tokens: 0 },
+            };
+          }
+          // tool_result
+          return {
+            role: "tool_result",
+            tool_call_id: msg.tool_call_id ?? "",
+            tool_name: msg.content.find((c) => c.type === "text")?.text?.slice(0, 50) ?? "unknown",
+            content,
+            details: {},
+            is_error: false,
+            timestamp,
+          };
+        }),
+        tools: request.tools.map((t) => ({
+          name: t.name,
+          label: t.name,
+          description: t.description,
+          parameters: t.inputSchema as object,
+          execution_mode: "parallel" as const,
+        })),
+      };
+
+      try {
+        const result = await callAnthropic(llmRequest, anthropicConfig);
+
+        if ("Err" in result.llmResult) {
+          const err = (result.llmResult as { Err: { error: { code: string; message: string } } }).Err.error;
+          throw createAgentError(
+            err.code === "network_error" ? "model_unavailable" :
+            err.code.startsWith("http_401") ? "model_auth_failed" :
+            err.code.startsWith("http_429") ? "model_rate_limited" :
+            "model_unavailable",
+            err.message,
+            { recoverable: err.code === "http_429" },
+          );
+        }
+
+        const ok = (result.llmResult as { Ok: object }).Ok as {
+          content: Array<{ type: string; text?: string; id?: string; name?: string; arguments?: unknown }>;
+          stop_reason: string;
+          usage?: { input: number; output: number; cache_read: number; cache_write: number; total_tokens: number };
+        };
+
+        return {
+          content: ok.content.map((b) => {
+            if (b.type === "text") return { type: "text", text: b.text ?? "" };
+            if (b.type === "tool_call") return { type: "tool_call", id: b.id ?? "", name: b.name ?? "", arguments: b.arguments ?? {} };
+            return { type: "text", text: "" };
+          }),
+          stopReason: ok.stop_reason === "tool_use" ? "tool_call" : "end",
+          usage: ok.usage,
+          model: config.model,
+          raw: result,
+        };
+      } 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 });
+      }
+    },
+  };
+}
+
+// --- Helpers ---
+
+function extractText(content: ContentBlock[]): string {
+	return content
+		.filter(
+			(b): b is typeof b & { text: string } =>
+				b.type === "text" && b.text !== undefined,
+		)
+		.map((b) => b.text)
+		.join("\n");
+}