indusagi 0.1.1

package/dist/webui/components/ThinkingBlock.js

@@ -0,0 +1,57 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { icon } from "@mariozechner/mini-lit";
+import { html, LitElement } from "lit";
+import { customElement, property, state } from "lit/decorators.js";
+import { ChevronRight } from "lucide";
+let ThinkingBlock = class ThinkingBlock extends LitElement {
+    constructor() {
+        super(...arguments);
+        this.isStreaming = false;
+        this.isExpanded = false;
+    }
+    createRenderRoot() {
+        return this;
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        this.style.display = "block";
+    }
+    toggleExpanded() {
+        this.isExpanded = !this.isExpanded;
+    }
+    render() {
+        const shimmerClasses = this.isStreaming
+            ? "animate-shimmer bg-gradient-to-r from-muted-foreground via-foreground to-muted-foreground bg-[length:200%_100%] bg-clip-text text-transparent"
+            : "";
+        return html `
+			<div class="thinking-block">
+				<div
+					class="thinking-header cursor-pointer select-none flex items-center gap-2 py-1 text-sm text-muted-foreground hover:text-foreground transition-colors"
+					@click=${this.toggleExpanded}
+				>
+					<span class="transition-transform inline-block ${this.isExpanded ? "rotate-90" : ""}">${icon(ChevronRight, "sm")}</span>
+					<span class="${shimmerClasses}">Thinking...</span>
+				</div>
+				${this.isExpanded ? html `<markdown-block .content=${this.content} .isThinking=${true}></markdown-block>` : ""}
+			</div>
+		`;
+    }
+};
+__decorate([
+    property()
+], ThinkingBlock.prototype, "content", void 0);
+__decorate([
+    property({ type: Boolean })
+], ThinkingBlock.prototype, "isStreaming", void 0);
+__decorate([
+    state()
+], ThinkingBlock.prototype, "isExpanded", void 0);
+ThinkingBlock = __decorate([
+    customElement("thinking-block")
+], ThinkingBlock);
+export { ThinkingBlock };

package/dist/webui/components/message-renderer-registry.d.ts

@@ -0,0 +1,12 @@
+import type { AgentMessage } from "../../agent/index.js";
+import type { TemplateResult } from "lit";
+export type MessageRole = AgentMessage["role"];
+export interface MessageRenderer<TMessage extends AgentMessage = AgentMessage> {
+    render(message: TMessage): TemplateResult;
+}
+export declare function registerMessageRenderer<TRole extends MessageRole>(role: TRole, renderer: MessageRenderer<Extract<AgentMessage, {
+    role: TRole;
+}>>): void;
+export declare function getMessageRenderer(role: MessageRole): MessageRenderer | undefined;
+export declare function renderMessage(message: AgentMessage): TemplateResult | undefined;
+//# sourceMappingURL=message-renderer-registry.d.ts.map

package/dist/webui/components/message-renderer-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-renderer-registry.d.ts","sourceRoot":"","sources":["../../../src/webui/components/message-renderer-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,KAAK,CAAC;AAG1C,MAAM,MAAM,WAAW,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC;AAG/C,MAAM,WAAW,eAAe,CAAC,QAAQ,SAAS,YAAY,GAAG,YAAY;IAC5E,MAAM,CAAC,OAAO,EAAE,QAAQ,GAAG,cAAc,CAAC;CAC1C;AAKD,wBAAgB,uBAAuB,CAAC,KAAK,SAAS,WAAW,EAChE,IAAI,EAAE,KAAK,EACX,QAAQ,EAAE,eAAe,CAAC,OAAO,CAAC,YAAY,EAAE;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,CAAC,CAAC,GAC/D,IAAI,CAEN;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,WAAW,GAAG,eAAe,GAAG,SAAS,CAEjF;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,YAAY,GAAG,cAAc,GAAG,SAAS,CAE/E"}

package/dist/webui/components/message-renderer-registry.js

@@ -0,0 +1,11 @@
+// Registry of custom message renderers by role
+const messageRenderers = new Map();
+export function registerMessageRenderer(role, renderer) {
+    messageRenderers.set(role, renderer);
+}
+export function getMessageRenderer(role) {
+    return messageRenderers.get(role);
+}
+export function renderMessage(message) {
+    return messageRenderers.get(message.role)?.render(message);
+}

package/dist/webui/components/sandbox/ArtifactsRuntimeProvider.d.ts

