@shareai-lab/kode-sdk 2.7.2 → 2.7.4

package/dist/infra/opensandbox/opensandbox-sandbox.js

@@ -0,0 +1,325 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenSandbox = void 0;
+const opensandbox_1 = require("@alibaba-group/opensandbox");
+const logger_1 = require("../../utils/logger");
+const opensandbox_fs_1 = require("./opensandbox-fs");
+class OpenSandbox {
+    constructor(options) {
+        this.kind = 'opensandbox';
+        this.sandbox = null;
+        this.watchers = new Map();
+        this.options = { ...options };
+        this.workDir = options.workDir || '/workspace';
+        this.fs = new opensandbox_fs_1.OpenSandboxFS(this);
+        this.watchMode = options.watch?.mode || 'polling';
+        this.pollIntervalMs = Math.max(100, options.watch?.pollIntervalMs ?? 1000);
+        this.disposeAction = options.lifecycle?.disposeAction || 'kill';
+    }
+    async init() {
+        if (this.sandbox)
+            return;
+        const connectionConfig = this.buildConnectionConfig();
+        if (this.options.sandboxId) {
+            const connectOptions = {
+                sandboxId: this.options.sandboxId,
+                connectionConfig,
+                skipHealthCheck: this.options.skipHealthCheck,
+                readyTimeoutSeconds: this.options.readyTimeoutSeconds,
+                healthCheckPollingInterval: this.options.healthCheckPollingInterval,
+            };
+            this.sandbox = await opensandbox_1.Sandbox.connect(connectOptions);
+        }
+        else {
+            const createOptions = {
+                connectionConfig,
+                image: this.options.image || this.options.template || 'ubuntu',
+                timeoutSeconds: Math.max(1, Math.ceil((this.options.timeoutMs ?? 10 * 60 * 1000) / 1000)),
+                env: this.options.env,
+                metadata: this.options.metadata,
+                resource: this.options.resource,
+                networkPolicy: this.options.networkPolicy,
+                skipHealthCheck: this.options.skipHealthCheck,
+                readyTimeoutSeconds: this.options.readyTimeoutSeconds,
+                healthCheckPollingInterval: this.options.healthCheckPollingInterval,
+            };
+            this.sandbox = await opensandbox_1.Sandbox.create(createOptions);
+        }
+        // Persist resolved sandbox id for Agent resume metadata.
+        this.options.sandboxId = this.sandbox.id;
+        // Best-effort workdir bootstrap.
+        if (this.workDir && this.workDir !== '/') {
+            await this.sandbox.commands
+                .run(`mkdir -p ${quoteShell(this.workDir)}`, {
+                workingDirectory: '/',
+                timeoutSeconds: 10,
+            })
+                .catch(() => undefined);
+        }
+    }
+    getOpenSandbox() {
+        if (!this.sandbox) {
+            throw new Error('OpenSandbox not initialized. Call init() first.');
+        }
+        return this.sandbox;
+    }
+    getSandboxId() {
+        return this.sandbox?.id || this.options.sandboxId;
+    }
+    async isRunning() {
+        try {
+            const info = await this.getOpenSandbox().getInfo();
+            const state = String(info?.status?.state || '').toLowerCase();
+            return state === 'running';
+        }
+        catch {
+            return false;
+        }
+    }
+    async exec(cmd, opts) {
+        const sandbox = this.getOpenSandbox();
+        const timeoutMs = this.resolveExecTimeoutMs(opts);
+        const timeoutSeconds = Math.max(1, Math.ceil(timeoutMs / 1000));
+        try {
+            const execution = await sandbox.commands.run(cmd, {
+                workingDirectory: this.workDir,
+                timeoutSeconds,
+            });
+            const stdout = execution.logs.stdout.map((m) => m.text).join('');
+            let stderr = execution.logs.stderr.map((m) => m.text).join('');
+            let code = execution.error ? 1 : 0;
+            if (execution.id) {
+                try {
+                    const status = await sandbox.commands.getCommandStatus(execution.id);
+                    if (typeof status.exitCode === 'number') {
+                        code = status.exitCode;
+                    }
+                    else if (status.running === false && status.error) {
+                        code = 1;
+                    }
+                }
+                catch {
+                    // keep fallback code when status API is unavailable
+                }
+            }
+            if (execution.error && !stderr) {
+                const traces = Array.isArray(execution.error.traceback) ? execution.error.traceback.join('\n') : '';
+                stderr = [execution.error.name, execution.error.value, traces].filter(Boolean).join('\n');
+            }
+            return { code, stdout, stderr };
+        }
+        catch (error) {
+            return {
+                code: 1,
+                stdout: '',
+                stderr: error?.message || String(error),
+            };
+        }
+    }
+    async watchFiles(paths, listener) {
+        if (this.watchMode === 'off') {
+            return `watch-disabled-${Date.now()}`;
+        }
+        const id = `opensandbox-watch-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+        const resolved = Array.from(new Set(paths.map((p) => this.fs.resolve(p))));
+        if (this.watchMode === 'native') {
+            const nativeStarted = await this.startNativeWatcher(id, resolved, listener);
+            if (nativeStarted) {
+                return id;
+            }
+            logger_1.logger.warn('[OpenSandbox] native watch unavailable, falling back to polling mode.');
+        }
+        await this.startPollingWatcher(id, resolved, listener);
+        return id;
+    }
+    unwatchFiles(id) {
+        const watcher = this.watchers.get(id);
+        if (!watcher)
+            return;
+        if (watcher.kind === 'polling') {
+            clearInterval(watcher.timer);
+        }
+        else {
+            watcher.abortController.abort();
+        }
+        this.watchers.delete(id);
+    }
+    async dispose() {
+        for (const id of Array.from(this.watchers.keys())) {
+            this.unwatchFiles(id);
+        }
+        if (!this.sandbox)
+            return;
+        let disposeError;
+        const sandbox = this.sandbox;
+        this.sandbox = null;
+        if (this.disposeAction === 'kill') {
+            try {
+                await sandbox.kill();
+            }
+            catch (error) {
+                disposeError = error;
+            }
+        }
+        try {
+            await sandbox.close();
+        }
+        catch (error) {
+            disposeError = disposeError || error;
+        }
+        if (disposeError) {
+            throw disposeError;
+        }
+    }
+    buildConnectionConfig() {
+        const config = {
+            apiKey: this.options.apiKey,
+            domain: this.options.endpoint || this.options.domain,
+            protocol: this.options.protocol,
+            requestTimeoutSeconds: this.options.requestTimeoutSeconds,
+            useServerProxy: this.options.useServerProxy ?? false,
+        };
+        return new opensandbox_1.ConnectionConfig(config);
+    }
+    async pollWatcher(id, listener) {
+        const watcher = this.watchers.get(id);
+        if (!watcher || watcher.kind !== 'polling' || watcher.polling)
+            return;
+        watcher.polling = true;
+        try {
+            do {
+                watcher.pending = false;
+                for (const path of watcher.paths) {
+                    if (!this.watchers.has(id)) {
+                        return;
+                    }
+                    const current = await this.safeMtime(path);
+                    const previous = watcher.lastMtimes.get(path);
+                    watcher.lastMtimes.set(path, current);
+                    if (previous === undefined && current === undefined)
+                        continue;
+                    if (previous === current)
+                        continue;
+                    listener({ path, mtimeMs: current ?? Date.now() });
+                }
+            } while (this.watchers.has(id) && watcher.pending);
+        }
+        finally {
+            if (this.watchers.get(id) === watcher) {
+                watcher.polling = false;
+            }
+        }
+    }
+    async safeMtime(path) {
+        try {
+            const stat = await this.fs.stat(path);
+            return stat.mtimeMs;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    resolveExecTimeoutMs(opts) {
+        return opts?.timeoutMs ?? this.options.execTimeoutMs ?? this.options.timeoutMs ?? 120000;
+    }
+    async startPollingWatcher(id, paths, listener) {
+        const lastMtimes = new Map();
+        for (const p of paths) {
+            lastMtimes.set(p, await this.safeMtime(p));
+        }
+        const watcher = {
+            kind: 'polling',
+            timer: setInterval(() => {
+                const current = this.watchers.get(id);
+                if (!current || current.kind !== 'polling')
+                    return;
+                current.pending = true;
+                if (!current.polling) {
+                    void this.pollWatcher(id, listener);
+                }
+            }, this.pollIntervalMs),
+            paths,
+            lastMtimes,
+            polling: false,
+            pending: true,
+        };
+        this.watchers.set(id, watcher);
+        void this.pollWatcher(id, listener);
+    }
+    async startNativeWatcher(id, paths, listener) {
+        const probe = await this.exec('command -v inotifywait >/dev/null 2>&1 && echo __KODE_INOTIFY_READY__', {
+            timeoutMs: 5000,
+        });
+        if (probe.code !== 0 || !probe.stdout.includes('__KODE_INOTIFY_READY__')) {
+            return false;
+        }
+        const sandbox = this.getOpenSandbox();
+        const abortController = new AbortController();
+        const nativeWatchCommand = buildNativeWatchCommand(paths);
+        let stdoutBuffer = '';
+        const streamTask = (async () => {
+            try {
+                for await (const event of sandbox.commands.runStream(nativeWatchCommand, { workingDirectory: this.workDir }, abortController.signal)) {
+                    if (abortController.signal.aborted) {
+                        break;
+                    }
+                    if (event.type !== 'stdout' || typeof event.text !== 'string') {
+                        continue;
+                    }
+                    stdoutBuffer += event.text;
+                    let lineBreak = stdoutBuffer.indexOf('\n');
+                    while (lineBreak >= 0) {
+                        const line = stdoutBuffer.slice(0, lineBreak).trim();
+                        stdoutBuffer = stdoutBuffer.slice(lineBreak + 1);
+                        if (line) {
+                            listener({ path: line, mtimeMs: Date.now() });
+                        }
+                        lineBreak = stdoutBuffer.indexOf('\n');
+                    }
+                }
+                const tail = stdoutBuffer.trim();
+                if (tail) {
+                    listener({ path: tail, mtimeMs: Date.now() });
+                }
+            }
+            catch (error) {
+                if (!abortController.signal.aborted) {
+                    logger_1.logger.warn('[OpenSandbox] native watch stream failed, fallback to polling.', error);
+                }
+            }
+            finally {
+                const current = this.watchers.get(id);
+                if (!current || current.kind !== 'native' || current.abortController !== abortController) {
+                    return;
+                }
+                this.watchers.delete(id);
+                if (!abortController.signal.aborted) {
+                    try {
+                        await this.startPollingWatcher(id, paths, listener);
+                        logger_1.logger.warn('[OpenSandbox] native watch stopped, switched to polling mode.');
+                    }
+                    catch (error) {
+                        logger_1.logger.warn('[OpenSandbox] failed to start polling fallback after native watch exit.', error);
+                    }
+                }
+            }
+        })();
+        const watcher = {
+            kind: 'native',
+            paths,
+            abortController,
+            streamTask,
+        };
+        this.watchers.set(id, watcher);
+        return true;
+    }
+}
+exports.OpenSandbox = OpenSandbox;
+function quoteShell(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function buildNativeWatchCommand(paths) {
+    const targets = paths.map((p) => quoteShell(p)).join(' ');
+    const script = `exec inotifywait -m -e modify,create,delete,move --format '%w%f' -- ${targets}`;
+    return `sh -lc ${quoteShell(script)}`;
+}

package/dist/infra/opensandbox/types.d.ts

@@ -0,0 +1,30 @@
+export type OpenSandboxWatchMode = 'native' | 'polling' | 'off';
+export interface OpenSandboxOptions {
+    kind: 'opensandbox';
+    apiKey?: string;
+    endpoint?: string;
+    domain?: string;
+    protocol?: 'http' | 'https';
+    sandboxId?: string;
+    image?: string;
+    template?: string;
+    workDir?: string;
+    timeoutMs?: number;
+    execTimeoutMs?: number;
+    requestTimeoutSeconds?: number;
+    useServerProxy?: boolean;
+    env?: Record<string, string>;
+    metadata?: Record<string, string>;
+    resource?: Record<string, string>;
+    networkPolicy?: Record<string, any>;
+    skipHealthCheck?: boolean;
+    readyTimeoutSeconds?: number;
+    healthCheckPollingInterval?: number;
+    watch?: {
+        mode?: OpenSandboxWatchMode;
+        pollIntervalMs?: number;
+    };
+    lifecycle?: {
+        disposeAction?: 'close' | 'kill';
+    };
+}

package/dist/infra/opensandbox/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/infra/providers/anthropic.js

@@ -207,6 +207,10 @@ class AnthropicProvider {
                     degraded = true;
                     return { type: 'text', text: utils_1.AUDIO_UNSUPPORTED_TEXT };
                 }
+                if (block.type === 'video') {
+                    degraded = true;
+                    return { type: 'text', text: utils_1.VIDEO_UNSUPPORTED_TEXT };
+                }
                 if (block.type === 'file') {
                     if (block.file_id) {
                         return {
@@ -214,6 +218,18 @@ class AnthropicProvider {
                             source: { type: 'file', file_id: block.file_id },
                         };
                     }
+                    if (block.base64 && block.mime_type) {
+                        return {
+                            type: 'document',
+                            source: { type: 'base64', media_type: block.mime_type, data: block.base64 },
+                        };
+                    }
+                    if (block.url) {
+                        return {
+                            type: 'document',
+                            source: { type: 'url', url: block.url },
+                        };
+                    }
                     degraded = true;
                     return { type: 'text', text: utils_1.FILE_UNSUPPORTED_TEXT };
                 }

package/dist/infra/providers/gemini.js

@@ -29,14 +29,26 @@ class GeminiProvider {
         this.thinking = options?.thinking;
     }
     async uploadFile(input) {
-        if (input.kind !== 'file') {
+        // Gemini supports uploading audio, video, and file types
+        if (input.kind !== 'file' && input.kind !== 'audio' && input.kind !== 'video') {
             return null;
         }
         const url = new URL(`${this.baseUrl}/files`);
         url.searchParams.set('key', this.apiKey);
+        // Determine display name based on kind
+        let defaultFilename;
+        if (input.kind === 'audio') {
+            defaultFilename = 'audio.wav';
+        }
+        else if (input.kind === 'video') {
+            defaultFilename = 'video.mp4';
+        }
+        else {
+            defaultFilename = 'file.pdf';
+        }
         const body = {
             file: {
-                display_name: input.filename || 'file.pdf',
+                display_name: input.filename || defaultFilename,
                 mime_type: input.mimeType,
             },
             content: input.data.toString('base64'),
@@ -372,8 +384,24 @@ class GeminiProvider {
                     }
                 }
                 else if (block.type === 'audio') {
-                    degraded = true;
-                    parts.push({ text: utils_1.AUDIO_UNSUPPORTED_TEXT });
+                    const audioPart = (0, utils_1.buildGeminiAudioPart)(block);
+                    if (audioPart) {
+                        parts.push(audioPart);
+                    }
+                    else {
+                        degraded = true;
+                        parts.push({ text: utils_1.AUDIO_UNSUPPORTED_TEXT });
+                    }
+                }
+                else if (block.type === 'video') {
+                    const videoPart = (0, utils_1.buildGeminiVideoPart)(block);
+                    if (videoPart) {
+                        parts.push(videoPart);
+                    }
+                    else {
+                        degraded = true;
+                        parts.push({ text: utils_1.VIDEO_UNSUPPORTED_TEXT });
+                    }
                 }
                 else if (block.type === 'file') {
                     const filePart = (0, utils_1.buildGeminiFilePart)(block);

package/dist/infra/providers/openai.js

@@ -458,7 +458,7 @@ class OpenAIProvider {
     buildOpenAIMessages(messages, system, reasoningTransport = 'text') {
         const output = [];
         const toolCallNames = new Map();
-        const useStructuredContent = messages.some((msg) => (0, utils_1.getMessageBlocks)(msg).some((block) => block.type === 'image' || block.type === 'audio' || block.type === 'file'));
+        const useStructuredContent = messages.some((msg) => (0, utils_1.getMessageBlocks)(msg).some((block) => block.type === 'image' || block.type === 'audio' || block.type === 'video' || block.type === 'file'));
         for (const msg of messages) {
             for (const block of (0, utils_1.getMessageBlocks)(msg)) {
                 if (block.type === 'tool_use') {
@@ -585,8 +585,21 @@ class OpenAIProvider {
                 continue;
             }
             if (block.type === 'audio') {
+                // OpenAI Chat Completions API supports audio via input_audio (wav/mp3 base64 only)
+                const audioPart = (0, utils_1.buildOpenAIAudioPart)(block);
+                if (audioPart) {
+                    contentParts.push(audioPart);
+                }
+                else {
+                    degraded = true;
+                    appendText(utils_1.AUDIO_UNSUPPORTED_TEXT);
+                }
+                continue;
+            }
+            if (block.type === 'video') {
+                // OpenAI does not support video input
                 degraded = true;
-                appendText(utils_1.AUDIO_UNSUPPORTED_TEXT);
+                appendText(utils_1.VIDEO_UNSUPPORTED_TEXT);
                 continue;
             }
             if (block.type === 'file') {
@@ -626,8 +639,19 @@ class OpenAIProvider {
                     parts.push({ type: textType, text: `<think>${block.reasoning}</think>` });
                 }
                 else if (block.type === 'audio') {
+                    const audioPart = (0, utils_1.buildOpenAIAudioPart)(block);
+                    if (audioPart) {
+                        parts.push(audioPart);
+                    }
+                    else {
+                        degraded = true;
+                        parts.push({ type: textType, text: utils_1.AUDIO_UNSUPPORTED_TEXT });
+                    }
+                }
+                else if (block.type === 'video') {
+                    // OpenAI Responses API does not support video input
                     degraded = true;
-                    parts.push({ type: textType, text: utils_1.AUDIO_UNSUPPORTED_TEXT });
+                    parts.push({ type: textType, text: utils_1.VIDEO_UNSUPPORTED_TEXT });
                 }
                 else if (block.type === 'file') {
                     if (block.file_id) {

package/dist/infra/providers/types.d.ts

@@ -60,7 +60,7 @@ export interface UploadFileInput {
     data: Buffer;
     mimeType: string;
     filename?: string;
-    kind: 'image' | 'file';
+    kind: 'image' | 'audio' | 'video' | 'file';
 }
 /**
  * File upload result.
@@ -104,6 +104,35 @@ export interface MultimodalOptions {
     maxBase64Bytes?: number;
     /** Allowed MIME types */
     allowMimeTypes?: string[];
+    /** Audio-specific options */
+    audio?: {
+        /** Allowed audio MIME types */
+        allowMimeTypes?: string[];
+        /** Maximum audio duration in seconds */
+        maxDurationSec?: number;
+        /** Custom transcriber callback for providers without native audio support */
+        customTranscriber?: (audio: {
+            base64?: string;
+            url?: string;
+            mimeType?: string;
+        }) => Promise<string>;
+    };
+    /** Video-specific options */
+    video?: {
+        /** Allowed video MIME types */
+        allowMimeTypes?: string[];
+        /** Maximum video duration in seconds */
+        maxDurationSec?: number;
+        /** Custom frame extractor callback for providers without native video support */
+        customFrameExtractor?: (video: {
+            base64?: string;
+            url?: string;
+            mimeType?: string;
+        }) => Promise<Array<{
+            base64: string;
+            mimeType: string;
+        }>>;
+    };
 }
 /**
  * Core model configuration.
@@ -185,12 +214,17 @@ export interface ProviderCapabilities {
     supportsInterleavedThinking: boolean;
     supportsImages: boolean;
     supportsAudio: boolean;
+    supportsVideo: boolean;
+    supportsAudioOutput: boolean;
     supportsFiles: boolean;
     supportsTools: boolean;
     supportsStreaming: boolean;
     supportsCache: boolean;
     maxContextTokens: number;
     maxOutputTokens: number;
+    maxAudioDurationSec?: number;
+    maxVideoDurationSec?: number;
+    maxInlineDataBytes?: number;
     minCacheableTokens?: number;
     maxCacheBreakpoints?: number;
 }

package/dist/infra/providers/utils.d.ts

@@ -1,7 +1,7 @@
 /**
  * Shared utilities for provider implementations.
  */
-import { ContentBlock, Message, ImageContentBlock, FileContentBlock } from '../../core/types';
+import { ContentBlock, Message, ImageContentBlock, FileContentBlock, AudioContentBlock, VideoContentBlock } from '../../core/types';
 import { ReasoningTransport } from './types';
 export declare function resolveProxyUrl(explicit?: string): string | undefined;
 export declare function getProxyDispatcher(proxyUrl?: string): any | undefined;
@@ -18,6 +18,7 @@ export declare function safeJsonStringify(value: any): string;
 export declare const FILE_UNSUPPORTED_TEXT = "[file unsupported] This model does not support PDF input. Please extract text or images first.";
 export declare const IMAGE_UNSUPPORTED_TEXT = "[image unsupported] This model does not support image URLs; please provide base64 data if supported.";
 export declare const AUDIO_UNSUPPORTED_TEXT = "[audio unsupported] This model does not support audio input; please provide a text transcript instead.";
+export declare const VIDEO_UNSUPPORTED_TEXT = "[video unsupported] This model does not support video input; please provide text description or extracted frames instead.";
 export declare function concatTextWithReasoning(blocks: ContentBlock[], reasoningTransport?: ReasoningTransport): string;
 export declare function joinReasoningBlocks(blocks: ContentBlock[]): string;
 /**
@@ -31,6 +32,23 @@ export declare function splitThinkText(text: string): ContentBlock[];
 export declare function extractReasoningDetails(message: any): ContentBlock[];
 export declare function buildGeminiImagePart(block: ImageContentBlock): any | null;
 export declare function buildGeminiFilePart(block: FileContentBlock): any | null;
+export declare function buildGeminiAudioPart(block: AudioContentBlock): any | null;
+export declare function buildGeminiVideoPart(block: VideoContentBlock): any | null;
+/** Supported OpenAI audio formats */
+export declare const OPENAI_SUPPORTED_AUDIO_FORMATS: readonly ["wav", "mp3"];
+export type OpenAIAudioFormat = (typeof OPENAI_SUPPORTED_AUDIO_FORMATS)[number];
+/**
+ * Extract and validate OpenAI audio format from MIME type.
+ * OpenAI Chat Completions API only supports wav and mp3.
+ * @returns The audio format if supported, null otherwise
+ */
+export declare function extractOpenAIAudioFormat(mimeType?: string): OpenAIAudioFormat | null;
+/**
+ * Build OpenAI input_audio content part from AudioContentBlock.
+ * OpenAI only supports base64 encoded audio (no URLs).
+ * @returns The OpenAI input_audio part or null if not supported
+ */
+export declare function buildOpenAIAudioPart(block: AudioContentBlock): any | null;
 export declare function sanitizeGeminiSchema(schema: any): any;
 export declare function hasAnthropicFileBlocks(messages: Message[]): boolean;
 export declare function mergeAnthropicBetaHeader(existing: string | undefined, entries: string[]): string | undefined;