@camerontaylor/paseo-server 0.8.0-fork.1

package/dist/server/server/agent/providers/jsonl-frame-decoder.js

@@ -0,0 +1,149 @@
+const V2_FRAME_BYTES = 1024 * 1024;
+const V2_REASSEMBLED_BYTES = 64 * 1024 * 1024;
+const V2_CHUNK_BYTES = 256 * 1024;
+const V2_BASE64_CHARS = Math.ceil(V2_CHUNK_BYTES / 3) * 4;
+const V2_MAX_CHUNKS = Math.ceil(V2_REASSEMBLED_BYTES / V2_CHUNK_BYTES);
+export function supportsJsonlRpcProtocolV2(message) {
+    return (message.type === "ready" &&
+        Array.isArray(message.supportedProtocolVersions) &&
+        message.supportedProtocolVersions.includes(2) &&
+        message.maxFrameBytes === V2_FRAME_BYTES &&
+        message.maxReassembledFrameBytes === V2_REASSEMBLED_BYTES);
+}
+function objectFrame(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function chunkHeader(frame) {
+    const { chunkId, index, count, byteLength, data } = frame;
+    if (typeof chunkId !== "string" ||
+        chunkId.length === 0 ||
+        chunkId.length > 128 ||
+        typeof index !== "number" ||
+        !Number.isSafeInteger(index) ||
+        index < 0 ||
+        typeof count !== "number" ||
+        !Number.isSafeInteger(count) ||
+        count < 2 ||
+        count > V2_MAX_CHUNKS ||
+        index >= count ||
+        typeof byteLength !== "number" ||
+        !Number.isSafeInteger(byteLength) ||
+        byteLength < V2_FRAME_BYTES ||
+        byteLength > V2_REASSEMBLED_BYTES ||
+        typeof data !== "string" ||
+        data.length === 0) {
+        return null;
+    }
+    return { id: chunkId, index, count, byteLength, data };
+}
+function chunkBytes(data) {
+    if (data.length > V2_BASE64_CHARS)
+        return null;
+    const bytes = Buffer.from(data, "base64");
+    if (bytes.byteLength > V2_CHUNK_BYTES || bytes.toString("base64") !== data)
+        return null;
+    return bytes;
+}
+export class JsonlFrameDecoder {
+    constructor(receiver) {
+        this.receiver = receiver;
+        this.lineBuffer = "";
+        this.assembly = null;
+    }
+    write(text) {
+        this.lineBuffer += text;
+        let newline = this.lineBuffer.indexOf("\n");
+        while (newline !== -1) {
+            const line = this.lineBuffer.slice(0, newline).replace(/\r$/, "");
+            this.lineBuffer = this.lineBuffer.slice(newline + 1);
+            if (line.trim())
+                this.consumeLine(line);
+            newline = this.lineBuffer.indexOf("\n");
+        }
+    }
+    consumeLine(line) {
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch (error) {
+            this.receiver.problem("invalid-json", { error, line });
+            return;
+        }
+        const frame = objectFrame(parsed);
+        if (!frame)
+            return;
+        if (frame.type !== "rpc_chunk") {
+            this.receiver.frame(frame);
+            return;
+        }
+        this.consumeChunk(frame);
+    }
+    consumeChunk(frame) {
+        const header = chunkHeader(frame);
+        if (!header) {
+            this.drop("invalid-chunk", frame);
+            return;
+        }
+        const bytes = chunkBytes(header.data);
+        if (!bytes) {
+            this.drop("invalid-base64");
+            return;
+        }
+        if (!this.assembly) {
+            if (header.index !== 0) {
+                this.receiver.problem("out-of-order-chunk");
+                return;
+            }
+            this.assembly = {
+                id: header.id,
+                count: header.count,
+                byteLength: header.byteLength,
+                parts: [],
+                bytes: 0,
+            };
+        }
+        const assembly = this.assembly;
+        if (assembly.id !== header.id ||
+            assembly.count !== header.count ||
+            assembly.byteLength !== header.byteLength ||
+            assembly.parts.length !== header.index) {
+            this.drop("out-of-order-chunk");
+            return;
+        }
+        assembly.parts.push(bytes);
+        assembly.bytes += bytes.byteLength;
+        if (assembly.bytes > assembly.byteLength) {
+            this.drop("chunk-length-mismatch");
+            return;
+        }
+        if (assembly.parts.length < assembly.count)
+            return;
+        this.assembly = null;
+        if (assembly.bytes !== assembly.byteLength) {
+            this.receiver.problem("chunk-length-mismatch");
+            return;
+        }
+        this.finishAssembly(assembly.parts);
+    }
+    finishAssembly(parts) {
+        try {
+            const text = new TextDecoder("utf-8", { fatal: true }).decode(Buffer.concat(parts));
+            const frame = objectFrame(JSON.parse(text));
+            if (frame)
+                this.receiver.frame(frame);
+            else
+                this.receiver.problem("invalid-chunk-payload");
+        }
+        catch (error) {
+            this.receiver.problem("invalid-chunk-payload", error);
+        }
+    }
+    drop(problem, detail) {
+        this.assembly = null;
+        this.receiver.problem(problem, detail);
+    }
+}
+//# sourceMappingURL=jsonl-frame-decoder.js.map

package/dist/server/server/agent/providers/jsonl-rpc-process.d.ts

@@ -0,0 +1,63 @@
+import { type ChildProcessWithoutNullStreams } from "node:child_process";
+import type { Logger } from "pino";
+export { supportsJsonlRpcProtocolV2 } from "./jsonl-frame-decoder.js";
+/** Default wall-clock timeout for control-plane / short RPC calls. */
+export declare const JSONL_RPC_DEFAULT_TIMEOUT_MS = 30000;
+/**
+ * Pass as `timeoutMs` to wait only for a response, process death, or `close()`.
+ * Use for long-running blocking RPCs (e.g. LLM-backed compact).
+ */
+export declare const JSONL_RPC_NO_TIMEOUT: null;
+export interface JsonlRpcLaunch {
+    command: string;
+    args: string[];
+    cwd: string;
+    env?: Record<string, string>;
+}
+export interface JsonlRpcExit {
+    code: number | null;
+    signal: NodeJS.Signals | null;
+    error: Error;
+}
+export interface JsonlRpcProcessOptions {
+    launch: JsonlRpcLaunch;
+    logger: Logger;
+    diagnosticName?: string;
+    defaultRequestTimeoutMs?: number;
+    spawn?: (launch: JsonlRpcLaunch) => ChildProcessWithoutNullStreams;
+}
+export declare class JsonlRpcProcess {
+    private readonly options;
+    private readonly child;
+    private readonly diagnosticName;
+    private readonly pending;
+    private readonly messageSubscribers;
+    private readonly exitSubscribers;
+    private stderrBuffer;
+    private nextRequestId;
+    private disposed;
+    private readonly frameDecoder;
+    constructor(options: JsonlRpcProcessOptions);
+    onMessage(callback: (message: Record<string, unknown>) => void): () => void;
+    onExit(callback: (exit: JsonlRpcExit) => void): () => void;
+    startRequest(command: {
+        type: string;
+        [key: string]: unknown;
+    }, timeoutMs?: number | null): {
+        id: string;
+        promise: Promise<unknown>;
+    };
+    request(command: {
+        type: string;
+        [key: string]: unknown;
+    }, timeoutMs?: number | null): Promise<unknown>;
+    send(message: Record<string, unknown>): void;
+    close(error?: Error): Promise<void>;
+    private handleStdoutChunk;
+    /** Route a complete logical frame to its consumer (response or subscriber). */
+    private dispatchFrame;
+    private handleResponse;
+    private handleStdinError;
+    private failAll;
+}
+//# sourceMappingURL=jsonl-rpc-process.d.ts.map

package/dist/server/server/agent/providers/jsonl-rpc-process.js

@@ -0,0 +1,207 @@
+import { spawnProcess } from "../../../utils/spawn.js";
+import { terminateWithTreeKill } from "../../../utils/tree-kill.js";
+import { JsonlFrameDecoder } from "./jsonl-frame-decoder.js";
+export { supportsJsonlRpcProtocolV2 } from "./jsonl-frame-decoder.js";
+/** Default wall-clock timeout for control-plane / short RPC calls. */
+export const JSONL_RPC_DEFAULT_TIMEOUT_MS = 30000;
+/**
+ * Pass as `timeoutMs` to wait only for a response, process death, or `close()`.
+ * Use for long-running blocking RPCs (e.g. LLM-backed compact).
+ */
+export const JSONL_RPC_NO_TIMEOUT = null;
+const STDERR_BUFFER_LIMIT = 8192;
+const GRACEFUL_SHUTDOWN_TIMEOUT_MS = 2000;
+const FORCE_SHUTDOWN_TIMEOUT_MS = 1000;
+function assertChildWithPipes(child) {
+    if (!child.stdin || !child.stdout || !child.stderr) {
+        throw new Error("JSONL RPC process was spawned without stdio streams");
+    }
+}
+function spawnJsonlRpcProcess(launch) {
+    const child = spawnProcess(launch.command, launch.args, {
+        cwd: launch.cwd,
+        envOverlay: launch.env,
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    assertChildWithPipes(child);
+    return child;
+}
+export class JsonlRpcProcess {
+    constructor(options) {
+        this.options = options;
+        this.pending = new Map();
+        this.messageSubscribers = new Set();
+        this.exitSubscribers = new Set();
+        this.stderrBuffer = "";
+        this.nextRequestId = 1;
+        this.disposed = false;
+        this.diagnosticName = options.diagnosticName ?? "JSONL RPC";
+        this.frameDecoder = new JsonlFrameDecoder({
+            frame: (message) => this.dispatchFrame(message),
+            problem: (problem, detail) => {
+                this.options.logger.warn({ problem, detail }, `Ignoring invalid ${this.diagnosticName} frame`);
+            },
+        });
+        this.child = (options.spawn ?? spawnJsonlRpcProcess)(options.launch);
+        this.child.stdout.on("data", (chunk) => {
+            this.handleStdoutChunk(chunk.toString());
+        });
+        this.child.stderr.on("data", (chunk) => {
+            this.stderrBuffer += chunk.toString();
+            if (this.stderrBuffer.length > STDERR_BUFFER_LIMIT) {
+                this.stderrBuffer = this.stderrBuffer.slice(-STDERR_BUFFER_LIMIT);
+            }
+        });
+        this.child.stdin.on("error", (error) => {
+            this.handleStdinError(error);
+        });
+        this.child.on("error", (error) => {
+            this.failAll(error instanceof Error ? error : new Error(String(error)));
+        });
+        this.child.on("exit", (code, signal) => {
+            const error = new Error(`${this.diagnosticName} process exited with code ${code ?? "null"} and signal ${signal ?? "null"}\n${this.stderrBuffer}`.trim());
+            const exit = { code, signal, error };
+            for (const subscriber of this.exitSubscribers) {
+                subscriber(exit);
+            }
+            this.failAll(error);
+        });
+    }
+    onMessage(callback) {
+        this.messageSubscribers.add(callback);
+        return () => {
+            this.messageSubscribers.delete(callback);
+        };
+    }
+    onExit(callback) {
+        this.exitSubscribers.add(callback);
+        return () => {
+            this.exitSubscribers.delete(callback);
+        };
+    }
+    startRequest(command, timeoutMs) {
+        if (this.disposed) {
+            return {
+                id: "",
+                promise: Promise.reject(new Error(`${this.diagnosticName} process is closed`)),
+            };
+        }
+        const id = `req_${this.nextRequestId}`;
+        this.nextRequestId += 1;
+        const requestTimeoutMs = timeoutMs === undefined
+            ? (this.options.defaultRequestTimeoutMs ?? JSONL_RPC_DEFAULT_TIMEOUT_MS)
+            : timeoutMs;
+        const startedAt = Date.now();
+        const promise = new Promise((resolve, reject) => {
+            const timer = createRequestTimeout(requestTimeoutMs, () => {
+                this.pending.delete(id);
+                reject(new Error(`${this.diagnosticName} request timed out phase=${command.type} elapsedMs=${Date.now() - startedAt} timeoutMs=${requestTimeoutMs}\n${this.stderrBuffer}`.trim()));
+            });
+            this.pending.set(id, { resolve, reject, timer });
+            this.send({ ...command, id });
+        });
+        return { id, promise };
+    }
+    request(command, timeoutMs) {
+        return this.startRequest(command, timeoutMs).promise;
+    }
+    send(message) {
+        if (this.disposed) {
+            return;
+        }
+        if (this.child.stdin.destroyed || !this.child.stdin.writable) {
+            this.handleStdinError(new Error(`${this.diagnosticName} stdin is not writable`));
+            return;
+        }
+        try {
+            this.child.stdin.write(`${JSON.stringify(message)}\n`);
+        }
+        catch (error) {
+            this.handleStdinError(error);
+        }
+    }
+    async close(error = new Error(`${this.diagnosticName} process is closed`)) {
+        if (this.disposed)
+            return;
+        this.failAll(error);
+        try {
+            this.child.stdin.end();
+        }
+        catch {
+            // Ignore cleanup races.
+        }
+        const result = await terminateWithTreeKill(this.child, {
+            gracefulTimeoutMs: GRACEFUL_SHUTDOWN_TIMEOUT_MS,
+            forceTimeoutMs: FORCE_SHUTDOWN_TIMEOUT_MS,
+            onForceSignal: () => {
+                this.options.logger.warn({ timeoutMs: GRACEFUL_SHUTDOWN_TIMEOUT_MS }, `${this.diagnosticName} process did not exit after SIGTERM; sending SIGKILL`);
+            },
+        });
+        if (result === "kill-timeout") {
+            this.options.logger.warn({ timeoutMs: FORCE_SHUTDOWN_TIMEOUT_MS }, `${this.diagnosticName} process did not report exit after SIGKILL`);
+        }
+    }
+    handleStdoutChunk(chunk) {
+        this.frameDecoder.write(chunk);
+    }
+    /** Route a complete logical frame to its consumer (response or subscriber). */
+    dispatchFrame(message) {
+        if (message.type === "response") {
+            this.handleResponse(message);
+            return;
+        }
+        for (const subscriber of this.messageSubscribers) {
+            subscriber(message);
+        }
+    }
+    handleResponse(response) {
+        if (!response.id) {
+            return;
+        }
+        const pending = this.pending.get(response.id);
+        if (!pending) {
+            return;
+        }
+        if (pending.timer) {
+            clearTimeout(pending.timer);
+        }
+        this.pending.delete(response.id);
+        if (!response.success) {
+            pending.reject(new Error(response.error ?? `${this.diagnosticName} ${response.command ?? "request"} failed`));
+            return;
+        }
+        pending.resolve(response.data);
+    }
+    handleStdinError(error) {
+        if (this.disposed) {
+            return;
+        }
+        const err = error instanceof Error ? error : new Error(String(error));
+        this.options.logger.warn({ err }, `${this.diagnosticName} stdin write failed`);
+        void this.close(err);
+    }
+    failAll(error) {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        for (const pending of this.pending.values()) {
+            if (pending.timer) {
+                clearTimeout(pending.timer);
+            }
+            pending.reject(error);
+        }
+        this.pending.clear();
+    }
+}
+/**
+ * Schedule a request timeout, or return null when the call should wait
+ * indefinitely for a response, process exit, or close().
+ */
+function createRequestTimeout(timeoutMs, onTimeout) {
+    if (timeoutMs == null || !Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+        return null;
+    }
+    return setTimeout(onTimeout, timeoutMs);
+}
+//# sourceMappingURL=jsonl-rpc-process.js.map

package/dist/server/server/agent/providers/kimi-acp-agent.d.ts

@@ -0,0 +1,35 @@
+import type { Logger } from "pino";
+import type { AgentModelDefinition } from "../agent-sdk-types.js";
+import { type ACPCatalogModelResolverContext } from "./acp-agent.js";
+import { GenericACPAgentClient } from "./generic-acp-agent.js";
+interface KimiACPAgentClientOptions {
+    logger: Logger;
+    command: [string, ...string[]];
+    env?: Record<string, string>;
+    providerId?: string;
+    label?: string;
+    providerParams?: unknown;
+}
+/**
+ * Kimi reports different thinking-effort levels per model (a boolean on/off toggle for one
+ * model, a multi-level select for another), but only exposes the *currently selected*
+ * model's levels through `configOptions` — the model list itself carries no per-model
+ * effort metadata. `deriveModelDefinitionsFromACP` can only see whichever model the probe
+ * session defaulted to, so every other model would otherwise inherit that one model's
+ * thinking options.
+ *
+ * Reuse the single catalog probe session to switch through each candidate model in turn and
+ * read back its real thinking options, rather than spawning a probe per model. Skipped
+ * entirely when the provider reports one model or no thinking picker, so a misbehaving ACP
+ * that only advertises a single model pays no extra round trips.
+ *
+ * This lives on the Kimi client, not the base ACP adapter: only Kimi needs the extra
+ * `setSessionConfigOption` round trips, so no other ACP provider risks a slow or
+ * nonconforming agent stalling its catalog probe on model switching.
+ */
+export declare function resolveKimiCatalogModels({ connection, sessionId, models, configOptions, runRequest, transformConfigOptions, logger, provider, }: ACPCatalogModelResolverContext): Promise<AgentModelDefinition[]>;
+export declare class KimiACPAgentClient extends GenericACPAgentClient {
+    constructor(options: KimiACPAgentClientOptions);
+}
+export {};
+//# sourceMappingURL=kimi-acp-agent.d.ts.map

package/dist/server/server/agent/providers/kimi-acp-agent.js

@@ -0,0 +1,65 @@
+import { deriveSelectorOptions, findSelectConfigOption, } from "./acp-agent.js";
+import { toDiagnosticErrorMessage } from "./diagnostic-utils.js";
+import { GenericACPAgentClient } from "./generic-acp-agent.js";
+/**
+ * Kimi reports different thinking-effort levels per model (a boolean on/off toggle for one
+ * model, a multi-level select for another), but only exposes the *currently selected*
+ * model's levels through `configOptions` — the model list itself carries no per-model
+ * effort metadata. `deriveModelDefinitionsFromACP` can only see whichever model the probe
+ * session defaulted to, so every other model would otherwise inherit that one model's
+ * thinking options.
+ *
+ * Reuse the single catalog probe session to switch through each candidate model in turn and
+ * read back its real thinking options, rather than spawning a probe per model. Skipped
+ * entirely when the provider reports one model or no thinking picker, so a misbehaving ACP
+ * that only advertises a single model pays no extra round trips.
+ *
+ * This lives on the Kimi client, not the base ACP adapter: only Kimi needs the extra
+ * `setSessionConfigOption` round trips, so no other ACP provider risks a slow or
+ * nonconforming agent stalling its catalog probe on model switching.
+ */
+export async function resolveKimiCatalogModels({ connection, sessionId, models, configOptions, runRequest, transformConfigOptions, logger, provider, }) {
+    if (models.length <= 1) {
+        return models;
+    }
+    const modelOption = findSelectConfigOption({ configOptions, category: "model" });
+    if (!modelOption || !findSelectConfigOption({ configOptions, category: "thought_level" })) {
+        return models;
+    }
+    const resolved = [];
+    for (const model of models) {
+        try {
+            const response = await runRequest(() => connection.setSessionConfigOption({
+                sessionId,
+                configId: modelOption.id,
+                value: model.id,
+            }));
+            const modelConfigOptions = transformConfigOptions(response.configOptions ?? []);
+            const thinkingOptions = deriveSelectorOptions(modelConfigOptions, "thought_level");
+            resolved.push({
+                ...model,
+                thinkingOptions: thinkingOptions.length > 0 ? thinkingOptions : undefined,
+                defaultThinkingOptionId: thinkingOptions.find((option) => option.isDefault)?.id ?? undefined,
+            });
+        }
+        catch (error) {
+            logger.warn({ modelId: model.id, error: toDiagnosticErrorMessage(error) }, `${provider} catalog probe could not resolve thinking options for model "${model.id}"; keeping its default options`);
+            resolved.push(model);
+        }
+    }
+    return resolved;
+}
+export class KimiACPAgentClient extends GenericACPAgentClient {
+    constructor(options) {
+        super({
+            logger: options.logger,
+            command: options.command,
+            env: options.env,
+            providerId: options.providerId,
+            label: options.label,
+            providerParams: options.providerParams,
+            catalogModelResolver: resolveKimiCatalogModels,
+        });
+    }
+}
+//# sourceMappingURL=kimi-acp-agent.js.map

package/dist/server/server/agent/providers/kiro-acp-agent.d.ts

@@ -0,0 +1,17 @@
+import type { Logger } from "pino";
+import type { ACPExtensionCommandsParser } from "./acp-agent.js";
+import { GenericACPAgentClient } from "./generic-acp-agent.js";
+interface KiroACPAgentClientOptions {
+    logger: Logger;
+    command: [string, ...string[]];
+    env?: Record<string, string>;
+    providerId?: string;
+    label?: string;
+    providerParams?: unknown;
+}
+export declare const parseKiroExtensionCommands: ACPExtensionCommandsParser;
+export declare class KiroACPAgentClient extends GenericACPAgentClient {
+    constructor(options: KiroACPAgentClientOptions);
+}
+export {};
+//# sourceMappingURL=kiro-acp-agent.d.ts.map

package/dist/server/server/agent/providers/kiro-acp-agent.js

@@ -0,0 +1,78 @@
+import { GenericACPAgentClient } from "./generic-acp-agent.js";
+// Kiro CLI publishes its slash commands and skills asynchronously through the
+// `_kiro.dev/commands/available` extension notification shortly after
+// `session/new` resolves. Wait for that first batch so listCommands() doesn't
+// resolve to an empty list before Kiro has reported its commands.
+const KIRO_INITIAL_COMMANDS_WAIT_TIMEOUT_MS = 10000;
+// ACP extension method (per the `_`-prefixed vendor namespace convention) that
+// Kiro CLI uses to publish its slash commands and skills after session/new.
+const KIRO_COMMANDS_AVAILABLE_METHOD = "_kiro.dev/commands/available";
+function isRecord(value) {
+    return value != null && typeof value === "object" && !Array.isArray(value);
+}
+// Maps a `_kiro.dev/commands/available` payload onto Paseo slash commands.
+// Kiro reports built-in slash commands under `commands` (names arrive with a
+// leading "/", e.g. "/agent") and skills/prompts under `prompts` (names without
+// a slash, tagged with a `skill:` serverName). Paseo stores command names
+// without the leading slash — the composer prepends it on insertion.
+function mapKiroAvailableCommands(params) {
+    const result = [];
+    const seen = new Set();
+    const pushEntry = (entry) => {
+        if (!isRecord(entry)) {
+            return;
+        }
+        const rawName = typeof entry.name === "string" ? entry.name.trim() : "";
+        const name = rawName.replace(/^\/+/, "");
+        if (!name || seen.has(name)) {
+            return;
+        }
+        seen.add(name);
+        const description = typeof entry.description === "string" ? entry.description : "";
+        const meta = isRecord(entry.meta) ? entry.meta : null;
+        const argumentHint = meta && typeof meta.hint === "string" ? meta.hint : "";
+        const serverName = typeof entry.serverName === "string" ? entry.serverName : "";
+        const kind = serverName.startsWith("skill:") ? "skill" : "command";
+        result.push({ name, description, argumentHint, kind });
+    };
+    if (Array.isArray(params.commands)) {
+        for (const entry of params.commands) {
+            pushEntry(entry);
+        }
+    }
+    if (Array.isArray(params.prompts)) {
+        for (const entry of params.prompts) {
+            pushEntry(entry);
+        }
+    }
+    return result;
+}
+// Provider-specific parser injected into the generic ACP session via the
+// `extensionCommandsParser` option (mirrors how Cursor/Copilot inject their
+// behavior through constructor options). Kiro advertises its slash commands and
+// skills through the `_kiro.dev/commands/available` extension notification
+// instead of the standard `available_commands_update` session update; this
+// recognizes that one method and returns the parsed commands (possibly empty),
+// or null for any other notification so the base session ignores it.
+export const parseKiroExtensionCommands = (method, params) => {
+    if (method !== KIRO_COMMANDS_AVAILABLE_METHOD) {
+        return null;
+    }
+    return mapKiroAvailableCommands(params);
+};
+export class KiroACPAgentClient extends GenericACPAgentClient {
+    constructor(options) {
+        super({
+            logger: options.logger,
+            command: options.command,
+            env: options.env,
+            providerId: options.providerId,
+            label: options.label,
+            providerParams: options.providerParams,
+            waitForInitialCommands: true,
+            initialCommandsWaitTimeoutMs: KIRO_INITIAL_COMMANDS_WAIT_TIMEOUT_MS,
+            extensionCommandsParser: parseKiroExtensionCommands,
+        });
+    }
+}
+//# sourceMappingURL=kiro-acp-agent.js.map