@@ -0,0 +1,35 @@
+import type { SandboxRuntimeProvider } from "./SandboxRuntimeProvider.js";
+interface ArtifactsPanelLike {
+    artifacts: Map<string, {
+        content: string;
+    }>;
+    tool: {
+        execute(toolCallId: string, args: {
+            command: string;
+            filename: string;
+            content?: string;
+        }): Promise<any>;
+    };
+}
+interface AgentLike {
+    appendMessage(message: any): void;
+}
+/**
+ * Artifacts Runtime Provider
+ *
+ * Provides programmatic access to session artifacts from sandboxed code.
+ * Allows code to create, read, update, and delete artifacts dynamically.
+ * Supports both online (extension) and offline (downloaded HTML) modes.
+ */
+export declare class ArtifactsRuntimeProvider implements SandboxRuntimeProvider {
+    private artifactsPanel;
+    private agent?;
+    private readWrite;
+    constructor(artifactsPanel: ArtifactsPanelLike, agent?: AgentLike | undefined, readWrite?: boolean);
+    getData(): Record<string, any>;
+    getRuntime(): (sandboxId: string) => void;
+    handleMessage(message: any, respond: (response: any) => void): Promise<void>;
+    getDescription(): string;
+}
+export {};
+//# sourceMappingURL=ArtifactsRuntimeProvider.d.ts.map

package/dist/webui/components/sandbox/ArtifactsRuntimeProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArtifactsRuntimeProvider.d.ts","sourceRoot":"","sources":["../../../../src/webui/components/sandbox/ArtifactsRuntimeProvider.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAG1E,UAAU,kBAAkB;IAC3B,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC5C,IAAI,EAAE;QACL,OAAO,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE;YAAE,OAAO,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,OAAO,CAAC,EAAE,MAAM,CAAA;SAAE,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;KACzG,CAAC;CACF;AAED,UAAU,SAAS;IAClB,aAAa,CAAC,OAAO,EAAE,GAAG,GAAG,IAAI,CAAC;CAClC;AAED;;;;;;GAMG;AACH,qBAAa,wBAAyB,YAAW,sBAAsB;IAErE,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,KAAK,CAAC;IACd,OAAO,CAAC,SAAS;gBAFT,cAAc,EAAE,kBAAkB,EAClC,KAAK,CAAC,EAAE,SAAS,YAAA,EACjB,SAAS,GAAE,OAAc;IAGlC,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAS9B,UAAU,IAAI,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI;IAgGnC,aAAa,CAAC,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC,QAAQ,EAAE,GAAG,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IA8ElF,cAAc,IAAI,MAAM;CAGxB"}

package/dist/webui/components/sandbox/ArtifactsRuntimeProvider.js

