@tyvm/knowhow 0.0.143 → 0.0.145

package/src/clients/qwen.ts

@@ -0,0 +1,16 @@
+import { HttpClient } from "./http";
+import { QwenTextPricing } from "./pricing/qwen";
+
+/**
+ * QWEN Cloud client — OpenAI-compatible API
+ * https://dashscope-intl.aliyuncs.com/compatible-mode/v1
+ * Alibaba Cloud's Qwen model family via the international DashScope endpoint.
+ * Set env var QWEN_CLOUD_API_KEY to enable.
+ */
+export class GenericQwenClient extends HttpClient {
+  constructor(apiKey = process.env.QWEN_CLOUD_API_KEY) {
+    super("https://dashscope-intl.aliyuncs.com/compatible-mode/v1");
+    if (apiKey) this.setJwt(apiKey);
+    this.setPrices(QwenTextPricing);
+  }
+}

package/src/clients/types.ts

@@ -8,7 +8,10 @@ export type ModelModality =
 
 export type MessageContent =
   | { type: "text"; text: string }
-  | { type: "image_url"; image_url: { url: string } }
+  | {
+      type: "image_url";
+      image_url: { url: string; detail?: "auto" | "low" | "high" };
+    }
   | { type: "audio_url"; audio_url: { url: string } }
   | { type: "video_url"; video_url: { url: string } };
 
