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

package/package.json

@@ -5,33 +5,20 @@
     "Irving Ou <irving@pi-oxide.dev>"
   ],
   "description": "WASM host for pi-core. Browser FileSystem Access API, fetch(), JS event loop.",
-  "version": "0.3.1",
+  "version": "0.5.0",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/pi-oxide/pi-oxide"
+    "url": "git+https://github.com/pi-oxide/pi-oxide.git"
   },
   "files": [
     "pi_host_web_bg.wasm",
     "pi_host_web.js",
-    "pi_host_web.d.ts",
-    "sdk/index.js",
-    "sdk/index.d.ts"
+    "pi_host_web.d.ts"
   ],
   "main": "pi_host_web.js",
   "types": "pi_host_web.d.ts",
   "sideEffects": [
     "./snippets/*"
-  ],
-  "exports": {
-    ".": {
-      "import": "./sdk/index.js",
-      "types": "./sdk/index.d.ts"
-    },
-    "./raw": {
-      "import": "./pi_host_web.js",
-      "types": "./pi_host_web.d.ts"
-    },
-    "./package.json": "./package.json"
-  }
+  ]
 }

package/pi_host_web.d.ts

@@ -10,30 +10,20 @@ export interface AgentOptions {
     system_prompt: string;
     model: Model;
     thinking_level?: ThinkingLevel;
-    tools?: ToolDefinition[];
     steering_mode?: QueueMode;
     follow_up_mode?: QueueMode;
-    tool_execution_mode?: ToolExecutionMode;
+    tool_execution_mode?: ExecutionMode;
     session_id?: SessionId;
-    messages?: AgentMessage[];
-    session_state?: SessionState | null;
 }
 