@@ -0,0 +1,188 @@
+import { ARTIFACTS_RUNTIME_PROVIDER_DESCRIPTION_RO, ARTIFACTS_RUNTIME_PROVIDER_DESCRIPTION_RW, } from "../../prompts/prompts.js";
+/**
+ * Artifacts Runtime Provider
+ *
+ * Provides programmatic access to session artifacts from sandboxed code.
+ * Allows code to create, read, update, and delete artifacts dynamically.
+ * Supports both online (extension) and offline (downloaded HTML) modes.
+ */
+export class ArtifactsRuntimeProvider {
+    constructor(artifactsPanel, agent, readWrite = true) {
+        this.artifactsPanel = artifactsPanel;
+        this.agent = agent;
+        this.readWrite = readWrite;
+    }
+    getData() {
+        // Inject artifact snapshot for offline mode
+        const snapshot = {};
+        this.artifactsPanel.artifacts.forEach((artifact, filename) => {
+            snapshot[filename] = artifact.content;
+        });
+        return { artifacts: snapshot };
+    }
+    getRuntime() {
+        // This function will be stringified, so no external references!
+        return (_sandboxId) => {
+            // Auto-parse/stringify for .json files
+            const isJsonFile = (filename) => filename.endsWith(".json");
+            window.listArtifacts = async () => {
+                // Online: ask extension
+                if (window.sendRuntimeMessage) {
+                    const response = await window.sendRuntimeMessage({
+                        type: "artifact-operation",
+                        action: "list",
+                    });
+                    if (!response.success)
+                        throw new Error(response.error);
+                    return response.result;
+                }
+                // Offline: return snapshot keys
+                else {
+                    return Object.keys(window.artifacts || {});
+                }
+            };
+            window.getArtifact = async (filename) => {
+                let content;
+                // Online: ask extension
+                if (window.sendRuntimeMessage) {
+                    const response = await window.sendRuntimeMessage({
+                        type: "artifact-operation",
+                        action: "get",
+                        filename,
+                    });
+                    if (!response.success)
+                        throw new Error(response.error);
+                    content = response.result;
+                }
+                // Offline: read snapshot
+                else {
+                    if (!window.artifacts?.[filename]) {
+                        throw new Error(`Artifact not found (offline mode): ${filename}`);
+                    }
+                    content = window.artifacts[filename];
+                }
+                // Auto-parse .json files
+                if (isJsonFile(filename)) {
+                    try {
+                        return JSON.parse(content);
+                    }
+                    catch (e) {
+                        throw new Error(`Failed to parse JSON from ${filename}: ${e}`);
+                    }
+                }
+                return content;
+            };
+            window.createOrUpdateArtifact = async (filename, content, mimeType) => {
+                if (!window.sendRuntimeMessage) {
+                    throw new Error("Cannot create/update artifacts in offline mode (read-only)");
+                }
+                let finalContent = content;
+                // Auto-stringify .json files
+                if (isJsonFile(filename) && typeof content !== "string") {
+                    finalContent = JSON.stringify(content, null, 2);
+                }
+                else if (typeof content !== "string") {
+                    finalContent = JSON.stringify(content, null, 2);
+                }
+                const response = await window.sendRuntimeMessage({
+                    type: "artifact-operation",
+                    action: "createOrUpdate",
+                    filename,
+                    content: finalContent,
+                    mimeType,
+                });
+                if (!response.success)
+                    throw new Error(response.error);
+            };
+            window.deleteArtifact = async (filename) => {
+                if (!window.sendRuntimeMessage) {
+                    throw new Error("Cannot delete artifacts in offline mode (read-only)");
+                }
+                const response = await window.sendRuntimeMessage({
+                    type: "artifact-operation",
+                    action: "delete",
+                    filename,
+                });
+                if (!response.success)
+                    throw new Error(response.error);
+            };
+        };
+    }
+    async handleMessage(message, respond) {
+        if (message.type !== "artifact-operation") {
+            return;
+        }
+        const { action, filename, content } = message;
+        try {
+            switch (action) {
+                case "list": {
+                    const filenames = Array.from(this.artifactsPanel.artifacts.keys());
+                    respond({ success: true, result: filenames });
+                    break;
+                }
+                case "get": {
+                    const artifact = this.artifactsPanel.artifacts.get(filename);
+                    if (!artifact) {
+                        respond({ success: false, error: `Artifact not found: ${filename}` });
+                    }
+                    else {
+                        respond({ success: true, result: artifact.content });
+                    }
+                    break;
+                }
+                case "createOrUpdate": {
+                    try {
+                        const exists = this.artifactsPanel.artifacts.has(filename);
+                        const command = exists ? "rewrite" : "create";
+                        const action = exists ? "update" : "create";
+                        await this.artifactsPanel.tool.execute("", {
+                            command,
+                            filename,
+                            content,
+                        });
+                        this.agent?.appendMessage({
+                            role: "artifact",
+                            action,
+                            filename,
+                            content,
+                            ...(action === "create" && { title: filename }),
+                            timestamp: new Date().toISOString(),
+                        });
+                        respond({ success: true });
+                    }
+                    catch (err) {
+                        respond({ success: false, error: err.message });
+                    }
+                    break;
+                }
+                case "delete": {
+                    try {
+                        await this.artifactsPanel.tool.execute("", {
+                            command: "delete",
+                            filename,
+                        });
+                        this.agent?.appendMessage({
+                            role: "artifact",
+                            action: "delete",
+                            filename,
+                            timestamp: new Date().toISOString(),
+                        });
+                        respond({ success: true });
+                    }
+                    catch (err) {
+                        respond({ success: false, error: err.message });
+                    }
+                    break;
+                }
+                default:
+                    respond({ success: false, error: `Unknown artifact action: ${action}` });
+            }
+        }
+        catch (error) {
+            respond({ success: false, error: error.message });
+        }
+    }
+    getDescription() {
+        return this.readWrite ? ARTIFACTS_RUNTIME_PROVIDER_DESCRIPTION_RW : ARTIFACTS_RUNTIME_PROVIDER_DESCRIPTION_RO;
+    }
+}