@@ -23,6 +26,50 @@ export interface Message {
 
 export interface OutputMessage extends Message {
   content?: string | null;
+  /**
+   * The model's reasoning/thinking content, when the provider exposes it.
+   * - OpenAI Responses API: a human-readable summary of the model's reasoning
+   *   (populated when reasoning_summary is requested).
+   */
+  reasoning_summary?: string;
+  /**
+   * OpenAI Responses API only (internal): the raw reasoning output items
+   * (carrying encrypted_content) captured from a stateless response. These are
+   * re-injected into the next request's input to preserve the reasoning chain.
+   * Not intended for display.
+   *
+   * @deprecated Prefer the provider-agnostic `_reasoning_details` slot. This is
+   * retained for backward compatibility with the OpenAI client only.
+   */
+  _reasoning_items?: any[];
+  /**
+   * Provider-agnostic (internal): an opaque, provider-tagged carrier for the
+   * model's reasoning artifact that must be round-tripped verbatim on the next
+   * tool-use turn to preserve reasoning continuity. Each provider stashes its
+   * own native artifact here and re-injects it only when the `provider` tag
+   * matches, so provider-specific payload never leaks into the generic
+   * (OpenAI-format) message shape.
+   *
+   *  - openai / xai: Responses API `reasoning` output items (encrypted_content)
+   *  - anthropic:    `thinking` / `redacted_thinking` blocks (with signature/data)
+   *  - gemini:       `thoughtSignature` strings keyed by tool-call id (+ thought parts)
+   *
+   * Not intended for display.
+   */
+  _reasoning_details?: ReasoningDetails;
+}
+
+/**
+ * Opaque, provider-tagged reasoning artifact. The `items` are provider-native
+ * and only meaningful to the client whose id matches `provider`; any other
+ * client must ignore them (they are never mapped into a foreign provider's
+ * request payload).
+ */
+export interface ReasoningDetails {
+  /** The provider that produced these items, e.g. "openai" | "xai" | "anthropic" | "gemini". */
+  provider: string;
+  /** Provider-native reasoning items to round-trip verbatim on the next turn. */
+  items: any[];
 }
 
 export interface ToolProp {
@@ -30,6 +77,7 @@ export interface ToolProp {
   description?: string;
   properties?: { [key: string]: ToolProp };
   items?: ToolProp;
+  enum?: any[];
 }
 
 export interface Tool {
@@ -114,6 +162,20 @@ export interface CompletionOptions extends RetryOptions {
    * Defaults to false (no summary displayed).
    */
   reasoning_summary?: boolean;
+  /**
+   * OpenAI Responses API only: when true, OpenAI stores the response server-side
+   * so subsequent turns can reference it via `previous_response_id` instead of
+   * resending the full reasoning/message history. Defaults to false (stateless).
+   * When false, the client automatically requests `reasoning.encrypted_content`
+   * and threads the reasoning items back in the next request's input.
+   */
+  store?: boolean;
+  /**
+   * OpenAI Responses API only: the id of a previously-stored response to continue
+   * from. Only meaningful when `store` was true on the prior request. When set,
+   * the model keeps its prior chain-of-thought instead of re-deriving it.
+   */
+  previous_response_id?: string;
   /**
    * When true, hints to the client that this task is long-running and it should
    * use a long-TTL cache where available.
@@ -165,6 +227,12 @@ export interface CompletionResponse {
   model: string;
   usage: TokenUsage | undefined;
   usd_cost?: number;
+  /**
+   * OpenAI Responses API only: the id of this response. When `store` was true,
+   * this can be passed as `previous_response_id` on the next request to continue
+   * the reasoning chain without resending history.
+   */
+  response_id?: string;
 }
 
 /** A single chunk yielded by a streaming completion. */

package/src/clients/xai.ts

@@ -116,6 +116,20 @@ export class GenericXAIClient implements GenericClient {
    * Used for grok-4.20 reasoning/non-reasoning and multi-agent models.
    * Translates Chat Completions message format to Responses API format.
    */
+  /**
+   * Resolve the xai-native reasoning items (Responses API `reasoning` items
+   * with encrypted_content) to re-inject for an assistant message, reading the
+   * provider-agnostic `_reasoning_details` slot only when it was produced by
+   * this provider.
+   */
+  private getReasoningItems(msg: any): any[] {
+    const details = msg?._reasoning_details;
+    if (details && details.provider === "xai" && Array.isArray(details.items)) {
+      return details.items;
+    }
+    return [];
+  }
+
   async createChatResponse(
     options: CompletionOptions
   ): Promise<CompletionResponse> {
@@ -133,22 +147,46 @@ export class GenericXAIClient implements GenericClient {
       .trim() || undefined;
 
     // Convert chat messages to Responses API input items
+    // Responses API hard limit: 10,485,760 chars per function_call_output.output
+    const MAX_TOOL_OUTPUT = 10_485_000;
+    const truncateToolOutput = (s: string) =>
+      s.length > MAX_TOOL_OUTPUT
+        ? s.slice(0, MAX_TOOL_OUTPUT) + "\n\n[TRUNCATED: output exceeded 10MB API limit]"
+        : s;
     const input: any[] = nonSystemMessages.map((msg) => {
       if (msg.role === "tool") {
         return {
           type: "function_call_output",
           call_id: msg.tool_call_id,
-          output: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
+          output: truncateToolOutput(typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)),
         };
       }
       if (msg.role === "assistant" && msg.tool_calls?.length) {
-        return msg.tool_calls.map((tc) => ({
+        // Re-inject any captured reasoning items (encrypted_content) BEFORE the
+        // function_call items so the model keeps its chain-of-thought instead of
+        // re-deriving it from scratch each turn.
+        const reasoningItems = this.getReasoningItems(msg);
+        return [
+          ...reasoningItems,
+          ...msg.tool_calls.map((tc) => ({
           type: "function_call",
           id: tc.id.startsWith("fc") ? tc.id : `fc_${tc.id}`,
           call_id: tc.id,
           name: tc.function.name,
           arguments: tc.function.arguments,
-        }));
+          })),
+        ];
+      }
+      if (msg.role === "assistant" && this.getReasoningItems(msg).length) {
+        // assistant message (no tool calls) that carried reasoning items →
+        // re-inject reasoning items, then the visible message content.
+        return [
+          ...this.getReasoningItems(msg),
+          {
+            role: msg.role,
+            content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
+          },
+        ];
       }
       return {
         role: msg.role,
@@ -182,7 +220,18 @@ export class GenericXAIClient implements GenericClient {
       ...(options.max_tokens && { max_output_tokens: Math.max(options.max_tokens, 16_000) }),
       ...(reasoningEffort && { reasoning: { effort: reasoningEffort } }),
       ...(tools?.length && { tools, tool_choice: "auto" }),
-      store: false,
+      // Reasoning persistence (same construct as OpenAI's Responses API):
+      //  - store === true  → xAI persists the response; next turn passes
+      //    previous_response_id to continue the reasoning chain server-side.
+      //  - store !== true  → stateless; request encrypted reasoning content so
+      //    we can thread the reasoning items back into the next request ourselves.
+      store: options.store === true,
+      ...(options.previous_response_id && {
+        previous_response_id: options.previous_response_id,
+      }),
+      ...(options.store !== true && reasoningEffort && {
+        include: ["reasoning.encrypted_content"],
+      }),
     };
 
     const response = await fetch("https://api.x.ai/v1/responses", {
@@ -218,6 +267,10 @@ export class GenericXAIClient implements GenericClient {
     // Collect text content and tool calls from output items
     let textContent: string | null = null;
     const toolCalls: any[] = [];
+    // Reasoning items (with encrypted_content) to thread back into the next
+    // turn, plus a human-readable summary of the model's thinking (if present).
+    const reasoningItems: any[] = [];
+    let reasoningSummary: string | null = null;
 
     for (const item of data.output ?? []) {
       if (item.type === "message") {
@@ -226,6 +279,17 @@ export class GenericXAIClient implements GenericClient {
             textContent = (textContent ?? "") + part.text;
           }
         }
+      } else if (item.type === "reasoning") {
+        // Keep the raw reasoning item so it can be re-injected next turn
+        // (carries encrypted_content when include was requested).
+        reasoningItems.push(item);
+        const summaryParts = item.summary ?? [];
+        for (const part of summaryParts) {
+          const text = typeof part === "string" ? part : part?.text;
+          if (text) {
+            reasoningSummary = (reasoningSummary ?? "") + text;
+          }
+        }
       } else if (item.type === "function_call") {
         toolCalls.push({
           id: item.call_id,
@@ -245,12 +309,17 @@ export class GenericXAIClient implements GenericClient {
             role: "assistant",
             content: textContent,
             ...(toolCalls.length > 0 && { tool_calls: toolCalls }),
+            ...(reasoningSummary && { reasoning_summary: reasoningSummary }),
+            ...(reasoningItems.length > 0 && {
+              _reasoning_details: { provider: "xai", items: reasoningItems },
+            }),
           },
         },
       ],
       model: options.model,
       usage,
       usd_cost: usdCost,
+      response_id: data.id,
     };
   }
 

package/src/commands/agent.ts

@@ -55,6 +55,10 @@ export function addAgentCommand(program: Command, getChatService: () => any): vo
     )
     .option("--model <model>", "Specific model for the provider")
     .option("--agent-name <name>", "Which agent to use", "Patcher")
+    .option(
+      "--reasoning-effort <effort>",
+      "Reasoning effort: none, low, medium, or high. Use 'none' to disable thinking on models that support it (e.g. for faster computer-use)."
+    )
     .option(
       "--max-time-limit <minutes>",
       "Time limit for agent execution (minutes)",
@@ -116,17 +120,29 @@ export function addAgentCommand(program: Command, getChatService: () => any): vo
             options.taskId,
             options.messageId
           );
+          // Restore the exact model/provider/reasoning the original run used
+          // (falls back to agent defaults when not persisted / remote-only).
+          const savedSettings = await agentModule.loadTaskSettings(
+            options.taskId,
+            options.messageId
+          );
           const resumeInput =
             options.input || "Please continue from where you left off.";
 
           await agentModule.initialize(chatService);
           const { taskCompleted: resumed } =
             await agentModule.resumeFromMessages({
-              agentName: options.agentName || "Patcher",
+              agentName:
+                options.agentName || savedSettings.agentName || "Patcher",
               input: resumeInput,
               threads,
               messageId: options.messageId,
               taskId: options.taskId,
+              // CLI-provided model/provider still win over persisted ones.
+              model: options.model || savedSettings.model,
+              provider: options.provider || savedSettings.provider,
+              reasoningEffort: savedSettings.reasoningEffort,
+              summarizeReasoning: savedSettings.summarizeReasoning,
             });
           await resumed;
           return;
@@ -208,6 +224,9 @@ export function addAgentCommand(program: Command, getChatService: () => any): vo
           input,
           maxTimeLimit: parseInt(options.maxTimeLimit, 10),
           maxSpendLimit: parseFloat(options.maxSpendLimit),
+          ...(options.reasoningEffort
+            ? { reasoningEffort: options.reasoningEffort }
+            : {}),
           ...(behaviorSystemPrompt ? { systemPrompt: behaviorSystemPrompt } : {}),
           ...(behaviorModel ? { model: behaviorModel } : {}),
           run: true,

package/src/commands/sandbox.ts

@@ -60,6 +60,7 @@ interface SandboxSnapshot {
   status: string;
   errorMsg?: string | null;
   statusMessage?: string | null;
+  regenerationSandboxId?: string | null;
   snapshotContent?: string;
   setupScript?: string | null;
 }
@@ -122,6 +123,51 @@ async function resolveSnapshot(
 
 // ─── Polling helpers ──────────────────────────────────────────────────────────
 
+/**
+ * Poll a snapshot's status until regeneration is complete.
+ *
+ * The backend's POST /regenerate endpoint is fire-and-forget — it returns
+ * immediately with regenerationSandboxId set. We poll GET /snapshots/:id
+ * until one of:
+ *   - regenerationSandboxId is null AND status === "ready"  → success
+ *   - status === "error"                                    → failure
+ *   - deadline exceeded                                     → timeout
+ *
+ * statusMessage is printed whenever it changes so the user sees progress.
+ */
+async function pollRegeneration(
+  sandboxId: string,
+  snapshotId: string,
+  timeoutMs: number
+): Promise<SandboxSnapshot> {
+  const deadline = Date.now() + timeoutMs;
+  let lastStatus = "";
+  let lastMessage = "";
+  while (Date.now() < deadline) {
+    const snap = await apiGet<SandboxSnapshot>(
+      `/sandboxes/${sandboxId}/snapshots/${snapshotId}`
+    );
+    if (snap.status !== lastStatus) {
+      console.log(`  [snapshot] status: ${snap.status}`);
+      lastStatus = snap.status;
+    }
+    if (snap.statusMessage && snap.statusMessage !== lastMessage) {
+      console.log(`  [snapshot] ${snap.statusMessage}`);
+      lastMessage = snap.statusMessage;
+    }
+    if (!snap.regenerationSandboxId && snap.status === "ready") return snap;
+    if (snap.status === "error") {
+      throw new Error(
+        `Snapshot regeneration failed: ${snap.errorMsg || snap.statusMessage || "(no details)"}`
+      );
+    }
+    await new Promise((r) => setTimeout(r, 5000));
+  }
+  throw new Error(
+    `Timeout waiting for snapshot regeneration to complete (${timeoutMs}ms). Last status: ${lastStatus}`
+  );
+}
+
 async function pollSandboxStatus(
   sandboxId: string,
   targetStatuses: string[],
@@ -373,7 +419,7 @@ export function addSandboxCommand(program: Command): void {
     .option("--sandbox-name <name>", "Source sandbox name (alternative to --sandbox-id)")
     .option("--snapshot-id <id>", "Snapshot ID to regenerate")
     .option("--snapshot-name <name>", "Snapshot label to regenerate")
-    .option("--no-wait", "Return immediately without waiting for snapshot to be ready")
+    .option("--no-wait", "Trigger regeneration and return immediately (do not poll for completion)")
     .option("--timeout-minutes <min>", "Max time for the full regen cycle", "60")
     .action(
       async (opts: {
@@ -381,20 +427,18 @@ export function addSandboxCommand(program: Command): void {
         sandboxName?: string;
         snapshotId?: string;
         snapshotName?: string;
-        wait: boolean; // commander flips --no-wait → wait=false
+        wait: boolean;
         timeoutMinutes: string;
       }) => {
         const timeoutMs = Number(opts.timeoutMinutes) * 60 * 1000;
-        const deadline = Date.now() + timeoutMs;
 
-        // ── 1. Resolve sandbox ──────────────────────────────────────────────
+        // ── 1. Resolve sandbox & snapshot ──────────────────────────────────
         if (!opts.sandboxId && !opts.sandboxName) {
           throw new Error("Provide --sandbox-id or --sandbox-name");
         }
         const sandboxId =
           opts.sandboxId || (await resolveSandboxId(opts.sandboxName!));
 
-        // ── 2. Resolve snapshot ─────────────────────────────────────────────
         if (!opts.snapshotId && !opts.snapshotName) {
           throw new Error("Provide --snapshot-id or --snapshot-name");
         }
@@ -410,132 +454,113 @@ export function addSandboxCommand(program: Command): void {
         );
         console.log(`   Source sandbox: ${sandboxId}`);
 
-        if (snapshot.status !== "ready") {
+        // ── 2. Validate preconditions ───────────────────────────────────────
+        if (snapshot.status !== "ready" && !snapshot.regenerationSandboxId) {
           throw new Error(
             `Snapshot must be in 'ready' status to regenerate (current: ${snapshot.status})`
           );
         }
-        if (!snapshot.setupScript) {
-          throw new Error(
-            "Snapshot has no setupScript. Add one via the UI before regenerating."
-          );
-        }
 
-        // ── 3. Fork ephemeral sandbox from the snapshot ─────────────────────
-        console.log("\n📦 Step 1/4: Forking ephemeral sandbox from snapshot...");
-        const ephemeralName = `regen-${snapshotId.slice(0, 8)}-${Date.now()}`;
-        const forkResult = await apiPost<{ id?: string; sandboxId?: string }>(
-          "/sandboxes/fork",
-          { snapshotId, name: ephemeralName }
+        // ── 3. Kick off background regeneration via backend API ─────────────
+        // The backend POST /regenerate endpoint returns immediately with the
+        // updated snapshot (regenerationSandboxId set). It runs the full
+        // cycle (fork ephemeral → setupScript → snapshot) in the background.
+        console.log("\n📡 Triggering backend regeneration...");
+        const triggered = await apiPost<SandboxSnapshot>(
+          `/sandboxes/${sandboxId}/snapshots/${snapshotId}/regenerate`
         );
-        const ephemeralId = forkResult.id || forkResult.sandboxId;
-        if (!ephemeralId) {
-          throw new Error(
-            `Fork did not return a sandbox ID: ${JSON.stringify(forkResult)}`
+        console.log(`   regenerationSandboxId: ${triggered.regenerationSandboxId || "(none)"}`);
+
+        if (!opts.wait) {
+          console.log(
+            `\n✅ Regeneration triggered. Monitor with:\n` +
+              `   knowhow sandbox snapshot-status --sandbox-id ${sandboxId} --snapshot-id ${snapshotId}`
           );
+          return;
         }
-        console.log(`   Ephemeral sandbox: ${ephemeralId} (${ephemeralName})`);
-
-        // ── 4. Wait for ephemeral sandbox to be running ─────────────────────
-        console.log("\n⏳ Step 2/4: Waiting for sandbox to start...");
-        await pollSandboxStatus(
-          ephemeralId,
-          ["running"],
-          Math.min(deadline - Date.now(), 10 * 60 * 1000),
-          ephemeralName
+
+        // ── 4. Poll until complete ──────────────────────────────────────────
+        console.log("\n⏳ Waiting for regeneration to complete (Ctrl+C to stop polling)...");
+        const done = await pollRegeneration(sandboxId, snapshotId, timeoutMs);
+
+        console.log(
+          `\n✅ Snapshot regeneration complete!\n` +
+            `   Snapshot ID : ${done.id}\n` +
+            `   Label       : ${done.label || "(none)"}\n` +
+            `   Status      : ${done.status}`
         );
-        console.log("   ✓ Running");
-
-        // ── 5. Execute the setupScript ──────────────────────────────────────
-        console.log("\n🔧 Step 3/4: Executing setupScript...");
-        console.log(`   Script length: ${snapshot.setupScript.length} chars`);
-        let execResult: { stdout?: string; stderr?: string; exitCode?: number };
-        try {
-          execResult = await apiPost<{
-            stdout?: string;
-            stderr?: string;
-            exitCode?: number;
-          }>(`/sandboxes/${ephemeralId}/exec`, {
-            command: "/bin/bash",
-            args: ["-c", snapshot.setupScript],
-            timeoutMs: Math.min(deadline - Date.now(), 25 * 60 * 1000),
-          });
-        } catch (err: any) {
-          console.error(`\n❌ setupScript exec failed: ${err.message}`);
-          await safeDestroy(ephemeralId);
-          throw err;
-        }
+      }
+    );
 
-        if (execResult.stdout) {
-          console.log("--- stdout ---");
-          process.stdout.write(execResult.stdout);
-        }
-        if (execResult.stderr) {
-          console.error("--- stderr ---");
-          process.stderr.write(execResult.stderr);
+  // ── sandbox snapshot-status ──────────────────────────────────────────────────
+  sandboxCmd
+    .command("snapshot-status")
+    .description(
+      "Check and optionally wait for a snapshot's regeneration to complete.\n" +
+        "Useful after triggering regeneration with --no-wait."
+    )
+    .option("--sandbox-id <id>", "Sandbox ID")
+    .option("--sandbox-name <name>", "Sandbox name")
+    .option("--snapshot-id <id>", "Snapshot ID")
+    .option("--snapshot-name <name>", "Snapshot label")
+    .option("--wait", "Poll until regeneration completes (or times out)")
+    .option("--timeout-minutes <min>", "Max poll time in minutes", "60")
+    .option("--json", "Output raw JSON")
+    .action(
+      async (opts: {
+        sandboxId?: string;
+        sandboxName?: string;
+        snapshotId?: string;
+        snapshotName?: string;
+        wait?: boolean;
+        timeoutMinutes: string;
+        json?: boolean;
+      }) => {
+        if (!opts.sandboxId && !opts.sandboxName) {
+          throw new Error("Provide --sandbox-id or --sandbox-name");
         }
-        if (execResult.exitCode != null && execResult.exitCode !== 0) {
-          await safeDestroy(ephemeralId);
-          throw new Error(`setupScript exited with code ${execResult.exitCode}`);
+        const sandboxId =
+          opts.sandboxId || (await resolveSandboxId(opts.sandboxName!));
+
+        if (!opts.snapshotId && !opts.snapshotName) {
+          throw new Error("Provide --snapshot-id or --snapshot-name");
         }
-        console.log("   ✓ setupScript completed");
-
-        // ── 6. Capture new snapshot with the same label ─────────────────────
-        console.log("\n📸 Step 4/4: Capturing new snapshot...");
-        const newLabel = snapshot.label || `regen-${snapshotId.slice(0, 8)}`;
-        let createResult: { snapshot?: SandboxSnapshot; id?: string };
-        try {
-          createResult = await apiPost<{ snapshot?: SandboxSnapshot; id?: string }>(
-            `/sandboxes/${ephemeralId}/snapshots`,
-            {
-              label: newLabel,
-              description: snapshot.description,
-              snapshotContent: snapshot.snapshotContent || "full",
-              snapshotType: "full",
-            }
+        const snapshot = opts.snapshotId
+          ? await apiGet<SandboxSnapshot>(
+              `/sandboxes/${sandboxId}/snapshots/${opts.snapshotId}`
+            )
+          : await resolveSnapshot(sandboxId, opts.snapshotName!);
+
+        if (opts.wait && snapshot.regenerationSandboxId) {
+          console.log("⏳ Waiting for regeneration to complete...");
+          const done = await pollRegeneration(
+            sandboxId,
+            snapshot.id,
+            Number(opts.timeoutMinutes) * 60 * 1000
           );
-        } catch (err: any) {
-          console.error(`\n❌ Snapshot creation failed: ${err.message}`);
-          await safeDestroy(ephemeralId);
-          throw err;
+          if (opts.json) {
+            console.log(JSON.stringify(done, null, 2));
+          } else {
+            console.log(
+              `✅ Done — status: ${done.status}  label: ${done.label || "(none)"}`
+            );
+          }
+          return;
         }
 
-        const newSnapshot = createResult.snapshot || (createResult as SandboxSnapshot);
-        const newSnapshotId = newSnapshot.id;
-        console.log(`   New snapshot ID: ${newSnapshotId}`);
-
-        if (opts.wait) {
-          console.log("   Waiting for snapshot upload...");
-          await pollSnapshotStatus(
-            ephemeralId,
-            newSnapshotId,
-            ["ready"],
-            Math.min(deadline - Date.now(), 20 * 60 * 1000)
+        if (opts.json) {
+          console.log(JSON.stringify(snapshot, null, 2));
+        } else {
+          const regenInfo = snapshot.regenerationSandboxId
+            ? `🔄 regenerating (ephemeral: ${snapshot.regenerationSandboxId})`
+            : `✅ ${snapshot.status}`;
+          console.log(
+            `Snapshot ${snapshot.id}  label=${snapshot.label || "(none)"}  ${regenInfo}`
           );
-          console.log("   ✓ Snapshot ready");
+          if (snapshot.statusMessage) {
+            console.log(`  message: ${snapshot.statusMessage}`);
+          }
         }
-
-        // ── 7. Destroy ephemeral sandbox ────────────────────────────────────
-        console.log("\n🗑  Destroying ephemeral sandbox...");
-        await safeDestroy(ephemeralId);
-        console.log("   ✓ Destroyed");
-
-        console.log(
-          `\n✅ Snapshot regeneration complete!\n` +
-            `   Old snapshot ID : ${snapshotId}\n` +
-            `   New snapshot ID : ${newSnapshotId}\n` +
-            `   Label           : ${newLabel}\n\n` +
-            `ℹ  The old snapshot still exists. Clean it up with:\n` +
-            `   knowhow sandbox delete-snapshot --sandbox-id ${sandboxId} --snapshot-id ${snapshotId}`
-        );
       }
     );
 }
-
-async function safeDestroy(sandboxId: string): Promise<void> {
-  try {
-    await apiDelete(`/sandboxes/${sandboxId}`);
-  } catch (err: any) {
-    console.warn(`⚠ Could not destroy sandbox ${sandboxId}: ${err.message}`);
-  }
-}

package/src/index.ts

@@ -51,6 +51,14 @@ export {
 } from "./generate";
 
 export * as clients from "./clients";
+export type {
+  Tool,
+  ToolProp,
+  ToolCall,
+  Message,
+  CompletionOptions,
+  CompletionResponse,
+} from "./clients/types";
 export * as agents from "./agents";
 export * as services from "./services";
 export * as embeddings from "./embeddings";
@@ -61,6 +69,7 @@ export * as ai from "./ai";
 // Export module system types for external modules
 export * from "./services/modules/types";
 export { ModulesService } from "./services/modules";
+export * from "./services/modules/computerUse";
 // Export conversion types for external modules (e.g. knowhow-module-pdf)
 export * from "./services/conversion/types";
 export { ConversionService } from "./services/conversion/ConversionService";