glm-acp-agent 1.0.0

package/dist/protocol/agent.js

@@ -0,0 +1,732 @@
+import { randomUUID } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { join as pathJoin } from "node:path";
+import { PROTOCOL_VERSION as VERSION } from "@agentclientprotocol/sdk";
+import { GlmClient, getAvailableModels, getDefaultModel, } from "../llm/glm-client.js";
+import { ToolExecutor } from "../tools/executor.js";
+import { TOOL_DEFINITIONS } from "../tools/definitions.js";
+import { SessionStore } from "./session-store.js";
+import { buildSystemPrompt } from "./system-prompt.js";
+import { preprocessImageBlocks, buildPromptBlockDiagnosticLines } from "./image-preprocessor.js";
+import { StdioVisionMcpClient } from "../tools/vision-mcp-client.js";
+import { resolveApiKey } from "../llm/credentials.js";
+import { debug, error, isDebugEnabled } from "../llm/logger.js";
+/**
+ * Maximum bytes of AGENTS.md / CLAUDE.md to embed in the system prompt.
+ * Caps the input-token cost of a single project's context. Z.AI prompt
+ * caching will absorb repeated reads across turns of the same session, but
+ * this still bounds the worst case for projects that ship enormous spec
+ * files in their AGENTS.md.
+ */
+const PROJECT_CONTEXT_CAP_CHARS = 8 * 1024;
+/**
+ * GlmAcpAgent implements the ACP `Agent` interface.
+ *
+ * It bridges the ACP protocol (via `AgentSideConnection`) and the Zhipu AI
+ * GLM series models (via `GlmClient`), providing a full prompt loop with
+ * tool-calling and streaming support.
+ */
+export class GlmAcpAgent {
+    connection;
+    sessions = new Map();
+    _glm;
+    maxTurns;
+    clientCapabilities = null;
+    sessionStore;
+    _visionClient;
+    visionClientExplicit;
+    constructor(connection, options = {}) {
+        this.connection = connection;
+        this._glm = options.glm ?? null;
+        const candidateMaxTurns = options.maxTurns ?? 20;
+        this.maxTurns =
+            Number.isFinite(candidateMaxTurns) && candidateMaxTurns > 0
+                ? Math.floor(candidateMaxTurns)
+                : 20;
+        this.sessionStore =
+            options.sessionStore === null
+                ? null
+                : (options.sessionStore ?? new SessionStore());
+        this.visionClientExplicit = "visionClient" in options;
+        this._visionClient = options.visionClient ?? null;
+    }
+    get glm() {
+        if (this._glm === null) {
+            this._glm = new GlmClient();
+        }
+        return this._glm;
+    }
+    get visionClient() {
+        if (this.visionClientExplicit)
+            return this._visionClient;
+        if (!this._visionClient) {
+            const apiKey = resolveApiKey();
+            if (!apiKey)
+                return null;
+            this._visionClient = new StdioVisionMcpClient({ apiKey });
+        }
+        return this._visionClient;
+    }
+    // ---------------------------------------------------------------------------
+    // ACP Lifecycle
+    // ---------------------------------------------------------------------------
+    async initialize(params) {
+        // Negotiate the lowest version both sides support.
+        const negotiatedVersion = params.protocolVersion <= VERSION ? params.protocolVersion : VERSION;
+        // Track client capabilities so we can adapt tool calls to what the client
+        // actually supports.
+        this.clientCapabilities = params.clientCapabilities ?? null;
+        return {
+            protocolVersion: negotiatedVersion,
+            agentInfo: {
+                name: "glm-acp-agent",
+                version: "1.0.0",
+            },
+            // Advertise auth methods so the ACP registry verifier and capable
+            // clients can discover how to configure us. The `agent`-default method
+            // (no `type` discriminator) signals that the agent reads its credentials
+            // itself at startup; the experimental `env_var` method gives clients
+            // that support it the metadata to prompt the user for the right var.
+            authMethods: [
+                {
+                    id: "z-ai-api-key",
+                    name: "Z.AI API key",
+                    description: "Set Z_AI_API_KEY in the environment, or run `glm-acp-agent --setup` once to store the key on disk. Generate one at https://z.ai/manage-apikey/apikey-list",
+                },
+                {
+                    type: "env_var",
+                    id: "z_ai_api_key",
+                    name: "Z.AI API key",
+                    description: "API key for the Z.AI / Zhipu AI service. Generate one at https://z.ai/manage-apikey/apikey-list",
+                    link: "https://z.ai/manage-apikey/apikey-list",
+                    vars: [
+                        {
+                            name: "Z_AI_API_KEY",
+                            label: "Z.AI API key",
+                            secret: true,
+                            optional: false,
+                        },
+                    ],
+                },
+            ],
+            agentCapabilities: {
+                loadSession: true,
+                promptCapabilities: {
+                    // Baseline (text + resource_link) is implicit; we additionally accept
+                    // embedded resources for inline file context, plus images for
+                    // vision-capable GLM models (e.g. glm-4v-plus).
+                    // Set ACP_GLM_PROMPT_IMAGES=false (or =0) to stop advertising image
+                    // support so clients like Zed won't offer the image-attachment UI.
+                    embeddedContext: true,
+                    image: process.env["ACP_GLM_PROMPT_IMAGES"] !== "false" &&
+                        process.env["ACP_GLM_PROMPT_IMAGES"] !== "0",
+                },
+                sessionCapabilities: {
+                    close: {},
+                    list: {},
+                    fork: {},
+                    resume: {},
+                },
+            },
+        };
+    }
+    async authenticate(_params) {
+        // Authentication is configured externally — either via Z_AI_API_KEY in the
+        // environment or via the credentials file written by `glm-acp-agent --setup`.
+        // The agent has nothing to do here; failures will surface when the model
+        // is first called.
+        return {};
+    }
+    async newSession(params) {
+        const sessionId = randomUUID();
+        debug(`newSession: id=${sessionId} cwd=${params.cwd} model=${getDefaultModel()}`);
+        const systemPrompt = {
+            role: "system",
+            content: buildSystemPrompt({
+                cwd: params.cwd,
+                tools: this.availableToolNames(),
+                agentsMd: loadProjectContext(params.cwd),
+            }),
+        };
+        const model = getDefaultModel();
+        this.sessions.set(sessionId, {
+            cwd: params.cwd,
+            messages: [systemPrompt],
+            abortController: null,
+            promptPromise: null,
+            title: null,
+            updatedAt: new Date().toISOString(),
+            model,
+        });
+        return {
+            sessionId,
+            models: this.modelsState(model),
+        };
+    }
+    async unstable_setSessionModel(params) {
+        const session = this.sessions.get(params.sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${params.sessionId}`);
+        }
+        const available = getAvailableModels();
+        const known = available.find((m) => m.modelId === params.modelId);
+        if (!known) {
+            // Allow the caller to pick any model id even if not in the curated list
+            // (Z.AI may offer models we haven't catalogued), but log a stderr hint.
+            process.stderr.write(`[glm-acp-agent] warning: model "${params.modelId}" is not in the advertised list; using as-is.\n`);
+        }
+        session.model = params.modelId;
+        session.updatedAt = new Date().toISOString();
+        // Notify clients so any UI that displays the active model refreshes
+        // immediately, instead of waiting for the next prompt to complete.
+        await safeSessionUpdate(this.connection, {
+            sessionId: params.sessionId,
+            update: {
+                sessionUpdate: "session_info_update",
+                updatedAt: session.updatedAt,
+            },
+        });
+        return {};
+    }
+    /** Build the SessionModelState we advertise on session create/load/resume/fork. */
+    modelsState(currentModelId) {
+        return {
+            availableModels: getAvailableModels(),
+            currentModelId,
+        };
+    }
+    async setSessionMode(_params) {
+        // We don't advertise modes; this is a no-op accepting any request the
+        // client might send.
+        return {};
+    }
+    // ---------------------------------------------------------------------------
+    // Prompt Turn
+    // ---------------------------------------------------------------------------
+    async prompt(params) {
+        const session = this.sessions.get(params.sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${params.sessionId}`);
+        }
+        // The ACP spec serializes prompts per-session – the client should not send
+        // a new prompt while another is running. Defensively cancel any stale
+        // controller and wait for the previous loop to fully unwind so it stops
+        // mutating session.messages or emitting updates before we start the new
+        // one.
+        if (session.abortController) {
+            session.abortController.abort();
+        }
+        if (session.promptPromise) {
+            try {
+                await session.promptPromise;
+            }
+            catch {
+                // The previous loop's failure is already reported back to its caller.
+            }
+        }
+        const abortController = new AbortController();
+        session.abortController = abortController;
+        // Abort the prompt automatically if the underlying connection closes.
+        const onConnectionClose = () => abortController.abort();
+        const connSignal = this.connection.signal;
+        if (connSignal && !connSignal.aborted) {
+            connSignal.addEventListener("abort", onConnectionClose, { once: true });
+        }
+        else if (connSignal?.aborted) {
+            abortController.abort();
+        }
+        // Convert ACP content blocks into a GLM user message. Baseline: text +
+        // resource_link. Optional: embedded resources. Image blocks are routed
+        // through Z.AI Coding Plan Vision MCP (see image-preprocessor) so the
+        // result is always a plain string for the chat-completions endpoint.
+        if (isDebugEnabled()) {
+            for (const line of buildPromptBlockDiagnosticLines(params.prompt)) {
+                debug(line);
+            }
+        }
+        let preprocessed;
+        preprocessed = await preprocessImageBlocks(params.prompt, this.visionClient, abortController.signal);
+        const { content: userContent, plainText: userText } = renderPromptBlocks(preprocessed.blocks);
+        session.messages.push({ role: "user", content: userContent });
+        // Echo back the client-supplied messageId on every response (success,
+        // cancelled, or error) so the client can correlate the turn.
+        const userMessageId = params.messageId ?? undefined;
+        let resolvePromptPromise;
+        session.promptPromise = new Promise((resolve) => {
+            resolvePromptPromise = resolve;
+        });
+        try {
+            const { stopReason, usage } = await this.runPromptLoop(params.sessionId, session, abortController.signal);
+            session.abortController = null;
+            session.updatedAt = new Date().toISOString();
+            // Emit a session_info_update with the (possibly first-set) title and
+            // updated timestamp so clients can show fresh metadata.
+            const titleUpdate = session.title === null
+                ? (() => {
+                    const derived = userText.slice(0, 80).replace(/\s+/g, " ").trim();
+                    session.title = derived.length > 0 ? derived : "New conversation";
+                    return { title: session.title };
+                })()
+                : {};
+            await this.connection.sessionUpdate({
+                sessionId: params.sessionId,
+                update: {
+                    sessionUpdate: "session_info_update",
+                    updatedAt: session.updatedAt,
+                    ...titleUpdate,
+                },
+            });
+            this.persistSession(params.sessionId, session);
+            const response = { stopReason };
+            if (usage)
+                response.usage = usage;
+            if (userMessageId)
+                response.userMessageId = userMessageId;
+            return response;
+        }
+        catch (err) {
+            error(`prompt error: session=${params.sessionId}`, err instanceof Error ? err.message : String(err));
+            // If the abort happened concurrently with another error, prefer the
+            // cancelled stop reason – that's what the spec asks for.
+            if (abortController.signal.aborted) {
+                session.abortController = null;
+                const cancelled = { stopReason: "cancelled" };
+                if (userMessageId)
+                    cancelled.userMessageId = userMessageId;
+                return cancelled;
+            }
+            session.abortController = null;
+            // Surface the error to the user as an agent message so the IDE displays
+            // something instead of a silent JSON-RPC error.
+            const message = err instanceof Error ? err.message : String(err);
+            await safeSessionUpdate(this.connection, {
+                sessionId: params.sessionId,
+                update: {
+                    sessionUpdate: "agent_message_chunk",
+                    content: { type: "text", text: `\n\n[error] ${message}` },
+                },
+            });
+            throw err;
+        }
+        finally {
+            connSignal?.removeEventListener("abort", onConnectionClose);
+            // Always resolve the promptPromise so a subsequent prompt can proceed.
+            session.promptPromise = null;
+            resolvePromptPromise();
+            for (const cleanup of preprocessed?.cleanups ?? []) {
+                try {
+                    await cleanup();
+                }
+                catch { /* best effort */ }
+            }
+        }
+    }
+    async cancel(params) {
+        const session = this.sessions.get(params.sessionId);
+        session?.abortController?.abort();
+    }
+    async closeSession(params) {
+        const session = this.sessions.get(params.sessionId);
+        session?.abortController?.abort();
+        if (session) {
+            // Persist final state on close so a subsequent loadSession/resume can
+            // pick the conversation back up. closeSession only releases in-memory
+            // resources; the on-disk record is intentionally retained.
+            this.persistSession(params.sessionId, session);
+        }
+        this.sessions.delete(params.sessionId);
+    }
+    async listSessions(params) {
+        // Merge in-memory sessions with anything previously persisted to disk. The
+        // store is the source of truth for closed/restarted sessions; in-memory
+        // state takes precedence when both exist (it has the freshest title /
+        // updatedAt before persistence has fired).
+        //
+        // We use the metadata-only store API so we don't load every conversation's
+        // full message history just to render a session picker.
+        const merged = new Map();
+        if (this.sessionStore) {
+            for (const meta of this.sessionStore.listMetadata()) {
+                merged.set(meta.sessionId, {
+                    cwd: meta.cwd,
+                    title: meta.title,
+                    updatedAt: meta.updatedAt,
+                });
+            }
+        }
+        for (const [sessionId, s] of this.sessions) {
+            merged.set(sessionId, {
+                cwd: s.cwd,
+                title: s.title,
+                updatedAt: s.updatedAt,
+            });
+        }
+        const all = Array.from(merged.entries());
+        const filtered = params.cwd
+            ? all.filter(([, s]) => s.cwd === params.cwd)
+            : all;
+        // Newest-first so clients can render the picker without re-sorting.
+        filtered.sort(([, a], [, b]) => a.updatedAt < b.updatedAt ? 1 : a.updatedAt > b.updatedAt ? -1 : 0);
+        return {
+            sessions: filtered.map(([sessionId, s]) => ({
+                sessionId,
+                cwd: s.cwd,
+                title: s.title ?? undefined,
+                updatedAt: s.updatedAt,
+            })),
+        };
+    }
+    // ---------------------------------------------------------------------------
+    // Session load / fork / resume
+    // ---------------------------------------------------------------------------
+    async loadSession(params) {
+        const persisted = this.requirePersisted(params.sessionId);
+        // Restore in-memory state. We do NOT carry over the abortController /
+        // promptPromise — those are transient.
+        const restored = {
+            cwd: params.cwd,
+            messages: persisted.messages,
+            abortController: null,
+            promptPromise: null,
+            title: persisted.title,
+            updatedAt: persisted.updatedAt,
+            model: persisted.model,
+        };
+        this.sessions.set(params.sessionId, restored);
+        // Replay user/assistant text turns so the client can rehydrate its UI.
+        // Tool / system messages are skipped — they're internal and the client
+        // doesn't render them on its own.
+        await this.replayMessages(params.sessionId, persisted.messages);
+        return { models: this.modelsState(persisted.model) };
+    }
+    async unstable_forkSession(params) {
+        const source = this.sessions.get(params.sessionId);
+        const persisted = source
+            ? this.snapshot(params.sessionId, source)
+            : this.requirePersisted(params.sessionId);
+        const newSessionId = randomUUID();
+        const forkedTitle = persisted.title === null ? null : `${persisted.title} (fork)`;
+        const forked = {
+            cwd: params.cwd,
+            // Deep-clone messages so the fork doesn't share state with the parent.
+            messages: structuredClone(persisted.messages),
+            abortController: null,
+            promptPromise: null,
+            title: forkedTitle,
+            updatedAt: new Date().toISOString(),
+            model: persisted.model,
+        };
+        this.sessions.set(newSessionId, forked);
+        this.persistSession(newSessionId, forked);
+        return {
+            sessionId: newSessionId,
+            models: this.modelsState(forked.model),
+        };
+    }
+    async resumeSession(params) {
+        const persisted = this.requirePersisted(params.sessionId);
+        const restored = {
+            cwd: params.cwd,
+            messages: persisted.messages,
+            abortController: null,
+            promptPromise: null,
+            title: persisted.title,
+            updatedAt: persisted.updatedAt,
+            model: persisted.model,
+        };
+        this.sessions.set(params.sessionId, restored);
+        // Resume does NOT replay history — the client keeps its own UI state and
+        // just wants the agent to pick up where it left off.
+        return { models: this.modelsState(persisted.model) };
+    }
+    // ---------------------------------------------------------------------------
+    // Persistence helpers
+    // ---------------------------------------------------------------------------
+    snapshot(sessionId, session) {
+        return {
+            sessionId,
+            cwd: session.cwd,
+            messages: session.messages,
+            title: session.title,
+            updatedAt: session.updatedAt,
+            model: session.model,
+        };
+    }
+    persistSession(sessionId, session) {
+        if (!this.sessionStore)
+            return;
+        try {
+            this.sessionStore.save(this.snapshot(sessionId, session));
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`[glm-acp-agent] warning: failed to persist session ${sessionId}: ${msg}\n`);
+        }
+    }
+    requirePersisted(sessionId) {
+        if (!this.sessionStore) {
+            throw new Error("Session persistence is disabled");
+        }
+        const persisted = this.sessionStore.load(sessionId);
+        if (!persisted) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        return persisted;
+    }
+    async replayMessages(sessionId, messages) {
+        for (const msg of messages) {
+            if (msg.role === "user") {
+                const text = stringifyUserMessage(msg.content);
+                if (text.length === 0)
+                    continue;
+                await this.connection.sessionUpdate({
+                    sessionId,
+                    update: {
+                        sessionUpdate: "user_message_chunk",
+                        content: { type: "text", text },
+                    },
+                });
+            }
+            else if (msg.role === "assistant") {
+                const content = msg.content;
+                const text = typeof content === "string"
+                    ? content
+                    : Array.isArray(content)
+                        ? content
+                            .filter((p) => typeof p === "object" &&
+                            p !== null &&
+                            p.type === "text" &&
+                            typeof p.text === "string")
+                            .map((p) => p.text)
+                            .join("")
+                        : "";
+                if (text.length === 0)
+                    continue;
+                await this.connection.sessionUpdate({
+                    sessionId,
+                    update: {
+                        sessionUpdate: "agent_message_chunk",
+                        content: { type: "text", text },
+                    },
+                });
+            }
+            // system / tool messages are not replayed — they're internal.
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Internal prompt loop
+    // ---------------------------------------------------------------------------
+    /**
+     * Runs the full prompt/tool-calling loop until the model stops or is cancelled.
+     *
+     * Returns the ACP stop reason and optional token usage reported by the model.
+     */
+    async runPromptLoop(sessionId, session, signal) {
+        const executor = new ToolExecutor(this.connection, sessionId, this.clientCapabilities, signal, this.visionClient);
+        let lastUsage;
+        for (let turn = 0; turn < this.maxTurns; turn++) {
+            if (signal.aborted)
+                return { stopReason: "cancelled" };
+            debug(`promptLoop: turn=${turn} session=${sessionId} model=${session.model} messages=${session.messages.length}`);
+            const toolCalls = [];
+            let assistantText = "";
+            let lastStopReason;
+            // Stream the GLM response. The session's currently-selected model wins;
+            // it's mutated by `unstable_setSessionModel` between turns.
+            for await (const chunk of this.glm.streamChat(session.messages, signal, {
+                model: session.model,
+            })) {
+                if (signal.aborted)
+                    return { stopReason: "cancelled" };
+                if (chunk.thinking) {
+                    await this.connection.sessionUpdate({
+                        sessionId,
+                        update: {
+                            sessionUpdate: "agent_thought_chunk",
+                            content: { type: "text", text: chunk.thinking },
+                        },
+                    });
+                }
+                if (chunk.text) {
+                    assistantText += chunk.text;
+                    await this.connection.sessionUpdate({
+                        sessionId,
+                        update: {
+                            sessionUpdate: "agent_message_chunk",
+                            content: { type: "text", text: chunk.text },
+                        },
+                    });
+                }
+                if (chunk.toolCall) {
+                    debug(`promptLoop: toolCall id=${chunk.toolCall.id} name=${chunk.toolCall.name}`);
+                    toolCalls.push(chunk.toolCall);
+                }
+                if (chunk.usage) {
+                    lastUsage = chunk.usage;
+                }
+                if (chunk.done) {
+                    lastStopReason = chunk.stopReason;
+                }
+            }
+            // Record the assistant turn in history so the model has full context for
+            // the next iteration.
+            if (toolCalls.length > 0) {
+                session.messages.push({
+                    role: "assistant",
+                    content: assistantText.length > 0 ? assistantText : null,
+                    tool_calls: toolCalls.map((tc) => ({
+                        id: tc.id,
+                        type: "function",
+                        function: { name: tc.name, arguments: tc.arguments },
+                    })),
+                });
+            }
+            else if (assistantText.length > 0) {
+                session.messages.push({ role: "assistant", content: assistantText });
+            }
+            // No tool calls => model is done.
+            if (toolCalls.length === 0) {
+                return { stopReason: this.mapStopReason(lastStopReason), usage: lastUsage };
+            }
+            // Execute tool calls in declaration order and feed each result back.
+            for (const tc of toolCalls) {
+                if (signal.aborted)
+                    return { stopReason: "cancelled", usage: lastUsage };
+                const result = await executor.execute(tc.id, tc.name, tc.arguments);
+                debug(`promptLoop: toolResult id=${tc.id} name=${tc.name} contentLength=${result.content.length}`);
+                session.messages.push({
+                    role: "tool",
+                    tool_call_id: tc.id,
+                    content: result.content,
+                });
+            }
+            // Loop and continue – GLM expects a follow-up completion now that it has
+            // tool results.
+        }
+        // Reached MAX_TURNS without resolution.
+        return { stopReason: "max_turn_requests", usage: lastUsage };
+    }
+    mapStopReason(stopReason) {
+        switch (stopReason) {
+            case "length":
+                return "max_tokens";
+            case "content_filter":
+                return "refusal";
+            case "stop":
+            case "tool_calls":
+            case undefined:
+            case null:
+            case "":
+                return "end_turn";
+            default:
+                return "end_turn";
+        }
+    }
+    /** Names of tools we expose given the client's capabilities. */
+    availableToolNames() {
+        // If the client never sent capabilities at all (initialize wasn't called,
+        // or it omitted the field), advertise the full set so the system prompt
+        // still mentions every tool. The executor will surface a clean error if
+        // the model invokes one whose capability is missing.
+        if (!this.clientCapabilities) {
+            return TOOL_DEFINITIONS.map((t) => t.function.name);
+        }
+        const fs = this.clientCapabilities.fs ?? {};
+        const terminal = this.clientCapabilities.terminal ?? false;
+        const names = [];
+        if (fs.readTextFile)
+            names.push("read_file");
+        if (fs.writeTextFile)
+            names.push("write_file");
+        if (terminal)
+            names.push("list_files", "run_command");
+        // Web tools and image_analysis run inside the agent process, so they are
+        // unconditional except when vision is explicitly disabled.
+        names.push("web_search", "web_reader");
+        if (this.visionClientExplicit ? this._visionClient !== null : true) {
+            names.push("image_analysis");
+        }
+        return names;
+    }
+}
+/**
+ * Render a list of ACP content blocks (after image preprocessing) into the
+ * plain-string user message we send to the chat-completions endpoint.
+ *
+ * `plainText` mirrors `content` and is used by the agent to derive a session
+ * title.
+ */
+function renderPromptBlocks(blocks) {
+    const textParts = [];
+    for (const block of blocks) {
+        switch (block.type) {
+            case "text":
+                textParts.push(block.text);
+                break;
+            case "resource_link":
+                textParts.push(`[${block.name}](${block.uri})`);
+                break;
+            case "resource": {
+                const res = block.resource;
+                if ("text" in res && typeof res.text === "string") {
+                    textParts.push(`<resource uri="${res.uri}">\n${res.text}\n</resource>`);
+                }
+                else if ("blob" in res) {
+                    textParts.push(`[binary resource](${res.uri})`);
+                }
+                break;
+            }
+            case "image": {
+                // Defensive: image blocks should have been preprocessed away upstream.
+                textParts.push(`[image: ${block.mimeType}]`);
+                break;
+            }
+            case "audio":
+                textParts.push("[unsupported audio block]");
+                break;
+            default:
+                textParts.push(`[unknown block type ${block.type}]`);
+        }
+    }
+    const plainText = textParts.join("\n");
+    return { content: plainText, plainText };
+}
+/** Flatten the `content` of a user message into a plain string for replay. */
+function stringifyUserMessage(content) {
+    return typeof content === "string" ? content : "";
+}
+/**
+ * Read an `AGENTS.md` (preferred) or `CLAUDE.md` from the session's cwd, returning
+ * its contents capped to {@link PROJECT_CONTEXT_CAP_CHARS} characters. Read errors
+ * (file missing, no permission, directory missing) are intentionally swallowed —
+ * project context is optional, and a missing file is the common case.
+ *
+ * Called once at `newSession` time (not per prompt) so the project context is
+ * stable across the conversation.
+ */
+function loadProjectContext(cwd) {
+    for (const filename of ["AGENTS.md", "CLAUDE.md"]) {
+        let contents;
+        try {
+            contents = readFileSync(pathJoin(cwd, filename), { encoding: "utf-8" });
+        }
+        catch {
+            continue;
+        }
+        if (contents.length > PROJECT_CONTEXT_CAP_CHARS) {
+            contents = contents.slice(0, PROJECT_CONTEXT_CAP_CHARS);
+        }
+        return contents;
+    }
+    return undefined;
+}
+/** sessionUpdate that swallows transport errors during error reporting. */
+async function safeSessionUpdate(connection, params) {
+    try {
+        await connection.sessionUpdate(params);
+    }
+    catch {
+        // best-effort
+    }
+}
+//# sourceMappingURL=agent.js.map