package/dist/webui/components/sandbox/AttachmentsRuntimeProvider.d.ts

@@ -0,0 +1,17 @@
+import type { Attachment } from "../../utils/attachment-utils.js";
+import type { SandboxRuntimeProvider } from "./SandboxRuntimeProvider.js";
+/**
+ * Attachments Runtime Provider
+ *
+ * OPTIONAL provider that provides file access APIs to sandboxed code.
+ * Only needed when attachments are present.
+ * Attachments are read-only snapshot data - no messaging needed.
+ */
+export declare class AttachmentsRuntimeProvider implements SandboxRuntimeProvider {
+    private attachments;
+    constructor(attachments: Attachment[]);
+    getData(): Record<string, any>;
+    getRuntime(): (sandboxId: string) => void;
+    getDescription(): string;
+}
+//# sourceMappingURL=AttachmentsRuntimeProvider.d.ts.map

package/dist/webui/components/sandbox/AttachmentsRuntimeProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AttachmentsRuntimeProvider.d.ts","sourceRoot":"","sources":["../../../../src/webui/components/sandbox/AttachmentsRuntimeProvider.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAE1E;;;;;;GAMG;AACH,qBAAa,0BAA2B,YAAW,sBAAsB;IAC5D,OAAO,CAAC,WAAW;gBAAX,WAAW,EAAE,UAAU,EAAE;IAE7C,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAa9B,UAAU,IAAI,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI;IAmCzC,cAAc,IAAI,MAAM;CAGxB"}

package/dist/webui/components/sandbox/AttachmentsRuntimeProvider.js

@@ -0,0 +1,63 @@
+import { ATTACHMENTS_RUNTIME_DESCRIPTION } from "../../prompts/prompts.js";
+/**
+ * Attachments Runtime Provider
+ *
+ * OPTIONAL provider that provides file access APIs to sandboxed code.
+ * Only needed when attachments are present.
+ * Attachments are read-only snapshot data - no messaging needed.
+ */
+export class AttachmentsRuntimeProvider {
+    constructor(attachments) {
+        this.attachments = attachments;
+    }
+    getData() {
+        const attachmentsData = this.attachments.map((a) => ({
+            id: a.id,
+            fileName: a.fileName,
+            mimeType: a.mimeType,
+            size: a.size,
+            content: a.content,
+            extractedText: a.extractedText,
+        }));
+        return { attachments: attachmentsData };
+    }
+    getRuntime() {
+        // This function will be stringified, so no external references!
+        // These functions read directly from window.attachments
+        // Works both online AND offline (no messaging needed!)
+        return (_sandboxId) => {
+            window.listAttachments = () => (window.attachments || []).map((a) => ({
+                id: a.id,
+                fileName: a.fileName,
+                mimeType: a.mimeType,
+                size: a.size,
+            }));
+            window.readTextAttachment = (attachmentId) => {
+                const a = (window.attachments || []).find((x) => x.id === attachmentId);
+                if (!a)
+                    throw new Error(`Attachment not found: ${attachmentId}`);
+                if (a.extractedText)
+                    return a.extractedText;
+                try {
+                    return atob(a.content);
+                }
+                catch {
+                    throw new Error(`Failed to decode text content for: ${attachmentId}`);
+                }
+            };
+            window.readBinaryAttachment = (attachmentId) => {
+                const a = (window.attachments || []).find((x) => x.id === attachmentId);
+                if (!a)
+                    throw new Error(`Attachment not found: ${attachmentId}`);
+                const bin = atob(a.content);
+                const bytes = new Uint8Array(bin.length);
+                for (let i = 0; i < bin.length; i++)
+                    bytes[i] = bin.charCodeAt(i);
+                return bytes;
+            };
+        };
+    }
+    getDescription() {
+        return ATTACHMENTS_RUNTIME_DESCRIPTION;
+    }
+}

package/dist/webui/components/sandbox/ConsoleRuntimeProvider.d.ts