-export interface AgentState {
-    system_prompt: string;
-    model: Model;
-    thinking_level: ThinkingLevel;
-    tools: ToolDefinition[];
-    messages: AgentMessage[];
-    is_streaming: boolean;
-    streaming_message?: AgentMessage;
-    pending_tool_calls: string[];
-    error_message?: string;
+export interface ArtifactSearchResult {
+    id: string;
+    snippet: string;
+    match_count: number;
 }
 
-export interface ApiUsageSnapshot {
-    estimated_tokens: number;
-    actual_input_tokens: number;
+export interface ArtifactSearchResults {
+    results: ArtifactSearchResult[];
 }
 
 export interface AssistantMessage {
@@ -47,49 +37,30 @@ export interface AssistantMessage {
     usage: TokenUsage;
 }
 
-export interface BranchSummary {
-    summary: string;
-    details?: JsonSchema;
-}
-
 export interface ContextProjectionBudget {
-    max_tool_result_chars: number;
-    max_context_tokens: number;
-    default_preview_chars: number;
+    max_tool_result_chars?: number;
+    max_context_tokens?: number;
     microcompact_after_turns?: number;
     compaction_threshold?: number;
 }
 
-export interface ContextProjectionReport {
-    estimated_tokens: number;
-    replacements: ContextReplacement[];
-    dropped_messages: number;
-    needs_compaction?: boolean;
-    cache_breakpoints?: number[];
-}
-
-export interface ContextProjectionState {
-    replacements: Record<string, ContextReplacement>;
-    last_api_usage?: ApiUsageSnapshot | null;
-    turns_since_compaction?: number;
+export interface CreateHostAgentOutput {
+    handle: number;
 }
 
-export interface ContextReplacement {
-    tool_call_id: string;
-    tool_name: string;
-    artifact_id: string;
-    original_chars: number;
-    preview_chars: number;
-    strategy: ContextStrategy;
+export interface CreateHostAgentResult {
+    ok: boolean;
+    data?: CreateHostAgentOutput;
+    error?: ErrorDto;
 }
 
-export interface CreateAgentOutput {
+export interface CreateHostStateOutput {
     handle: number;
 }
 
-export interface CreateAgentResult {
+export interface CreateHostStateResult {
     ok: boolean;
-    data?: CreateAgentOutput;
+    data?: CreateHostStateOutput;
     error?: ErrorDto;
 }
 
@@ -118,13 +89,13 @@ export interface EstimateTokensResult {
     error?: ErrorDto;
 }
 
-export interface EventsOutput {
-    events: AgentEvent[];
+export interface HostStatePersistDataOutput {
+    state: PersistData;
 }
 
-export interface EventsResult {
+export interface HostStatePersistDataResult {
     ok: boolean;
-    data?: EventsOutput;
+    data?: HostStatePersistDataOutput;
     error?: ErrorDto;
 }
 
@@ -172,87 +143,19 @@ export interface ModelCost {
     cache_write: number;
 }
 
-export interface MoveToOutput {
-    summary_entry_id: string | null;
-}
-
-export interface MoveToResult {
-    ok: boolean;
-    data?: MoveToOutput;
-    error?: ErrorDto;
-}
-
-export interface ProjectionInput {
-    system_prompt: string;
-    messages: AgentMessage[];
-    budget: ContextProjectionBudget;
-    state: ContextProjectionState;
-}
-
-export interface ProjectionOutput {
-    projected_messages: AgentMessage[];
-    updated_state: ContextProjectionState;
-    report: ContextProjectionReport;
-}
-
-export interface ProjectionResult {
-    ok: boolean;
-    data?: ProjectionOutput;
-    error?: ErrorDto;
-}
-
-export interface SessionBranchOutput {
-    entries: SessionEntry[];
-}
-
-export interface SessionBranchResult {
-    ok: boolean;
-    data?: SessionBranchOutput;
-    error?: ErrorDto;
-}
-
-export interface SessionEntry {
-    id: string;
-    parent_id?: string;
-    kind: EntryKind;
-    timestamp: number;
+export interface PersistData {
+    T?: Value;
+    A?: Value;
+    turn_number?: number;
+    host_artifacts?: [string, string][];
+    budget?: ContextProjectionBudget;
+    system_prompt?: string;
+    compaction_prompt?: string;
 }
 
-export interface SessionState {
-    entries: SessionEntry[];
-    leaf_id: string;
-    name?: string;
-}
-
-export interface SessionStateOutput {
-    state: SessionState;
-}
-
-export interface SessionStateResult {
-    ok: boolean;
-    data?: SessionStateOutput;
-    error?: ErrorDto;
-}
-
-export interface StateOutput {
-    state: AgentState;
-}
-
-export interface StateResult {
-    ok: boolean;
-    data?: StateOutput;
-    error?: ErrorDto;
-}
-
-export interface StepOutput {
-    events: AgentEvent[];
-    actions: AgentAction[];
-}
-
-export interface StepResult {
-    ok: boolean;
-    data?: StepOutput;
-    error?: ErrorDto;
+export interface StartTurnInput {
+    prompt: AgentMessage;
+    tools?: ToolDefinition[];
 }
 
 export interface TextContent {
@@ -273,12 +176,19 @@ export interface ToolCall {
     arguments: ToolArguments;
 }
 
+export interface ToolCallPreparation {
+    tool_call_id: ToolCallId;
+    transform: ToolCallTransform;
+    permission: ToolCallPermission;
+}
+
 export interface ToolDefinition {
     name: ToolName;
     label: string;
     description: string;
     parameters: JsonSchema;
     execution_mode?: ExecutionMode;
+    tool_run_mode?: ToolRunMode;
 }
 
 export interface ToolError {
@@ -301,15 +211,6 @@ export interface ToolResult {
     terminate?: boolean;
 }
 
-export interface ToolResultContext {
-    content_kind: ContentKind;
-    strategy: ContextStrategy;
-    original_chars: number;
-    truncated_by_tool: boolean;
-    path?: string;
-    exit_code?: number;
-}
-
 export interface ToolResultMessage {
     tool_call_id: ToolCallId;
     tool_name: ToolName;
@@ -319,14 +220,24 @@ export interface ToolResultMessage {
     timestamp: number;
 }
 
+export interface TurnResultOutput {
+    events: AgentEvent[];
+    directives: HostDirective[];
+    markers?: ChangeMarkerDto[];
+}
+
+export interface TurnResultResult {
+    ok: boolean;
+    data?: TurnResultOutput;
+    error?: ErrorDto;
+}
+
 export interface UserMessage {
     content: Content[];
     timestamp: number;
 }
 
-export type AgentAction = { type: "stream_llm"; context: LlmContext; session_id?: SessionId } | { type: "execute_tools"; calls: ToolCall[] } | { type: "cancel_tools"; tool_call_ids: ToolCallId[]; reason: CancelReason } | { type: "wait_for_input"; mode: WaitMode } | { type: "finished"; messages: AgentMessage[] };
-
-export type AgentEvent = { type: "agent_start" } | { type: "agent_end"; messages: AgentMessage[] } | { type: "turn_start" } | { type: "turn_end"; message: AgentMessage; tool_results: ToolResultMessage[] } | { type: "message_start"; message: AgentMessage } | { type: "message_update"; message: AgentMessage; delta: ContentDelta } | { type: "message_end"; message: AgentMessage } | { type: "tool_execution_start"; tool_call_id: ToolCallId; tool_name: ToolName; args?: ToolArguments } | { type: "tool_execution_update"; tool_call_id: ToolCallId; stream: ToolOutputStream; chunk: string; sequence: number; timestamp: number } | { type: "tool_execution_end"; tool_call_id: ToolCallId; result: ToolResult; is_error: boolean } | { type: "tool_execution_cancelled"; tool_call_id: ToolCallId; reason: CancelReason } | { type: "queue_update"; steer: AgentMessage[]; follow_up: AgentMessage[] } | { type: "save_point"; had_pending_writes: boolean } | { type: "settled" };
+export type AgentEvent = { type: "agent_start" } | { type: "agent_end" } | { type: "turn_start" } | { type: "turn_end"; message: AgentMessage; tool_results: ToolResultMessage[] } | { type: "message_start"; message: AgentMessage } | { type: "message_update"; message: AgentMessage; delta: ContentDelta } | { type: "message_end"; message: AgentMessage } | { type: "tool_execution_start"; tool_call_id: ToolCallId; tool_name: ToolName; args?: ToolArguments } | { type: "tool_execution_update"; tool_call_id: ToolCallId; stream: ToolOutputStream; chunk: string; sequence: number; timestamp: number } | { type: "tool_execution_end"; tool_call_id: ToolCallId; tool_name: ToolName; result: ToolResult; args?: ToolArguments; is_error: boolean } | { type: "tool_execution_cancelled"; tool_call_id: ToolCallId; reason: CancelReason } | { type: "queue_update"; steer: AgentMessage[]; follow_up: AgentMessage[] } | { type: "save_point"; had_pending_writes: boolean } | { type: "settled" };
 
 export type AgentMessage = ({ role: "user" } & UserMessage) | ({ role: "assistant" } & AssistantMessage) | ({ role: "tool_result" } & ToolResultMessage);
 
@@ -334,18 +245,16 @@ export type ApiName = string;
 
 export type CancelReason = { type: "user_requested" } | { type: "timeout" } | { type: "agent_aborted" } | { type: "dependency_failed"; cause_tool_call_id: ToolCallId };
 
+export type ChangeMarkerDto = { type: "compaction_applied" } | { type: "new_artifacts"; entry_ids: string[] };
+
 export type Content = ({ type: "text" } & TextContent) | ({ type: "image" } & ImageContent) | ({ type: "tool_call" } & ToolCall);
 
 export type ContentDelta = { kind: "text_start" } | { kind: "text_delta"; text: string } | { kind: "text_end" } | { kind: "thinking_start" } | { kind: "thinking_delta"; text: string } | { kind: "thinking_end" } | { kind: "tool_call_start"; tool_call: ToolCall } | { kind: "tool_call_delta"; tool_call_id: ToolCallId; delta: Value } | { kind: "tool_call_end"; tool_call_id: ToolCallId };
 
-export type ContentKind = "file_read" | "command_output" | "diff" | "search_results" | "directory_listing" | "generic_text";
-
-export type ContextStrategy = { type: "keep_full" } | { type: "head"; max_chars: number } | { type: "tail"; max_chars: number } | { type: "head_tail"; head_chars: number; tail_chars: number } | { type: "drop_if_old" } | { type: "microcompacted" };
-
-export type EntryKind = ({ type: "message" } & {} & AgentMessage) | { type: "compaction"; summary: string; first_kept_entry_id: string; tokens_before: number; details?: JsonSchema } | { type: "branch_summary"; summary: string; details?: JsonSchema } | { type: "model_change"; provider: string; model_id: string } | ({ type: "thinking_level_change" } & ThinkingLevel) | { type: "custom"; custom_type: string; data?: JsonSchema };
-
 export type ExecutionMode = "parallel" | "sequential";
 
+export type HostDirective = { type: "stream_llm"; context: LlmContext } | { type: "prepare_tool_calls"; calls: ToolCall[] } | { type: "execute_tools"; calls: ToolCall[] } | { type: "cancel_tools"; tool_call_ids: ToolCallId[]; reason: CancelReason } | { type: "persist" } | { type: "summarize"; context: LlmContext } | { type: "finished" } | { type: "wait_for_input"; mode: WaitMode };
+
 export type JsonSchema = Value;
 
 export type LlmChunk = ({ kind: "start" } & {} & AssistantMessage) | { kind: "text_delta"; text: string } | { kind: "thinking_delta"; text: string } | { kind: "tool_call_delta"; tool_call_id: ToolCallId; delta: Value } | { kind: "done" } | { kind: "error"; message: string };
@@ -358,10 +267,6 @@ export type ModelName = string;
 
 export type ModelProvider = "open_ai" | "anthropic" | "google" | "ollama" | "custom";
 
-export type Phase = "idle" | "streaming" | "wait_for_input";
-
-export type PromptRequest = AgentMessage | { text: string };
-
 export type ProviderName = string;
 
 export type QueueMode = "one_at_a_time" | "all";
@@ -376,104 +281,110 @@ export type ToolArguments = Value;
 
 export type ToolCallId = string;
 
-export type ToolDetails = Value;
+export type ToolCallPermission = { type: "allow" } | { type: "block"; reason: string };
 
-export type ToolDonePayload = { error: ToolError } | { result: ToolResult } | ToolResult;
+export type ToolCallTransform = { type: "none" } | { type: "rewrite_args"; arguments: ToolArguments };
 
-export type ToolExecutionMode = "parallel" | "sequential";
+export type ToolDetails = Value;
 
 export type ToolName = string;
 
 export type ToolOutputStream = "stdout" | "stderr" | "status";
 
-export type WaitMode = "steering" | "follow_up" | "any";
+export type ToolRunMode = "immediate" | "deferred";
 
+export type WaitMode = "steering" | "follow_up" | "any";
 
-export function abort(handle: number): StepResult;
 
-export function appendSessionEntry(handle: number, entry: SessionEntry): EmptyResult;
+export function createHostAgent(options: AgentOptions, budget: ContextProjectionBudget): CreateHostAgentResult;
 
-export function continueTurn(handle: number): StepResult;
+export function createHostState(_budget: ContextProjectionBudget): CreateHostStateResult;
 
-export function createAgent(options: AgentOptions): CreateAgentResult;
+export function destroyHostAgent(handle: number): EmptyResult;
 
-export function destroyAgent(handle: number): EmptyResult;
+export function destroyHostState(handle: number): EmptyResult;
 
 export function estimateTokens(input: EstimateTokensInput): EstimateTokensResult;
 
 export function estimateTokensForText(text: string): EstimateTokensResult;
 
-export function fallbackStrategy(tool_name: string): ContextStrategy;
+export function getHostAgentPersistData(handle: number): HostStatePersistDataResult;
 
-export function feedLlmChunk(handle: number, chunk: LlmChunk): EventsResult;
+export function getHostStatePersistData(handle: number): HostStatePersistDataResult;
 
-export function followUp(handle: number, message: AgentMessage): EmptyResult;
+export function hostAbort(handle: number): TurnResultResult;
 
-export function getSessionBranch(handle: number): SessionBranchResult;
+export function hostAcceptCompaction(handle: number, summary: string, _compacted_entry_ids: string[]): TurnResultResult;
 
-export function getSessionState(handle: number): SessionStateResult;
+export function hostContinueTurn(handle: number): TurnResultResult;
 
-export function moveTo(handle: number, target_id: string, summary?: BranchSummary | null): MoveToResult;
+export function hostFeedLlmChunk(handle: number, chunk: LlmChunk): TurnResultResult;
 
-export function onLlmDone(handle: number, result: LlmResult): StepResult;
+export function hostLlmDone(handle: number, result: LlmResult): TurnResultResult;
 
-export function onToolCancelled(handle: number, tool_call_id: string, reason: CancelReason): StepResult;
+export function hostPrepareToolCalls(handle: number, preparations_json: string): TurnResultResult;
 
-export function onToolDone(handle: number, tool_call_id: string, payload: ToolDonePayload): StepResult;
+export function hostReadArtifact(handle: number, artifact_id: string): string;
 
-export function onToolStarted(handle: number, tool_call_id: string): EventsResult;
+export function hostReset(handle: number): EmptyResult;
 
-export function onToolUpdate(handle: number, update: ToolExecutionUpdate): EventsResult;
+export function hostSearchArtifacts(handle: number, query: string): ArtifactSearchResults;
 
-export function projectContext(input: ProjectionInput): ProjectionResult;
+export function hostSteer(handle: number, message: AgentMessage): TurnResultResult;
 
-export function prompt(handle: number, prompt: PromptRequest): StepResult;
+export function hostToolCancelled(handle: number, tool_call_id: string, reason: CancelReason): TurnResultResult;
 
-export function reset(handle: number): EmptyResult;
+export function hostToolDone(handle: number, id: ToolCallId, result: ToolResult): TurnResultResult;
 
-export function setLogLevel(level: string): void;
+export function hostToolFailed(handle: number, id: ToolCallId, error: ToolError): TurnResultResult;
+
+export function restoreHostAgent(options: AgentOptions, data: PersistData): CreateHostAgentResult;
 
-export function setSessionState(handle: number, state: SessionState): EmptyResult;
+export function restoreHostState(data: PersistData): CreateHostStateResult;
 
-export function state(handle: number): StateResult;
+export function restoreHostStateFromJson(json: string): CreateHostStateResult;
+
+export function setLogLevel(level: string): void;
 
-export function steer(handle: number, message: AgentMessage): EventsResult;
+export function startTurn(handle: number, input: StartTurnInput): TurnResultResult;
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
-    readonly abort: (a: number) => any;
-    readonly appendSessionEntry: (a: number, b: any) => any;
-    readonly continueTurn: (a: number) => any;
-    readonly createAgent: (a: any) => any;
-    readonly destroyAgent: (a: number) => any;
+    readonly createHostState: (a: any) => any;
+    readonly destroyHostState: (a: number) => any;
     readonly estimateTokens: (a: any) => any;
     readonly estimateTokensForText: (a: number, b: number) => any;
-    readonly fallbackStrategy: (a: number, b: number) => any;
-    readonly feedLlmChunk: (a: number, b: any) => any;
-    readonly followUp: (a: number, b: any) => any;
-    readonly getSessionBranch: (a: number) => any;
-    readonly getSessionState: (a: number) => any;
-    readonly moveTo: (a: number, b: number, c: number, d: number) => any;
-    readonly onLlmDone: (a: number, b: any) => any;
-    readonly onToolCancelled: (a: number, b: number, c: number, d: any) => any;
-    readonly onToolDone: (a: number, b: number, c: number, d: any) => any;
-    readonly onToolStarted: (a: number, b: number, c: number) => any;
-    readonly onToolUpdate: (a: number, b: any) => any;
-    readonly projectContext: (a: any) => any;
-    readonly prompt: (a: number, b: any) => any;
-    readonly reset: (a: number) => any;
+    readonly getHostStatePersistData: (a: number) => any;
+    readonly restoreHostState: (a: any) => any;
+    readonly restoreHostStateFromJson: (a: number, b: number) => any;
     readonly setLogLevel: (a: number, b: number) => void;
-    readonly setSessionState: (a: number, b: any) => any;
-    readonly state: (a: number) => any;
-    readonly steer: (a: number, b: any) => any;
+    readonly hostReadArtifact: (a: number, b: number, c: number) => [number, number, number, number];
+    readonly hostSearchArtifacts: (a: number, b: number, c: number) => [number, number, number];
+    readonly createHostAgent: (a: any, b: any) => any;
+    readonly destroyHostAgent: (a: number) => any;
+    readonly getHostAgentPersistData: (a: number) => any;
+    readonly hostAbort: (a: number) => any;
+    readonly hostAcceptCompaction: (a: number, b: number, c: number, d: number, e: number) => any;
+    readonly hostContinueTurn: (a: number) => any;
+    readonly hostFeedLlmChunk: (a: number, b: any) => any;
+    readonly hostLlmDone: (a: number, b: any) => any;
+    readonly hostPrepareToolCalls: (a: number, b: number, c: number) => any;
+    readonly hostReset: (a: number) => any;
+    readonly hostSteer: (a: number, b: any) => any;
+    readonly hostToolCancelled: (a: number, b: number, c: number, d: any) => any;
+    readonly hostToolDone: (a: number, b: any, c: any) => any;
+    readonly hostToolFailed: (a: number, b: any, c: any) => any;
+    readonly restoreHostAgent: (a: any, b: any) => any;
+    readonly startTurn: (a: number, b: any) => any;
     readonly __wbindgen_malloc: (a: number, b: number) => number;
     readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_free: (a: number, b: number, c: number) => void;
     readonly __wbindgen_exn_store: (a: number) => void;
     readonly __externref_table_alloc: () => number;
     readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __externref_table_dealloc: (a: number) => void;
     readonly __wbindgen_start: () => void;
 }
 

package/pi_host_web.js

@@ -1,39 +1,30 @@
 /* @ts-self-types="./pi_host_web.d.ts" */
 
 /**
- * @param {number} handle
- * @returns {StepResult}
+ * @param {AgentOptions} options
+ * @param {ContextProjectionBudget} budget
+ * @returns {CreateHostAgentResult}
  */
-export function abort(handle) {
-    const ret = wasm.abort(handle);
+export function createHostAgent(options, budget) {
+    const ret = wasm.createHostAgent(options, budget);
     return ret;
 }
 
 /**
- * @param {number} handle
- * @param {SessionEntry} entry
- * @returns {EmptyResult}
+ * @param {ContextProjectionBudget} _budget
+ * @returns {CreateHostStateResult}
  */
-export function appendSessionEntry(handle, entry) {
-    const ret = wasm.appendSessionEntry(handle, entry);
+export function createHostState(_budget) {
+    const ret = wasm.createHostState(_budget);
     return ret;
 }
 
 /**
  * @param {number} handle
- * @returns {StepResult}
- */
-export function continueTurn(handle) {
-    const ret = wasm.continueTurn(handle);
-    return ret;
-}
-
-/**
- * @param {AgentOptions} options
- * @returns {CreateAgentResult}
+ * @returns {EmptyResult}
  */
-export function createAgent(options) {
-    const ret = wasm.createAgent(options);
+export function destroyHostAgent(handle) {
+    const ret = wasm.destroyHostAgent(handle);
     return ret;
 }
 
@@ -41,8 +32,8 @@ export function createAgent(options) {
  * @param {number} handle
  * @returns {EmptyResult}
  */
-export function destroyAgent(handle) {
-    const ret = wasm.destroyAgent(handle);
+export function destroyHostState(handle) {
+    const ret = wasm.destroyHostState(handle);
     return ret;
 }
 
@@ -67,193 +58,241 @@ export function estimateTokensForText(text) {
 }
 
 /**
- * @param {string} tool_name
- * @returns {ContextStrategy}
+ * @param {number} handle
+ * @returns {HostStatePersistDataResult}
  */
-export function fallbackStrategy(tool_name) {
-    const ptr0 = passStringToWasm0(tool_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.fallbackStrategy(ptr0, len0);
+export function getHostAgentPersistData(handle) {
+    const ret = wasm.getHostAgentPersistData(handle);
     return ret;
 }
 
 /**
  * @param {number} handle
- * @param {LlmChunk} chunk
- * @returns {EventsResult}
+ * @returns {HostStatePersistDataResult}
  */
-export function feedLlmChunk(handle, chunk) {
-    const ret = wasm.feedLlmChunk(handle, chunk);
+export function getHostStatePersistData(handle) {
+    const ret = wasm.getHostStatePersistData(handle);
     return ret;
 }
 
 /**
  * @param {number} handle
- * @param {AgentMessage} message
- * @returns {EmptyResult}
+ * @returns {TurnResultResult}
  */
-export function followUp(handle, message) {
-    const ret = wasm.followUp(handle, message);
+export function hostAbort(handle) {
+    const ret = wasm.hostAbort(handle);
     return ret;
 }
 
 /**
  * @param {number} handle
- * @returns {SessionBranchResult}
+ * @param {string} summary
+ * @param {string[]} _compacted_entry_ids
+ * @returns {TurnResultResult}
  */
-export function getSessionBranch(handle) {
-    const ret = wasm.getSessionBranch(handle);
+export function hostAcceptCompaction(handle, summary, _compacted_entry_ids) {
+    const ptr0 = passStringToWasm0(summary, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayJsValueToWasm0(_compacted_entry_ids, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.hostAcceptCompaction(handle, ptr0, len0, ptr1, len1);
     return ret;
 }
 
 /**
  * @param {number} handle
- * @returns {SessionStateResult}
+ * @returns {TurnResultResult}
  */
-export function getSessionState(handle) {
-    const ret = wasm.getSessionState(handle);
+export function hostContinueTurn(handle) {
+    const ret = wasm.hostContinueTurn(handle);
     return ret;
 }
 
 /**
  * @param {number} handle
- * @param {string} target_id
- * @param {BranchSummary | null} [summary]
- * @returns {MoveToResult}
+ * @param {LlmChunk} chunk
+ * @returns {TurnResultResult}
  */
-export function moveTo(handle, target_id, summary) {
-    const ptr0 = passStringToWasm0(target_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.moveTo(handle, ptr0, len0, isLikeNone(summary) ? 0 : addToExternrefTable0(summary));
+export function hostFeedLlmChunk(handle, chunk) {
+    const ret = wasm.hostFeedLlmChunk(handle, chunk);
     return ret;
 }
 
 /**
  * @param {number} handle
  * @param {LlmResult} result
- * @returns {StepResult}
+ * @returns {TurnResultResult}
  */
-export function onLlmDone(handle, result) {
-    const ret = wasm.onLlmDone(handle, result);
+export function hostLlmDone(handle, result) {
+    const ret = wasm.hostLlmDone(handle, result);
     return ret;
 }
 
 /**
  * @param {number} handle
- * @param {string} tool_call_id
- * @param {CancelReason} reason
- * @returns {StepResult}
+ * @param {string} preparations_json
+ * @returns {TurnResultResult}
  */
-export function onToolCancelled(handle, tool_call_id, reason) {
-    const ptr0 = passStringToWasm0(tool_call_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+export function hostPrepareToolCalls(handle, preparations_json) {
+    const ptr0 = passStringToWasm0(preparations_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.onToolCancelled(handle, ptr0, len0, reason);
+    const ret = wasm.hostPrepareToolCalls(handle, ptr0, len0);
     return ret;
 }
 
 /**
  * @param {number} handle
- * @param {string} tool_call_id
- * @param {ToolDonePayload} payload
- * @returns {StepResult}
+ * @param {string} artifact_id
+ * @returns {string}
  */
-export function onToolDone(handle, tool_call_id, payload) {
-    const ptr0 = passStringToWasm0(tool_call_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.onToolDone(handle, ptr0, len0, payload);
+export function hostReadArtifact(handle, artifact_id) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(artifact_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.hostReadArtifact(handle, ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * @param {number} handle
+ * @returns {EmptyResult}
+ */
+export function hostReset(handle) {
+    const ret = wasm.hostReset(handle);
     return ret;
 }
 
 /**
  * @param {number} handle
- * @param {string} tool_call_id
- * @returns {EventsResult}
+ * @param {string} query
+ * @returns {ArtifactSearchResults}
  */
-export function onToolStarted(handle, tool_call_id) {
-    const ptr0 = passStringToWasm0(tool_call_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+export function hostSearchArtifacts(handle, query) {
+    const ptr0 = passStringToWasm0(query, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.onToolStarted(handle, ptr0, len0);
-    return ret;
+    const ret = wasm.hostSearchArtifacts(handle, ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
 }
 
 /**
  * @param {number} handle
- * @param {ToolExecutionUpdate} update
- * @returns {EventsResult}
+ * @param {AgentMessage} message
+ * @returns {TurnResultResult}
  */
-export function onToolUpdate(handle, update) {
-    const ret = wasm.onToolUpdate(handle, update);
+export function hostSteer(handle, message) {
+    const ret = wasm.hostSteer(handle, message);
     return ret;
 }
 
 /**
- * @param {ProjectionInput} input
- * @returns {ProjectionResult}
+ * @param {number} handle
+ * @param {string} tool_call_id
+ * @param {CancelReason} reason
+ * @returns {TurnResultResult}
  */
-export function projectContext(input) {
-    const ret = wasm.projectContext(input);
+export function hostToolCancelled(handle, tool_call_id, reason) {
+    const ptr0 = passStringToWasm0(tool_call_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.hostToolCancelled(handle, ptr0, len0, reason);
     return ret;
 }
 
 /**
  * @param {number} handle
- * @param {PromptRequest} prompt
- * @returns {StepResult}
+ * @param {ToolCallId} id
+ * @param {ToolResult} result
+ * @returns {TurnResultResult}
  */
-export function prompt(handle, prompt) {
-    const ret = wasm.prompt(handle, prompt);
+export function hostToolDone(handle, id, result) {
+    const ret = wasm.hostToolDone(handle, id, result);
     return ret;
 }
 
 /**
  * @param {number} handle
- * @returns {EmptyResult}
+ * @param {ToolCallId} id
+ * @param {ToolError} error
+ * @returns {TurnResultResult}
  */
-export function reset(handle) {
-    const ret = wasm.reset(handle);
+export function hostToolFailed(handle, id, error) {
+    const ret = wasm.hostToolFailed(handle, id, error);
     return ret;
 }
 
 /**
- * @param {string} level
+ * @param {AgentOptions} options
+ * @param {PersistData} data
+ * @returns {CreateHostAgentResult}
  */
-export function setLogLevel(level) {
-    const ptr0 = passStringToWasm0(level, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    wasm.setLogLevel(ptr0, len0);
+export function restoreHostAgent(options, data) {
+    const ret = wasm.restoreHostAgent(options, data);
+    return ret;
 }
 
 /**
- * @param {number} handle
- * @param {SessionState} state
- * @returns {EmptyResult}
+ * @param {PersistData} data
+ * @returns {CreateHostStateResult}
  */
-export function setSessionState(handle, state) {
-    const ret = wasm.setSessionState(handle, state);
+export function restoreHostState(data) {
+    const ret = wasm.restoreHostState(data);
     return ret;
 }
 
 /**
- * @param {number} handle
- * @returns {StateResult}
+ * @param {string} json
+ * @returns {CreateHostStateResult}
  */
-export function state(handle) {
-    const ret = wasm.state(handle);
+export function restoreHostStateFromJson(json) {
+    const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.restoreHostStateFromJson(ptr0, len0);
     return ret;
 }
 
+/**
+ * @param {string} level
+ */
+export function setLogLevel(level) {
+    const ptr0 = passStringToWasm0(level, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    wasm.setLogLevel(ptr0, len0);
+}
+
 /**
  * @param {number} handle
- * @param {AgentMessage} message
- * @returns {EventsResult}
+ * @param {StartTurnInput} input
+ * @returns {TurnResultResult}
  */
-export function steer(handle, message) {
-    const ret = wasm.steer(handle, message);
+export function startTurn(handle, input) {
+    const ret = wasm.startTurn(handle, input);
     return ret;
 }
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
+        __wbg___wbindgen_debug_string_0accd80f45e5faa2: function(arg0, arg1) {
+            const ret = debugString(arg1);
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
         __wbg___wbindgen_is_undefined_67b456be8673d3d7: function(arg0) {
             const ret = arg0 === undefined;
             return ret;
@@ -325,10 +364,17 @@ function __wbg_get_imports() {
             const ret = new Error();
             return ret;
         },
+        __wbg_new_ce1ab61c1c2b300d: function() {
+            const ret = new Object();
+            return ret;
+        },
         __wbg_parse_03863847d06c4e89: function() { return handleError(function (arg0, arg1) {
             const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
             return ret;
         }, arguments); },
+        __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
+            arg0[arg1] = arg2;
+        },
         __wbg_stack_3b0d974bbf31e44f: function(arg0, arg1) {
             const ret = arg1.stack;
             const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -340,6 +386,11 @@ function __wbg_get_imports() {
             const ret = JSON.stringify(arg0);
             return ret;
         }, arguments); },
+        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return ret;
+        },
         __wbindgen_init_externref_table: function() {
             const table = wasm.__wbindgen_externrefs;
             const offset = table.grow(4);
@@ -362,6 +413,71 @@ function addToExternrefTable0(obj) {
     return idx;
 }
 
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
 let cachedDataViewMemory0 = null;
 function getDataViewMemory0() {
     if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
@@ -395,6 +511,16 @@ function isLikeNone(x) {
     return x === undefined || x === null;
 }
 
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    for (let i = 0; i < array.length; i++) {
+        const add = addToExternrefTable0(array[i]);
+        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);
@@ -432,6 +558,12 @@ function passStringToWasm0(arg, malloc, realloc) {
     return ptr;
 }
 
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
 let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
 cachedTextDecoder.decode();
 const MAX_SAFARI_DECODE_BYTES = 2146435072;
@@ -553,4 +685,4 @@ async function __wbg_init(module_or_path) {
     return __wbg_finalize_init(instance, module);
 }
 
-export { initSync, __wbg_init as default };
+export { __wbg_init as default, initSync };

package/sdk/index.d.ts

@@ -1,55 +0,0 @@
-/**
- * High-level JS SDK for @pi-oxide/pi-host-web.
- *
- * Re-exports all raw types so consumers never need to import from ./raw.
- */
-
-export * from "../pi_host_web.js";
-
-export declare function ensureInit(): Promise<void>;
-
-export declare function continueTurn(handle: number): StepResult;
-
-export declare function toolResult(
-  text: string,
-  opts?: { terminate?: boolean }
-): { content: Array<{ type: "text"; text: string }>; terminate?: boolean };
-
-export declare function toolError(
-  code: string,
-  message: string
-): { error: { code: string; message: string } };
-
-export interface LlmStream {
-  chunks: AsyncIterable<LlmChunk>;
-  result: Promise<LlmResult>;
-}
-
-export interface LlmProvider {
-  call(context: LlmContext, signal?: AbortSignal): Promise<LlmStream> | LlmStream;
-}
-
-export type ToolMap = Record<
-  string,
-  (call: ToolCall) => Promise<ToolResult> | ToolResult
->;
-
-export interface AgentRunConfig {
-  llm: LlmProvider;
-  tools: ToolMap;
-  onEvent?: (event: AgentEvent) => void;
-  signal?: AbortSignal;
-}
-
-export declare class Agent {
-  static create(options: AgentOptions): Promise<Agent>;
-  run(promptText: string, config: AgentRunConfig): Promise<AgentAction>;
-  stop(): void;
-  reset(): void;
-  state(): AgentState;
-  getSessionState(): SessionState;
-  setSessionState(sessionState: SessionState): void;
-  steer(message: AgentMessage): AgentEvent[];
-  followUp(message: AgentMessage): void;
-  destroy(): void;
-}

package/sdk/index.js

@@ -1,245 +0,0 @@
-/**
- * High-level JS SDK for @pi-oxide/pi-host-web.
- *
- * Hides WASM loading, numeric handles, and the agent drive-loop.
- * Supports streaming LLM responses and full agent lifecycle.
- *
- * Import from the package root:
- *   import { Agent, toolResult } from "@pi-oxide/pi-host-web";
- */
-
-import {
-  abort,
-  createAgent,
-  continueTurn,
-  destroyAgent,
-  feedLlmChunk,
-  followUp,
-  getSessionState,
-  initSync,
-  onLlmDone,
-  onToolCancelled,
-  onToolDone,
-  onToolStarted,
-  projectContext,
-  prompt,
-  reset,
-  setSessionState,
-  state,
-  steer,
-  default as init,
-} from "../pi_host_web.js";
-
-export { projectContext };
-
-let initialized = false;
-
-/** Ensure the WASM module is loaded. Safe to call multiple times. */
-export async function ensureInit() {
-  if (initialized) return;
-  if (typeof process !== "undefined" && process.versions?.node) {
-    const { readFileSync } = await import("node:fs");
-    const bytes = readFileSync(
-      new URL("../pi_host_web_bg.wasm", import.meta.url)
-    );
-    initSync({ module: bytes });
-  } else {
-    await init();
-  }
-  initialized = true;
-}
-
-class HostError extends Error {
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.name = "HostError";
-  }
-}
-
-function unwrap(result) {
-  if (!result.ok) {
-    throw new HostError(result.error.code, result.error.message);
-  }
-  return result.data;
-}
-
-/** Build a successful tool result payload. */
-export function toolResult(text, opts = {}) {
-  const payload = {
-    content: [{ type: "text", text }],
-  };
-  if (opts.terminate) {
-    payload.terminate = true;
-  }
-  return payload;
-}
-
-/** Build an error tool result payload. */
-export function toolError(code, message) {
-  return { error: { code, message } };
-}
-
-/**
- * High-level agent that manages the WASM handle and drive-loop.
- *
- * Usage:
- *   const agent = await Agent.create(options);
- *   const finalAction = await agent.run("hello", { llm, tools, onEvent });
- *   agent.destroy();
- */
-export class Agent {
-  /** @type {number} */
-  #handle;
-
-  constructor(handle) {
-    this.#handle = handle;
-  }
-
-  /** Create a new agent. Loads WASM on first call automatically. */
-  static async create(options) {
-    await ensureInit();
-    const result = unwrap(createAgent(options));
-    return new Agent(result.handle);
-  }
-
-  /**
-   * Run one user prompt through the full turn loop.
-   *
-   * @param {string} promptText
-   * @param {object} config
-   * @param {LlmProvider} config.llm
-   * @param {Record<string, (call: ToolCall) => Promise<ToolResult> | ToolResult>} config.tools
-   * @param {(event: AgentEvent) => void} [config.onEvent]
-   * @param {AbortSignal} [config.signal] — abort to stop mid-stream or mid-tool
-   * @returns {Promise<AgentAction>} terminal action (finished or wait_for_input)
-   */
-  async run(promptText, config) {
-    const signal = config.signal;
-    const checkAbort = () => {
-      if (signal?.aborted) {
-        this.stop();
-        throw new HostError("user_aborted", "Turn stopped by user");
-      }
-    };
-
-    let step = unwrap(prompt(this.#handle, { text: promptText }));
-    for (const event of step.events) {
-      config.onEvent?.(event);
-    }
-
-    while (true) {
-      checkAbort();
-      let actions = step.actions ?? [];
-      if (actions.length === 0) {
-        return { type: "finished", messages: [] };
-      }
-
-      for (const action of actions) {
-        checkAbort();
-        switch (action.type) {
-          case "stream_llm": {
-            const stream = await config.llm.call(action.context, signal);
-            for await (const chunk of stream.chunks) {
-              checkAbort();
-              const ev = unwrap(feedLlmChunk(this.#handle, chunk));
-              for (const e of ev.events) config.onEvent?.(e);
-            }
-            checkAbort();
-            const result = await stream.result;
-            step = unwrap(onLlmDone(this.#handle, result));
-            for (const e of step.events) config.onEvent?.(e);
-            break;
-          }
-
-          case "execute_tools": {
-            for (const call of action.calls) {
-              checkAbort();
-              const started = unwrap(onToolStarted(this.#handle, call.id));
-              for (const e of started.events) config.onEvent?.(e);
-
-              const handler = config.tools[call.name];
-              let result;
-              if (handler) {
-                result = await handler(call);
-              } else {
-                result = toolError("unknown_tool", `No handler for ${call.name}`);
-              }
-              step = unwrap(onToolDone(this.#handle, call.id, result));
-              for (const e of step.events) config.onEvent?.(e);
-            }
-            if ((step.actions ?? []).length === 0) {
-              step = unwrap(continueTurn(this.#handle));
-              for (const e of step.events) config.onEvent?.(e);
-            }
-            break;
-          }
-
-          case "cancel_tools": {
-            for (const id of action.tool_call_ids) {
-              step = unwrap(
-                onToolCancelled(this.#handle, id, action.reason)
-              );
-              for (const e of step.events) config.onEvent?.(e);
-            }
-            break;
-          }
-
-          case "finished":
-            return action;
-
-          case "wait_for_input":
-            return action;
-
-          default:
-            return action;
-        }
-      }
-    }
-  }
-
-  /** Abort a running turn mid-stream or mid-tool. */
-  stop() {
-    try {
-      unwrap(abort(this.#handle));
-    } catch (e) {
-      if (e.code !== "wrong_phase") throw e;
-    }
-  }
-
-  /** Reset agent state (clear messages, return to idle). */
-  reset() {
-    unwrap(reset(this.#handle));
-  }
-
-  /** Get public agent state. */
-  state() {
-    return unwrap(state(this.#handle));
-  }
-
-  /** Get session state for persistence. */
-  getSessionState() {
-    return unwrap(getSessionState(this.#handle));
-  }
-
-  /** Set session state (e.g. after restoring from storage). */
-  setSessionState(sessionState) {
-    unwrap(setSessionState(this.#handle, sessionState));
-  }
-
-  /** Send a steering message mid-turn. */
-  steer(message) {
-    const out = unwrap(steer(this.#handle, message));
-    return out.events;
-  }
-
-  /** Queue a follow-up message. */
-  followUp(message) {
-    unwrap(followUp(this.#handle, message));
-  }
-
-  /** Destroy the underlying WASM handle. */
-  destroy() {
-    destroyAgent(this.#handle);
-  }
-}