kodelet 0.4.25-alpha1 → 0.4.31-alpha

package/dist/agent.js

@@ -0,0 +1,956 @@
+import { spawn as spawnProcess } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { EventEmitter } from "node:events";
+import { chmod, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { createServer } from "node:net";
+import os from "node:os";
+import path from "node:path";
+import { createExtensionHost } from "./api.js";
+import { runWithHostRPCClient } from "./context.js";
+const ACP_PROTOCOL_VERSION = 1;
+export class Profile {
+    name;
+    config;
+    constructor(config) {
+        if (typeof config === "string") {
+            this.name = config;
+            this.config = { name: config };
+            return;
+        }
+        const normalized = { ...config };
+        if (normalized.provider === undefined && typeof normalized.profiler === "string") {
+            normalized.provider = normalized.profiler;
+        }
+        delete normalized.profiler;
+        this.name = typeof normalized.name === "string" ? normalized.name : undefined;
+        this.config = normalized;
+    }
+    static named(name) {
+        return new Profile(name);
+    }
+    isNamedOnly() {
+        return Object.keys(this.config).every((key) => key === "name");
+    }
+    toLaunchConfig() {
+        if (this.name && this.isNamedOnly()) {
+            return { args: ["--profile", this.name] };
+        }
+        return {
+            args: [],
+            config: this.config,
+        };
+    }
+}
+export class AgentRunError extends Error {
+    code;
+    signal;
+    stderr;
+    constructor(message, opts) {
+        super(message);
+        this.name = "AgentRunError";
+        this.code = opts.code;
+        this.signal = opts.signal;
+        this.stderr = opts.stderr;
+    }
+}
+class RPCError extends Error {
+    code;
+    data;
+    constructor(error) {
+        super(error.message);
+        this.name = "RPCError";
+        this.code = error.code;
+        this.data = error.data;
+    }
+}
+export class Client {
+    command;
+    cwd;
+    env;
+    spawn;
+    sessions = new Set();
+    constructor(options = {}) {
+        this.command = options.command ?? "kodelet";
+        this.cwd = path.resolve(options.cwd ?? process.cwd());
+        this.env = options.env ?? {};
+        this.spawn = options.spawn ?? ((command, args, spawnOptions) => spawnProcess(command, args, spawnOptions));
+    }
+    async createSession(options = {}) {
+        const bridge = options.extensions?.length
+            ? await InMemoryExtensionBridge.create(options.extensions, { ui: options.ui })
+            : undefined;
+        const cwd = path.resolve(options.cwd ?? this.cwd);
+        const profile = normalizeProfile(options.profile);
+        let launch;
+        let rpc;
+        try {
+            launch = await buildLaunchConfig(profile, bridge);
+            const env = cleanEnv({
+                ...this._baseEnv({ isolateKodeletEnv: launch.configFileMode === "isolated" }),
+                ...launch.env,
+            });
+            const args = [...launch.args, "acp", ...acpServerArgs(options)];
+            rpc = new ACPRPCClient(this._spawn(args, { cwd, env, stdio: ["pipe", "pipe", "pipe"] }));
+            await rpc.initialize();
+            const sessionID = options.resume ? await rpc.loadSession(options.resume, cwd) : await rpc.createSession(cwd);
+            const session = new Session(this, {
+                ...options,
+                cwd,
+                profile,
+                sessionID,
+                rpc,
+                extensionBridge: bridge,
+                tempConfig: launch.tempConfig,
+            });
+            this.sessions.add(session);
+            return session;
+        }
+        catch (error) {
+            await rpc?.close();
+            await bridge?.close();
+            await launch?.tempConfig?.close();
+            throw error;
+        }
+    }
+    async close() {
+        await Promise.all([...this.sessions].map((session) => session.close()));
+        this.sessions.clear();
+    }
+    _spawn(args, options) {
+        return this.spawn(this.command, args, options);
+    }
+    _baseEnv(options = {}) {
+        const env = { ...process.env };
+        if (options.isolateKodeletEnv) {
+            for (const key of Object.keys(env)) {
+                if (key.startsWith("KODELET_")) {
+                    delete env[key];
+                }
+            }
+        }
+        return { ...env, ...this.env };
+    }
+    _deleteSession(session) {
+        this.sessions.delete(session);
+    }
+}
+export class Session extends EventEmitter {
+    cwd;
+    client;
+    rpc;
+    maxTurns;
+    extensionBridge;
+    tempConfig;
+    conversationId;
+    closed = false;
+    running = false;
+    constructor(client, options) {
+        super();
+        this.client = client;
+        this.cwd = options.cwd;
+        this.rpc = options.rpc;
+        this.maxTurns = options.maxTurns;
+        this.conversationId = options.sessionID;
+        this.extensionBridge = options.extensionBridge;
+        this.tempConfig = options.tempConfig;
+    }
+    get id() {
+        return this.conversationId;
+    }
+    on(eventName, listener) {
+        return super.on(eventName, listener);
+    }
+    once(eventName, listener) {
+        return super.once(eventName, listener);
+    }
+    off(eventName, listener) {
+        return super.off(eventName, listener);
+    }
+    async runAndWait(options) {
+        if (this.closed) {
+            throw new Error("Cannot run a closed Kodelet session");
+        }
+        if (this.running) {
+            throw new Error("Cannot run a Kodelet session while another run is in progress");
+        }
+        if (options.maxTurns !== undefined && options.maxTurns !== this.maxTurns) {
+            throw new Error("Per-run maxTurns is not supported by the RPC transport; set maxTurns in createSession instead");
+        }
+        throwIfAlreadyAborted(options.signal);
+        this.running = true;
+        const events = [];
+        const assistantChunks = [];
+        const thinkingActive = { value: false };
+        const toolNames = new Map();
+        const unsubscribe = this.rpc.onNotification((method, params) => {
+            if (method !== "session/update") {
+                return;
+            }
+            this.handleSessionUpdate(params, events, assistantChunks, thinkingActive, toolNames);
+        });
+        const abort = () => this.rpc.cancelSession(this.conversationId);
+        options.signal?.addEventListener("abort", abort, { once: true });
+        this.emitSDKEvent("agent.start", { message: options.message }, events);
+        this.emitSDKEvent("user.message", { content: options.message }, events);
+        try {
+            const result = await this.rpc.prompt(this.conversationId, buildPromptBlocks(options));
+            if (thinkingActive.value) {
+                thinkingActive.value = false;
+                this.emitSDKEvent("assistant.thinking_end", {}, events);
+            }
+            this.emitSDKEvent("assistant.content_end", {}, events);
+            const content = assistantChunks.join("");
+            if (content !== "") {
+                this.emitSDKEvent("assistant.message", { content }, events);
+            }
+            const response = {
+                content,
+                conversationId: this.conversationId,
+                events,
+                exitCode: 0,
+                stopReason: result.stopReason,
+            };
+            this.emitSDKEvent("agent.end", { ...response, events: [...events] }, events);
+            return response;
+        }
+        catch (error) {
+            this.emitSDKEvent("agent.error", { message: errorMessage(error) }, events);
+            throw error;
+        }
+        finally {
+            options.signal?.removeEventListener("abort", abort);
+            unsubscribe();
+            this.running = false;
+        }
+    }
+    async close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        await this.rpc.close();
+        await this.extensionBridge?.close();
+        await this.tempConfig?.close();
+        this.client._deleteSession(this);
+    }
+    handleSessionUpdate(params, events, assistantChunks, thinkingActive, toolNames) {
+        if (!isRecord(params)) {
+            return;
+        }
+        const sessionId = stringField(params, "sessionId");
+        if (sessionId !== this.conversationId) {
+            return;
+        }
+        const update = params.update;
+        if (!isRecord(update)) {
+            return;
+        }
+        switch (stringField(update, "sessionUpdate")) {
+            case "agent_message_chunk": {
+                const content = textFromACPContent(update.content);
+                if (content !== "") {
+                    assistantChunks.push(content);
+                    this.emitSDKEvent("assistant.message_delta", { deltaContent: content }, events, update);
+                }
+                break;
+            }
+            case "agent_thought_chunk": {
+                if (!thinkingActive.value) {
+                    thinkingActive.value = true;
+                    this.emitSDKEvent("assistant.thinking_start", {}, events, update);
+                }
+                const content = textFromACPContent(update.content);
+                if (content !== "") {
+                    this.emitSDKEvent("assistant.thinking_delta", { deltaContent: content }, events, update);
+                }
+                break;
+            }
+            case "tool_call": {
+                const tool = update;
+                const toolCallId = tool.toolCallId;
+                const toolName = toolNameFromUpdate(tool);
+                if (toolCallId && toolName) {
+                    toolNames.set(toolCallId, toolName);
+                }
+                this.emitSDKEvent("tool.call", {
+                    toolName,
+                    input: tool.rawInput,
+                    rawInput: typeof tool.rawInput === "string" ? tool.rawInput : JSON.stringify(tool.rawInput ?? null),
+                    toolCallId,
+                }, events, update);
+                break;
+            }
+            case "tool_call_update": {
+                const tool = update;
+                if (tool.status !== "completed" && tool.status !== "failed") {
+                    return;
+                }
+                const toolCallId = tool.toolCallId;
+                this.emitSDKEvent("tool.result", {
+                    toolName: (toolCallId && toolNames.get(toolCallId)) || toolNameFromUpdate(tool),
+                    result: toolContentToText(tool.content),
+                    toolCallId,
+                    status: tool.status,
+                }, events, update);
+                break;
+            }
+            default:
+                this.emitSDKEvent("event", update, events, update);
+        }
+    }
+    emitSDKEvent(type, data, events, raw) {
+        const event = { type, data, conversationId: this.conversationId, raw };
+        events.push(event);
+        this.emit(type, event);
+        if (type !== "event") {
+            this.emit("event", event);
+        }
+        return event;
+    }
+}
+class ACPRPCClient {
+    child;
+    nextId = 0;
+    pending = new Map();
+    stdoutBuffer = new LineBuffer();
+    stderrChunks = [];
+    notificationHandlers = new Set();
+    closed = false;
+    constructor(child) {
+        this.child = child;
+        if (!child.stdin) {
+            throw new Error("kodelet acp process did not expose stdin");
+        }
+        child.stdout?.on("data", (chunk) => {
+            this.stdoutBuffer.push(String(chunk));
+            for (const line of this.stdoutBuffer.drainLines()) {
+                this.handleLine(line);
+            }
+        });
+        child.stderr?.on("data", (chunk) => {
+            this.stderrChunks.push(String(chunk));
+        });
+        child.once("error", (error) => {
+            this.closed = true;
+            this.rejectPending(error);
+        });
+        child.once("close", (code, signal) => {
+            this.closed = true;
+            const message = this.stderrChunks.join("").trim() || `kodelet acp exited with status ${code ?? "unknown"}${signal ? ` (${signal})` : ""}`;
+            this.rejectPending(new AgentRunError(message, { code, signal, stderr: this.stderrChunks.join("") }));
+        });
+    }
+    async initialize() {
+        await this.request("initialize", {
+            protocolVersion: ACP_PROTOCOL_VERSION,
+            clientCapabilities: {
+                terminal: true,
+                fs: { readTextFile: false, writeTextFile: false },
+            },
+            clientInfo: { name: "kodelet-sdk", title: "Kodelet SDK" },
+        });
+    }
+    async createSession(cwd) {
+        const result = await this.request("session/new", { cwd });
+        if (!isRecord(result) || typeof result.sessionId !== "string") {
+            throw new Error("Invalid session/new response from kodelet acp");
+        }
+        return result.sessionId;
+    }
+    async loadSession(sessionId, cwd) {
+        await this.request("session/load", { sessionId, cwd });
+        return sessionId;
+    }
+    async prompt(sessionId, prompt) {
+        const result = await this.request("session/prompt", { sessionId, prompt });
+        if (!isRecord(result)) {
+            return {};
+        }
+        return { stopReason: stringField(result, "stopReason") };
+    }
+    cancelSession(sessionId) {
+        this.notify("session/cancel", { sessionId });
+    }
+    onNotification(handler) {
+        this.notificationHandlers.add(handler);
+        return () => this.notificationHandlers.delete(handler);
+    }
+    async close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        this.child.kill("SIGTERM");
+        await new Promise((resolve) => {
+            this.child.once("close", () => resolve());
+            setTimeout(resolve, 1000).unref?.();
+        });
+    }
+    request(method, params) {
+        if (this.closed) {
+            throw new Error("kodelet acp process is closed");
+        }
+        const id = ++this.nextId;
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            this.write({ jsonrpc: "2.0", id, method, params });
+        });
+    }
+    notify(method, params) {
+        if (!this.closed) {
+            this.write({ jsonrpc: "2.0", method, params });
+        }
+    }
+    write(message) {
+        this.child.stdin?.write(`${JSON.stringify(message)}\n`);
+    }
+    rejectPending(error) {
+        for (const pending of this.pending.values()) {
+            pending.reject(error);
+        }
+        this.pending.clear();
+    }
+    handleLine(line) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            return;
+        }
+        let message;
+        try {
+            message = JSON.parse(trimmed);
+        }
+        catch {
+            for (const handler of this.notificationHandlers) {
+                handler("$/stdout", { line });
+            }
+            return;
+        }
+        if (message.method && message.id !== undefined && message.id !== null) {
+            this.respondToServerRequest(message);
+            return;
+        }
+        if (message.method) {
+            for (const handler of this.notificationHandlers) {
+                handler(message.method, message.params);
+            }
+            return;
+        }
+        if (typeof message.id !== "number") {
+            return;
+        }
+        const pending = this.pending.get(message.id);
+        if (!pending) {
+            return;
+        }
+        this.pending.delete(message.id);
+        if (message.error) {
+            pending.reject(new RPCError(message.error));
+            return;
+        }
+        pending.resolve(message.result);
+    }
+    respondToServerRequest(message) {
+        this.write({
+            jsonrpc: "2.0",
+            id: message.id,
+            error: { code: -32601, message: `Unsupported client RPC method: ${message.method}` },
+        });
+    }
+}
+class InMemoryExtensionBridge {
+    rootDir;
+    servers;
+    constructor(rootDir, servers) {
+        this.rootDir = rootDir;
+        this.servers = servers;
+    }
+    static async create(entrypoints, options = {}) {
+        const rootDir = await mkdtemp(path.join(os.tmpdir(), "kodelet-sdk-extensions-"));
+        const bridgeId = randomUUID().replace(/-/g, "").slice(0, 16);
+        const servers = [];
+        try {
+            for (const [index, entrypoint] of entrypoints.entries()) {
+                const id = `sdk-${bridgeId}-${index + 1}`;
+                const socketPath = extensionSocketPath(rootDir, id);
+                const host = await createExtensionHost(entrypoint);
+                const server = new ExtensionSocketServer(host, socketPath, options.ui);
+                await server.listen();
+                servers.push(server);
+                const executablePath = path.join(rootDir, `kodelet-extension-${id}`);
+                await writeFile(executablePath, extensionBridgeExecutable(socketPath), "utf8");
+                await chmod(executablePath, 0o755);
+            }
+        }
+        catch (error) {
+            await Promise.allSettled(servers.map((server) => server.close()));
+            await rm(rootDir, { recursive: true, force: true });
+            throw error;
+        }
+        return new InMemoryExtensionBridge(rootDir, servers);
+    }
+    config() {
+        return {
+            enabled: true,
+            local_dir: this.rootDir,
+            allow: [this.rootDir],
+        };
+    }
+    async close() {
+        await Promise.allSettled(this.servers.map((server) => server.close()));
+        await rm(this.rootDir, { recursive: true, force: true });
+    }
+}
+class TempConfig {
+    rootDir;
+    path;
+    constructor(rootDir, path) {
+        this.rootDir = rootDir;
+        this.path = path;
+    }
+    static async create(config) {
+        const rootDir = await mkdtemp(path.join(os.tmpdir(), "kodelet-sdk-config-"));
+        const configPath = path.join(rootDir, "kodelet-config.json");
+        await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+        return new TempConfig(rootDir, configPath);
+    }
+    async close() {
+        await rm(this.rootDir, { recursive: true, force: true });
+    }
+}
+class ExtensionSocketServer {
+    host;
+    socketPath;
+    ui;
+    server;
+    socket;
+    nextId = 0;
+    pending = new Map();
+    constructor(host, socketPath, ui) {
+        this.host = host;
+        this.socketPath = socketPath;
+        this.ui = ui;
+    }
+    async listen() {
+        await rm(this.socketPath, { force: true });
+        this.server = createServer((socket) => {
+            this.socket = socket;
+            const reader = new FrameReader();
+            socket.on("data", (chunk) => {
+                for (const payload of reader.push(chunk)) {
+                    void this.handlePayload(payload, socket);
+                }
+            });
+            socket.on("close", () => {
+                if (this.socket === socket) {
+                    this.socket = undefined;
+                }
+            });
+        });
+        await new Promise((resolve, reject) => {
+            this.server?.once("error", reject);
+            this.server?.listen(this.socketPath, () => {
+                this.server?.off("error", reject);
+                resolve();
+            });
+        });
+    }
+    async close() {
+        for (const pending of this.pending.values()) {
+            pending.reject(new Error("Extension bridge closed"));
+        }
+        this.pending.clear();
+        this.socket?.destroy();
+        await new Promise((resolve) => {
+            if (!this.server) {
+                resolve();
+                return;
+            }
+            this.server.close(() => resolve());
+        });
+        await rm(this.socketPath, { force: true });
+    }
+    async request(method, params) {
+        const localUIResponse = await this.tryHandleLocalUIRequest(method, params);
+        if (localUIResponse.handled) {
+            return localUIResponse.result;
+        }
+        if (!this.socket) {
+            throw new Error("Extension bridge is not connected");
+        }
+        const id = ++this.nextId;
+        writeFrame(this.socket, JSON.stringify({ jsonrpc: "2.0", id, method, params }));
+        return await new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+        });
+    }
+    async handlePayload(payload, socket) {
+        let message;
+        try {
+            message = JSON.parse(payload.toString("utf8"));
+        }
+        catch (error) {
+            writeFrame(socket, JSON.stringify({ jsonrpc: "2.0", id: null, error: { code: -32700, message: errorMessage(error) } }));
+            return;
+        }
+        if (!message.method && message.id !== undefined) {
+            this.handleResponse(message);
+            return;
+        }
+        if (!message.method || message.id === undefined || message.id === null) {
+            return;
+        }
+        try {
+            const result = await runWithHostRPCClient(this, () => this.dispatch(message));
+            writeFrame(socket, JSON.stringify({ jsonrpc: "2.0", id: message.id, result }));
+        }
+        catch (error) {
+            writeFrame(socket, JSON.stringify({ jsonrpc: "2.0", id: message.id, error: { code: -32000, message: errorMessage(error) } }));
+        }
+    }
+    handleResponse(response) {
+        if (typeof response.id !== "number") {
+            return;
+        }
+        const pending = this.pending.get(response.id);
+        if (!pending) {
+            return;
+        }
+        this.pending.delete(response.id);
+        if (response.error) {
+            pending.reject(new Error(response.error.message));
+            return;
+        }
+        pending.resolve(response.result);
+    }
+    async dispatch(message) {
+        switch (message.method) {
+            case "extension.initialize":
+                return this.host.initialize(message.params);
+            case "extension.tool.execute":
+                return await this.host.executeTool(message.params);
+            case "extension.command.execute":
+                return await this.host.executeCommand(message.params);
+            case "extension.event.handle":
+                return await this.host.handleEvent(message.params);
+            case "$/cancelRequest":
+                return undefined;
+            default:
+                throw new Error(`Unknown JSON-RPC method: ${message.method}`);
+        }
+    }
+    async tryHandleLocalUIRequest(method, params) {
+        switch (method) {
+            case "kodelet.ui.input": {
+                if (!this.ui?.input) {
+                    return { handled: true, result: unavailableUI("ui input is not available") };
+                }
+                const value = await this.ui.input(params);
+                return { handled: true, result: value === undefined ? dismissedUI() : { status: "submitted", value } };
+            }
+            case "kodelet.ui.confirm": {
+                if (!this.ui?.confirm) {
+                    return { handled: true, result: unavailableUI("ui confirm is not available") };
+                }
+                const confirmed = await this.ui.confirm(params);
+                return { handled: true, result: { status: "submitted", confirmed } };
+            }
+            case "kodelet.ui.select": {
+                if (!this.ui?.select) {
+                    return { handled: true, result: unavailableUI("ui select is not available") };
+                }
+                const value = await this.ui.select(params);
+                return { handled: true, result: value === undefined ? dismissedUI() : { status: "submitted", value } };
+            }
+            case "kodelet.ui.notify": {
+                if (!this.ui?.notify) {
+                    return { handled: true, result: unavailableUI("ui notify is not available") };
+                }
+                await this.ui.notify(params);
+                return { handled: true, result: { status: "submitted" } };
+            }
+            default:
+                return { handled: false };
+        }
+    }
+}
+class FrameReader {
+    buffer = Buffer.alloc(0);
+    push(chunk) {
+        this.buffer = Buffer.concat([this.buffer, chunk]);
+        const frames = [];
+        while (true) {
+            const frame = tryReadFrame(this.buffer);
+            if (!frame) {
+                return frames;
+            }
+            frames.push(frame.payload);
+            this.buffer = frame.remaining;
+        }
+    }
+}
+class LineBuffer {
+    buffer = "";
+    push(chunk) {
+        this.buffer += chunk;
+    }
+    drainLines() {
+        const lines = [];
+        while (true) {
+            const index = this.buffer.indexOf("\n");
+            if (index === -1) {
+                return lines;
+            }
+            lines.push(this.buffer.slice(0, index).replace(/\r$/, ""));
+            this.buffer = this.buffer.slice(index + 1);
+        }
+    }
+}
+function normalizeProfile(profile) {
+    if (profile === undefined) {
+        return undefined;
+    }
+    return profile instanceof Profile ? profile : new Profile(profile);
+}
+function acpServerArgs(options) {
+    const args = [];
+    if (options.maxTurns !== undefined && options.maxTurns > 0) {
+        args.push("--max-turns", String(options.maxTurns));
+    }
+    return args;
+}
+async function buildLaunchConfig(profile, bridge) {
+    const resolved = profile?.toLaunchConfig();
+    const profileConfig = resolved?.config;
+    const config = pruneUndefined({
+        ...(profileConfig ?? {}),
+        ...(profileConfig && profileConfig.profile === undefined ? { profile: "default" } : {}),
+        ...(bridge ? { extensions: bridge.config() } : {}),
+    });
+    if (Object.keys(config).length === 0) {
+        return { args: resolved?.args ?? [], env: {} };
+    }
+    const tempConfig = await TempConfig.create(config);
+    const configFileMode = profileConfig ? "isolated" : "merge";
+    return {
+        args: resolved?.args ?? [],
+        env: {
+            KODELET_CONFIG_FILE: tempConfig.path,
+            KODELET_CONFIG_FILE_MODE: configFileMode,
+        },
+        tempConfig,
+        configFileMode,
+    };
+}
+function pruneUndefined(value) {
+    const result = {};
+    for (const [key, item] of Object.entries(value)) {
+        if (item === undefined) {
+            continue;
+        }
+        if (isPlainObject(item)) {
+            result[key] = pruneUndefined(item);
+            continue;
+        }
+        result[key] = item;
+    }
+    return result;
+}
+function buildPromptBlocks(options) {
+    const prompt = [{ type: "text", text: options.message }];
+    for (const image of options.images ?? []) {
+        prompt.push(imageToContentBlock(image));
+    }
+    return prompt;
+}
+function throwIfAlreadyAborted(signal) {
+    if (!signal?.aborted) {
+        return;
+    }
+    signal.throwIfAborted();
+    const error = new Error("The operation was aborted");
+    error.name = "AbortError";
+    throw error;
+}
+function imageToContentBlock(image) {
+    const match = image.match(/^data:([^;,]+);base64,(.*)$/);
+    if (match) {
+        return { type: "image", mimeType: match[1], data: match[2] };
+    }
+    return { type: "image", uri: image };
+}
+function textFromACPContent(content) {
+    if (!isRecord(content)) {
+        return "";
+    }
+    if (typeof content.text === "string") {
+        return content.text;
+    }
+    if (isRecord(content.resource) && typeof content.resource.text === "string") {
+        return content.resource.text;
+    }
+    return "";
+}
+function toolNameFromUpdate(update) {
+    if (typeof update.toolName === "string" && update.toolName.trim() !== "") {
+        return update.toolName;
+    }
+    return "";
+}
+function toolContentToText(content) {
+    if (!Array.isArray(content)) {
+        return "";
+    }
+    const parts = [];
+    for (const item of content) {
+        if (!isRecord(item)) {
+            continue;
+        }
+        if (item.type === "content" && isRecord(item.content)) {
+            const text = textFromACPContent(item.content);
+            if (text !== "") {
+                parts.push(text);
+            }
+            continue;
+        }
+        if (typeof item.path === "string") {
+            parts.push(item.path);
+        }
+        if (typeof item.newText === "string") {
+            parts.push(item.newText);
+        }
+    }
+    return parts.join("\n");
+}
+function cleanEnv(env) {
+    return Object.fromEntries(Object.entries(env).filter((entry) => entry[1] !== undefined));
+}
+function stringField(record, key) {
+    const value = record[key];
+    return typeof value === "string" ? value : undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function tryReadFrame(buffer) {
+    const headerEnd = buffer.indexOf("\r\n\r\n");
+    const fallbackHeaderEnd = headerEnd === -1 ? buffer.indexOf("\n\n") : -1;
+    const separatorIndex = headerEnd === -1 ? fallbackHeaderEnd : headerEnd;
+    if (separatorIndex === -1) {
+        return undefined;
+    }
+    const separatorLength = headerEnd === -1 ? 2 : 4;
+    const header = buffer.subarray(0, separatorIndex).toString("ascii");
+    const contentLength = parseContentLength(header);
+    const payloadStart = separatorIndex + separatorLength;
+    const payloadEnd = payloadStart + contentLength;
+    if (buffer.length < payloadEnd) {
+        return undefined;
+    }
+    return {
+        payload: buffer.subarray(payloadStart, payloadEnd),
+        remaining: buffer.subarray(payloadEnd),
+    };
+}
+function parseContentLength(header) {
+    for (const line of header.split(/\r?\n/)) {
+        const [key, value] = line.split(":", 2);
+        if (key?.trim().toLowerCase() === "content-length") {
+            const parsed = Number.parseInt(value?.trim() ?? "", 10);
+            if (Number.isFinite(parsed) && parsed >= 0) {
+                return parsed;
+            }
+        }
+    }
+    throw new Error("Missing Content-Length header");
+}
+function writeFrame(socket, payload) {
+    socket.write(`Content-Length: ${Buffer.byteLength(payload, "utf8")}\r\n\r\n${payload}`);
+}
+function extensionSocketPath(rootDir, id) {
+    if (process.platform === "win32") {
+        return `\\\\.\\pipe\\kodelet-sdk-${process.pid}-${Date.now()}-${id}`;
+    }
+    return path.join(rootDir, `${id}.sock`);
+}
+function extensionBridgeExecutable(socketPath) {
+    return `#!/usr/bin/env node
+const net = require("node:net");
+const process = require("node:process");
+const SOCKET_PATH = ${JSON.stringify(socketPath)};
+
+let stdinBuffer = Buffer.alloc(0);
+let socketBuffer = Buffer.alloc(0);
+const socket = net.createConnection(SOCKET_PATH);
+
+socket.on("data", (chunk) => {
+  socketBuffer = Buffer.concat([socketBuffer, chunk]);
+  while (true) {
+    const frame = tryReadFrame(socketBuffer);
+    if (!frame) break;
+    socketBuffer = frame.remaining;
+    writeFrame(process.stdout, frame.payload);
+  }
+});
+
+socket.on("error", (error) => {
+  process.stderr.write(JSON.stringify({ level: "error", message: "kodelet SDK extension bridge failed", error: error.message }) + "\\n");
+  process.exit(1);
+});
+
+socket.on("close", () => process.exit(0));
+
+process.stdin.on("data", (chunk) => {
+  stdinBuffer = Buffer.concat([stdinBuffer, chunk]);
+  while (true) {
+    const frame = tryReadFrame(stdinBuffer);
+    if (!frame) break;
+    stdinBuffer = frame.remaining;
+    writeFrame(socket, frame.payload);
+  }
+});
+process.stdin.resume();
+
+function tryReadFrame(buffer) {
+  const headerEnd = buffer.indexOf("\\r\\n\\r\\n");
+  const fallbackHeaderEnd = headerEnd === -1 ? buffer.indexOf("\\n\\n") : -1;
+  const separatorIndex = headerEnd === -1 ? fallbackHeaderEnd : headerEnd;
+  if (separatorIndex === -1) return undefined;
+  const separatorLength = headerEnd === -1 ? 2 : 4;
+  const header = buffer.subarray(0, separatorIndex).toString("ascii");
+  const contentLength = parseContentLength(header);
+  const payloadStart = separatorIndex + separatorLength;
+  const payloadEnd = payloadStart + contentLength;
+  if (buffer.length < payloadEnd) return undefined;
+  return { payload: buffer.subarray(payloadStart, payloadEnd), remaining: buffer.subarray(payloadEnd) };
+}
+
+function parseContentLength(header) {
+  for (const line of header.split(/\\r?\\n/)) {
+    const [key, value] = line.split(":", 2);
+    if (key && key.trim().toLowerCase() === "content-length") {
+      const parsed = Number.parseInt((value || "").trim(), 10);
+      if (Number.isFinite(parsed) && parsed >= 0) return parsed;
+    }
+  }
+  throw new Error("Missing Content-Length header");
+}
+
+function writeFrame(stream, payload) {
+  stream.write("Content-Length: " + Buffer.byteLength(payload) + "\\r\\n\\r\\n");
+  stream.write(payload);
+}
+`;
+}
+function unavailableUI(reason) {
+    return { status: "unavailable", reason };
+}
+function dismissedUI() {
+    return { status: "dismissed" };
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=agent.js.map