@@ -0,0 +1,42 @@
+import type { SandboxRuntimeProvider } from "./SandboxRuntimeProvider.js";
+export interface ConsoleLog {
+    type: "log" | "warn" | "error" | "info";
+    text: string;
+    args?: unknown[];
+}
+/**
+ * Console Runtime Provider
+ *
+ * REQUIRED provider that should always be included first.
+ * Provides console capture, error handling, and execution lifecycle management.
+ * Collects console output for retrieval by caller.
+ */
+export declare class ConsoleRuntimeProvider implements SandboxRuntimeProvider {
+    private logs;
+    private completionError;
+    private completed;
+    getData(): Record<string, any>;
+    getDescription(): string;
+    getRuntime(): (sandboxId: string) => void;
+    handleMessage(message: any, respond: (response: any) => void): Promise<void>;
+    /**
+     * Get collected console logs
+     */
+    getLogs(): ConsoleLog[];
+    /**
+     * Get completion status
+     */
+    isCompleted(): boolean;
+    /**
+     * Get completion error if any
+     */
+    getCompletionError(): {
+        message: string;
+        stack: string;
+    } | null;
+    /**
+     * Reset state for reuse
+     */
+    reset(): void;
+}
+//# sourceMappingURL=ConsoleRuntimeProvider.d.ts.map

package/dist/webui/components/sandbox/ConsoleRuntimeProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConsoleRuntimeProvider.d.ts","sourceRoot":"","sources":["../../../../src/webui/components/sandbox/ConsoleRuntimeProvider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAE1E,MAAM,WAAW,UAAU;IAC1B,IAAI,EAAE,KAAK,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,OAAO,EAAE,CAAC;CACjB;AAED;;;;;;GAMG;AACH,qBAAa,sBAAuB,YAAW,sBAAsB;IACpE,OAAO,CAAC,IAAI,CAAoB;IAChC,OAAO,CAAC,eAAe,CAAmD;IAC1E,OAAO,CAAC,SAAS,CAAS;IAE1B,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAK9B,cAAc,IAAI,MAAM;IAIxB,UAAU,IAAI,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI;IA2GnC,aAAa,CAAC,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC,QAAQ,EAAE,GAAG,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAoBlF;;OAEG;IACH,OAAO,IAAI,UAAU,EAAE;IAIvB;;OAEG;IACH,WAAW,IAAI,OAAO;IAItB;;OAEG;IACH,kBAAkB,IAAI;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAI/D;;OAEG;IACH,KAAK,IAAI,IAAI;CAKb"}

package/dist/webui/components/sandbox/ConsoleRuntimeProvider.js

@@ -0,0 +1,160 @@
+/**
+ * Console Runtime Provider
+ *
+ * REQUIRED provider that should always be included first.
+ * Provides console capture, error handling, and execution lifecycle management.
+ * Collects console output for retrieval by caller.
+ */
+export class ConsoleRuntimeProvider {
+    constructor() {
+        this.logs = [];
+        this.completionError = null;
+        this.completed = false;
+    }
+    getData() {
+        // No data needed
+        return {};
+    }
+    getDescription() {
+        return "";
+    }
+    getRuntime() {
+        return (_sandboxId) => {
+            // Store truly original console methods on first wrap only
+            // This prevents accumulation of wrapper functions across multiple executions
+            if (!window.__originalConsole) {
+                window.__originalConsole = {
+                    log: console.log.bind(console),
+                    error: console.error.bind(console),
+                    warn: console.warn.bind(console),
+                    info: console.info.bind(console),
+                };
+            }
+            // Always use the truly original console, not the current (possibly wrapped) one
+            const originalConsole = window.__originalConsole;
+            // Track pending send promises to wait for them in onCompleted
+            const pendingSends = [];
+            ["log", "error", "warn", "info"].forEach((method) => {
+                console[method] = (...args) => {
+                    const text = args
+                        .map((arg) => {
+                        try {
+                            return typeof arg === "object" ? JSON.stringify(arg) : String(arg);
+                        }
+                        catch {
+                            return String(arg);
+                        }
+                    })
+                        .join(" ");
+                    // Always log locally too (using truly original console)
+                    originalConsole[method].apply(console, args);
+                    // Send immediately and track the promise (only in extension context)
+                    if (window.sendRuntimeMessage) {
+                        const sendPromise = window
+                            .sendRuntimeMessage({
+                            type: "console",
+                            method,
+                            text,
+                            args,
+                        })
+                            .catch(() => { });
+                        pendingSends.push(sendPromise);
+                    }
+                };
+            });
+            // Register completion callback to wait for all pending sends
+            if (window.onCompleted) {
+                window.onCompleted(async (_success) => {
+                    // Wait for all pending console sends to complete
+                    if (pendingSends.length > 0) {
+                        await Promise.all(pendingSends);
+                    }
+                });
+            }
+            // Track errors for HTML artifacts
+            let lastError = null;
+            // Error handlers - track errors but don't log them
+            // (they'll be shown via execution-error message)
+            window.addEventListener("error", (e) => {
+                const text = `${e.error?.stack || e.message || String(e)} at line ${e.lineno || "?"}:${e.colno || "?"}`;
+                lastError = {
+                    message: e.error?.message || e.message || String(e),
+                    stack: e.error?.stack || text,
+                };
+            });
+            window.addEventListener("unhandledrejection", (e) => {
+                const text = `Unhandled promise rejection: ${e.reason?.message || e.reason || "Unknown error"}`;
+                lastError = {
+                    message: e.reason?.message || String(e.reason) || "Unhandled promise rejection",
+                    stack: e.reason?.stack || text,
+                };
+            });
+            // Expose complete() method for user code to call
+            let completionSent = false;
+            window.complete = async (error, returnValue) => {
+                if (completionSent)
+                    return;
+                completionSent = true;
+                const finalError = error || lastError;
+                if (window.sendRuntimeMessage) {
+                    if (finalError) {
+                        await window.sendRuntimeMessage({
+                            type: "execution-error",
+                            error: finalError,
+                        });
+                    }
+                    else {
+                        await window.sendRuntimeMessage({
+                            type: "execution-complete",
+                            returnValue,
+                        });
+                    }
+                }
+            };
+        };
+    }
+    async handleMessage(message, respond) {
+        if (message.type === "console") {
+            // Collect console output
+            this.logs.push({
+                type: message.method === "error"
+                    ? "error"
+                    : message.method === "warn"
+                        ? "warn"
+                        : message.method === "info"
+                            ? "info"
+                            : "log",
+                text: message.text,
+                args: message.args,
+            });
+            // Acknowledge receipt
+            respond({ success: true });
+        }
+    }
+    /**
+     * Get collected console logs
+     */
+    getLogs() {
+        return this.logs;
+    }
+    /**
+     * Get completion status
+     */
+    isCompleted() {
+        return this.completed;
+    }
+    /**
+     * Get completion error if any
+     */
+    getCompletionError() {
+        return this.completionError;
+    }
+    /**
+     * Reset state for reuse
+     */
+    reset() {
+        this.logs = [];
+        this.completionError = null;
+        this.completed = false;
+    }
+}

package/dist/webui/components/sandbox/FileDownloadRuntimeProvider.d.ts

@@ -0,0 +1,30 @@
+import type { SandboxRuntimeProvider } from "./SandboxRuntimeProvider.js";
+export interface DownloadableFile {
+    fileName: string;
+    content: string | Uint8Array;
+    mimeType: string;
+}
+/**
+ * File Download Runtime Provider
+ *
+ * Provides returnDownloadableFile() for creating user downloads.
+ * Files returned this way are NOT accessible to the LLM later (one-time download).
+ * Works both online (sends to extension) and offline (triggers browser download directly).
+ * Collects files for retrieval by caller.
+ */
+export declare class FileDownloadRuntimeProvider implements SandboxRuntimeProvider {
+    private files;
+    getData(): Record<string, any>;
+    getRuntime(): (sandboxId: string) => void;
+    handleMessage(message: any, respond: (response: any) => void): Promise<void>;
+    /**
+     * Get collected files
+     */
+    getFiles(): DownloadableFile[];
+    /**
+     * Reset state for reuse
+     */
+    reset(): void;
+    getDescription(): string;
+}
+//# sourceMappingURL=FileDownloadRuntimeProvider.d.ts.map

package/dist/webui/components/sandbox/FileDownloadRuntimeProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileDownloadRuntimeProvider.d.ts","sourceRoot":"","sources":["../../../../src/webui/components/sandbox/FileDownloadRuntimeProvider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAE1E,MAAM,WAAW,gBAAgB;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,GAAG,UAAU,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;GAOG;AACH,qBAAa,2BAA4B,YAAW,sBAAsB;IACzE,OAAO,CAAC,KAAK,CAA0B;IAEvC,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAK9B,UAAU,IAAI,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI;IAuDnC,aAAa,CAAC,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC,QAAQ,EAAE,GAAG,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAalF;;OAEG;IACH,QAAQ,IAAI,gBAAgB,EAAE;IAI9B;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb,cAAc,IAAI,MAAM;CAGxB"}