lark-remote 0.1.0

package/dist/runner/pi/jsonl.js

@@ -0,0 +1,249 @@
+/**
+ * Accumulates pi's incremental message_update events and emits normalized
+ * AgentEvents. Content mapping: text→TextContent, thinking→ThinkingContent,
+ * toolCall→ToolUseContent (input:arguments), toolResult→ToolResultContent.
+ *
+ * Implements RunnerTranslator so the base SpawningRunner can drive it
+ * uniformly. pi has no agent-reported terminal error (no equivalent of codex
+ * `turn.failed`), so isTerminal/finish/getTerminalError/hasAgentTerminalError
+ * are no-ops — pi relies entirely on the base class's signal/code-based
+ * result event classification.
+ */
+export class PiEventAccumulator {
+    content = [];
+    currentContentIndex = -1;
+    sessionId = '';
+    /**
+     * Accumulated (summed) token usage across all assistant messages in this run.
+     * pi emits per-message (non-cumulative) usage on each assistant `message_end`;
+     * summing yields the run's total consumption, aligned with ccusage (which sums
+     * per-message entries).
+     * `totalTokens` is NOT summed: it tracks the last message's total as the
+     * context-length water level (summing would overcount - design.md §usage:
+     * "N turn 累加得 N×context 虚假巨值").
+     */
+    accInput = 0;
+    accOutput = 0;
+    accCacheRead = 0;
+    accCacheCreation = 0;
+    lastTotalTokens;
+    /** stopReason of the most recent assistant message_end. "error" indicates a
+     * provider/LLM failure (pi retries internally; a later message_end may
+     * overwrite this with "stop" on eventual success). */
+    lastAssistantStopReason;
+    /** errorMessage paired with the last assistant message_end whose
+     * stopReason==="error". Surfaces the provider's failure text (e.g.
+     * "Connection error.") to the user via the result event. */
+    lastAssistantErrorMessage;
+    translate(raw) {
+        return this.normalize(raw);
+    }
+    isTerminal() {
+        // pi has no terminal event — agent_end is non-terminal (the process
+        // continues until exit). The base class's result event is the terminal.
+        return false;
+    }
+    finish(_reason) {
+        // No-op: pi has no stream-ended-early terminal error to record.
+        // The base class's signal/code-based result event handles all cases.
+    }
+    getTerminalError() {
+        // Surface provider/LLM failures reported via stopReason="error" on the
+        // final assistant message_end. pi has no other agent-reported terminal
+        // error; this lets SpawningRunner produce an error result event instead
+        // of a silent "success" with empty content.
+        // Empty-string errorMessage is treated as missing (defensive against
+        // providers that return stopReason="error" with no message) — fall back
+        // to a non-empty sentinel so the run card never shows an empty error.
+        if (this.lastAssistantStopReason === 'error') {
+            const msg = this.lastAssistantErrorMessage;
+            return msg && msg.trim() ? msg : 'pi reported an error';
+        }
+        return undefined;
+    }
+    hasAgentTerminalError() {
+        // True when the most recent assistant message_end reported stopReason
+        // "error" (provider/LLM failure). pi retries internally; if a later
+        // message_end succeeds, lastAssistantStopReason is overwritten to "stop"
+        // and this returns false — so transient retries that eventually succeed
+        // are NOT misclassified as errors.
+        return this.lastAssistantStopReason === 'error';
+    }
+    getSessionId() {
+        return this.sessionId;
+    }
+    getLastUsage() {
+        if (this.accInput === 0 &&
+            this.accOutput === 0 &&
+            this.accCacheRead === 0 &&
+            this.accCacheCreation === 0 &&
+            this.lastTotalTokens === undefined) {
+            return undefined;
+        }
+        return {
+            input_tokens: this.accInput,
+            output_tokens: this.accOutput,
+            cache_read_tokens: this.accCacheRead,
+            cache_creation_tokens: this.accCacheCreation,
+            ...(this.lastTotalTokens != null ? { total_tokens: this.lastTotalTokens } : {}),
+        };
+    }
+    /** Accumulate a per-message usage record into the run's cumulative totals. */
+    addUsage(u) {
+        this.accInput += u.input ?? 0;
+        this.accOutput += u.output ?? 0;
+        this.accCacheRead += u.cacheRead ?? 0;
+        this.accCacheCreation += u.cacheWrite ?? 0;
+        if (u.totalTokens != null) {
+            this.lastTotalTokens = u.totalTokens;
+        }
+    }
+    normalize(raw) {
+        switch (raw.type) {
+            case 'session': {
+                const s = raw;
+                this.sessionId = s.id;
+                return {
+                    type: 'system',
+                    subtype: 'init',
+                    session_id: s.id,
+                    cwd: s.cwd,
+                    model: s.model ?? '',
+                    timestamp: new Date().toISOString(),
+                };
+            }
+            case 'message_start': {
+                const m = raw.message;
+                if (m.role === 'assistant') {
+                    // Initialize accumulator for new assistant message
+                    this.content = [];
+                    this.currentContentIndex = -1;
+                }
+                return null;
+            }
+            case 'message_update': {
+                const evt = raw.assistantMessageEvent;
+                this.applyUpdate(evt);
+                return null;
+            }
+            case 'message_end': {
+                const m = raw.message;
+                if (m.role === 'assistant') {
+                    // Record provider/LLM failure signal: pi emits stopReason="error"
+                    // with an errorMessage on transient provider outages. A subsequent
+                    // successful message_end (stopReason="stop" after internal retry)
+                    // overwrites these, so only the final state decides terminal error.
+                    this.lastAssistantStopReason = m.stopReason;
+                    if (m.stopReason === 'error') {
+                        this.lastAssistantErrorMessage = m.errorMessage;
+                    }
+                    else {
+                        this.lastAssistantErrorMessage = undefined;
+                    }
+                    // Emit accumulated AssistantEvent
+                    const event = {
+                        type: 'assistant',
+                        message: { content: this.content },
+                        timestamp: new Date().toISOString(),
+                    };
+                    this.content = [];
+                    this.currentContentIndex = -1;
+                    // Accumulate per-message usage (ccusage-aligned: input is non-cached).
+                    if (m.usage) {
+                        this.addUsage(m.usage);
+                    }
+                    return event;
+                }
+                if (m.role === 'toolResult') {
+                    // Emit UserEvent with tool_result content
+                    const toolResultContent = this.normalizeToolResult(m);
+                    const event = {
+                        type: 'user',
+                        message: { content: [toolResultContent] },
+                        timestamp: new Date().toISOString(),
+                    };
+                    return event;
+                }
+                return null;
+            }
+            case 'turn_end': {
+                // pi 0.80+ `message_end` always carries usage; `turn_end` is a no-op.
+                return null;
+            }
+            case 'agent_end': {
+                // P2#6: do NOT emit result here — base class emits after exit-code check.
+                return null;
+            }
+            default:
+                // Ignore unknown event types (agent_start, turn_start, tool_execution_*, etc.)
+                return null;
+        }
+    }
+    applyUpdate(evt) {
+        switch (evt.type) {
+            case 'text_start':
+                this.content.push({ type: 'text', text: '' });
+                this.currentContentIndex++;
+                break;
+            case 'text_delta':
+                if (this.currentContentIndex >= 0 &&
+                    this.content[this.currentContentIndex]?.type === 'text') {
+                    this.content[this.currentContentIndex].text += evt.delta ?? '';
+                }
+                break;
+            case 'text_end':
+                if (this.currentContentIndex >= 0 &&
+                    this.content[this.currentContentIndex]?.type === 'text' &&
+                    evt.content) {
+                    this.content[this.currentContentIndex].text = evt.content;
+                }
+                break;
+            case 'thinking_start':
+                this.content.push({ type: 'thinking', thinking: '' });
+                this.currentContentIndex++;
+                break;
+            case 'thinking_delta':
+                if (this.currentContentIndex >= 0 &&
+                    this.content[this.currentContentIndex]?.type === 'thinking') {
+                    this.content[this.currentContentIndex].thinking +=
+                        evt.delta ?? '';
+                }
+                break;
+            case 'thinking_end':
+                if (this.currentContentIndex >= 0 &&
+                    this.content[this.currentContentIndex]?.type === 'thinking' &&
+                    evt.content) {
+                    this.content[this.currentContentIndex].thinking = evt.content;
+                }
+                break;
+            case 'toolcall_start':
+                this.content.push({ type: 'tool_use', id: '', name: '', input: {} });
+                this.currentContentIndex++;
+                break;
+            case 'toolcall_end':
+                if (this.currentContentIndex >= 0 &&
+                    this.content[this.currentContentIndex]?.type === 'tool_use' &&
+                    evt.toolCall) {
+                    this.content[this.currentContentIndex] = {
+                        type: 'tool_use',
+                        id: evt.toolCall.id,
+                        name: evt.toolCall.name,
+                        input: evt.toolCall.arguments,
+                    };
+                }
+                break;
+            default:
+                // toolcall_delta: pi provides complete arguments at toolcall_end, ignore delta
+                break;
+        }
+    }
+    normalizeToolResult(msg) {
+        return {
+            type: 'tool_result',
+            tool_use_id: msg.toolCallId ?? '',
+            content: msg.content ?? '',
+            is_error: msg.isError ?? false,
+        };
+    }
+}
+//# sourceMappingURL=jsonl.js.map

package/dist/runner/pi/runner.d.ts

@@ -0,0 +1,37 @@
+import type { AgentRunner, AgentSessionReader, SpawnOptions, AgentStatusInfo } from '../types.js';
+import { SpawningRunner, type RunnerTranslator } from '../common/spawning-runner.js';
+interface PiRunnerConfig {
+    binary?: string;
+    provider?: string;
+    model?: string;
+    thinking?: string;
+    tools?: string[];
+    stopGraceMs?: number;
+    pidDir?: string;
+    workspace: string;
+    spawnHeartbeatMs?: number;
+    sessionReader?: AgentSessionReader;
+}
+/**
+ * PiRunner: spawn-per-message runner using `pi --mode json -p <prompt> ...`.
+ *
+ * Inherits the spawn + completion + cleanup orchestration from SpawningRunner.
+ * This subclass overrides only the createTranslator()
+ * hook to return a PiEventAccumulator (which implements RunnerTranslator).
+ * Pi uses the default JSONL stream reader (createJSONLStream) and the default
+ * stdio ['ignore','pipe','pipe'] — no stdin writing, no env sync.
+ */
+export declare class PiRunner extends SpawningRunner implements AgentRunner {
+    readonly kind: "pi";
+    readonly sessionReader: AgentSessionReader;
+    private provider;
+    private defaultModel;
+    private thinking;
+    private tools;
+    constructor(opts: PiRunnerConfig);
+    get pid(): number | undefined;
+    getStatusInfo(): AgentStatusInfo;
+    protected buildArgv(opts: SpawnOptions): string[];
+    protected createTranslator(_opts: SpawnOptions): RunnerTranslator;
+}
+export {};

package/dist/runner/pi/runner.js

@@ -0,0 +1,76 @@
+import { SpawningRunner } from '../common/spawning-runner.js';
+import { PiEventAccumulator } from './jsonl.js';
+/**
+ * PiRunner: spawn-per-message runner using `pi --mode json -p <prompt> ...`.
+ *
+ * Inherits the spawn + completion + cleanup orchestration from SpawningRunner.
+ * This subclass overrides only the createTranslator()
+ * hook to return a PiEventAccumulator (which implements RunnerTranslator).
+ * Pi uses the default JSONL stream reader (createJSONLStream) and the default
+ * stdio ['ignore','pipe','pipe'] — no stdin writing, no env sync.
+ */
+export class PiRunner extends SpawningRunner {
+    kind = 'pi';
+    sessionReader;
+    provider;
+    defaultModel;
+    thinking;
+    tools;
+    constructor(opts) {
+        super({
+            binary: opts.binary ?? 'pi',
+            pidDir: opts.pidDir,
+            workspace: opts.workspace,
+            stopGraceMs: opts.stopGraceMs,
+            spawnHeartbeatMs: opts.spawnHeartbeatMs,
+            pidFilePrefix: 'pi',
+            logTag: 'pi-runner',
+        });
+        this.provider = opts.provider ?? 'Volcano';
+        this.defaultModel = opts.model ?? 'glm-5.2';
+        this.thinking = opts.thinking ?? 'medium';
+        this.tools = opts.tools ?? ['read', 'bash', 'edit', 'write', 'grep', 'find', 'ls'];
+        this.sessionReader = opts.sessionReader ?? {
+            listSessions: () => ({ sessions: [], total: 0 }),
+            getNewestSession: () => null,
+            readSessionContent: () => ({ events: [] }),
+            isSessionActive: () => false,
+        };
+    }
+    get pid() {
+        return this.currentProcess?.pid;
+    }
+    getStatusInfo() {
+        return {
+            kind: 'pi',
+            model: this.defaultModel,
+            provider: this.provider,
+            reasoning: this.thinking,
+        };
+    }
+    buildArgv(opts) {
+        const args = [
+            '--mode',
+            'json',
+            '-p',
+            this.currentMessage,
+            '--provider',
+            this.provider,
+            '--model',
+            opts.model ?? this.defaultModel,
+            '--tools',
+            this.tools.join(','),
+        ];
+        if (opts.sessionId)
+            args.push('--session-id', opts.sessionId);
+        if (this.thinking && this.thinking !== 'off')
+            args.push('--thinking', this.thinking);
+        return args;
+    }
+    // --- Hooks ---
+    createTranslator(_opts) {
+        // Fresh accumulator per run (stateful: content buffer, sessionId, lastUsage).
+        return new PiEventAccumulator();
+    }
+}
+//# sourceMappingURL=runner.js.map

package/dist/runner/registry.d.ts

@@ -0,0 +1,54 @@
+import type { AgentKind, AgentRunner } from './index.js';
+/**
+ * Registry of agent factories, keyed by `AgentKind`. `index.ts` registers one
+ * factory per available agent at startup; `Bridge.getRunner(workspace)` looks
+ * up `config.defaultAgent` here to pick the concrete runner.
+ *
+ * Singleton caching: the factory MAY cache its instance internally. All
+ * current agents (claude, codex, opencode, pi, kimi) are spawn-per-message,
+ * so per-workspace instantiation has no cost; each factory returns a fresh
+ * runner per call.
+ *
+ * Dynamic config reload: factory can read latest config via registry's
+ * configContainer, enabling runtime config changes to take effect.
+ */
+export declare class AgentRegistry {
+    private readonly factories;
+    private readonly displayNames;
+    /** Container for runtime config updates (pi provider dynamic reload). */
+    private configContainer?;
+    register(kind: AgentKind, factory: (workspace: string) => AgentRunner): void;
+    /**
+     * 注册 agent 的显示名。应在 register(kind, factory) 后调用。
+     * 用于 agentDisplayName 等全局查询，实现单点真相。
+     */
+    registerDisplayName(kind: AgentKind, displayName: string): void;
+    /**
+     * 获取 agent 显示名。未注册时返回原始 kind。
+     */
+    getDisplayName(kind: AgentKind): string;
+    /**
+     * 设置全局 registry 实例，供 agentDisplayName 等全局函数使用。
+     * 在 index.ts 初始化所有 agents 后调用。
+     */
+    static setGlobalInstance(reg: AgentRegistry): void;
+    /**
+     * 获取全局 registry 实例。
+     */
+    static getGlobalInstance(): AgentRegistry | undefined;
+    /**
+     * Set config container reference. Call after bridge config is updated.
+     * Factory functions can read latest config from here.
+     */
+    setConfigContainer(container: {
+        current: unknown;
+    }): void;
+    /**
+     * Get the config container for factory functions to read latest config.
+     * Returns undefined if not set.
+     */
+    getConfigContainer(): {
+        current: unknown;
+    } | undefined;
+    get(kind: AgentKind, workspace: string): AgentRunner;
+}

package/dist/runner/registry.js

@@ -0,0 +1,75 @@
+/**
+ * 单例 registry 实例，供 agentDisplayName 等全局查询使用。
+ * 在 index.ts 初始化后设置。
+ */
+let globalRegistry;
+/**
+ * Registry of agent factories, keyed by `AgentKind`. `index.ts` registers one
+ * factory per available agent at startup; `Bridge.getRunner(workspace)` looks
+ * up `config.defaultAgent` here to pick the concrete runner.
+ *
+ * Singleton caching: the factory MAY cache its instance internally. All
+ * current agents (claude, codex, opencode, pi, kimi) are spawn-per-message,
+ * so per-workspace instantiation has no cost; each factory returns a fresh
+ * runner per call.
+ *
+ * Dynamic config reload: factory can read latest config via registry's
+ * configContainer, enabling runtime config changes to take effect.
+ */
+export class AgentRegistry {
+    factories = new Map();
+    displayNames = new Map();
+    /** Container for runtime config updates (pi provider dynamic reload). */
+    configContainer;
+    register(kind, factory) {
+        this.factories.set(kind, factory);
+    }
+    /**
+     * 注册 agent 的显示名。应在 register(kind, factory) 后调用。
+     * 用于 agentDisplayName 等全局查询，实现单点真相。
+     */
+    registerDisplayName(kind, displayName) {
+        this.displayNames.set(kind, displayName);
+    }
+    /**
+     * 获取 agent 显示名。未注册时返回原始 kind。
+     */
+    getDisplayName(kind) {
+        return this.displayNames.get(kind) ?? kind;
+    }
+    /**
+     * 设置全局 registry 实例，供 agentDisplayName 等全局函数使用。
+     * 在 index.ts 初始化所有 agents 后调用。
+     */
+    static setGlobalInstance(reg) {
+        globalRegistry = reg;
+    }
+    /**
+     * 获取全局 registry 实例。
+     */
+    static getGlobalInstance() {
+        return globalRegistry;
+    }
+    /**
+     * Set config container reference. Call after bridge config is updated.
+     * Factory functions can read latest config from here.
+     */
+    setConfigContainer(container) {
+        this.configContainer = container;
+    }
+    /**
+     * Get the config container for factory functions to read latest config.
+     * Returns undefined if not set.
+     */
+    getConfigContainer() {
+        return this.configContainer;
+    }
+    get(kind, workspace) {
+        const factory = this.factories.get(kind);
+        if (!factory) {
+            throw new Error(`agent not registered: ${kind}`);
+        }
+        return factory(workspace);
+    }
+}
+//# sourceMappingURL=registry.js.map

package/dist/runner/resolve-agent-choices.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Resolve agentChoices into agents config.
+ * Priority: explicit agents config > agentChoices > defaults
+ * This is called at startup to restore the last used configuration for the current agent.
+ */
+import type { AppConfig } from '../config/index.js';
+export declare function resolveAgentChoices(config: AppConfig): AppConfig;

package/dist/runner/resolve-agent-choices.js

@@ -0,0 +1,76 @@
+export function resolveAgentChoices(config) {
+    const choices = config.agentChoices;
+    const agent = config.defaultAgent;
+    if (!choices || !agent) {
+        return config;
+    }
+    // Skip claude - it's stored at top-level config.claude, not in agentChoices
+    if (agent === 'claude') {
+        return config;
+    }
+    const agentChoices = choices[agent];
+    if (!agentChoices) {
+        return config;
+    }
+    // Clone to avoid mutation
+    const resolved = JSON.parse(JSON.stringify(config));
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const resolvedAny = resolved;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const agentChoicesAny = agentChoices;
+    switch (agent) {
+        case 'codex':
+            if (!resolvedAny.agents)
+                resolvedAny.agents = {};
+            if (!resolvedAny.agents.codex)
+                resolvedAny.agents.codex = {};
+            if (!resolvedAny.agents.codex.model && agentChoicesAny.model) {
+                resolvedAny.agents.codex.model = agentChoicesAny.model;
+            }
+            if (!resolvedAny.agents.codex.modelProvider && agentChoicesAny.modelProvider) {
+                resolvedAny.agents.codex.modelProvider = agentChoicesAny.modelProvider;
+            }
+            break;
+        case 'pi':
+            if (!resolvedAny.agents)
+                resolvedAny.agents = {};
+            if (!resolvedAny.agents.pi)
+                resolvedAny.agents.pi = {};
+            if (!resolvedAny.agents.pi.model && agentChoicesAny.model) {
+                resolvedAny.agents.pi.model = agentChoicesAny.model;
+            }
+            if (!resolvedAny.agents.pi.provider && agentChoicesAny.provider) {
+                resolvedAny.agents.pi.provider = agentChoicesAny.provider;
+            }
+            if (!resolvedAny.agents.pi.thinking && agentChoicesAny.thinking) {
+                resolvedAny.agents.pi.thinking = agentChoicesAny.thinking;
+            }
+            break;
+        case 'opencode':
+            if (!resolvedAny.agents)
+                resolvedAny.agents = {};
+            if (!resolvedAny.agents.opencode)
+                resolvedAny.agents.opencode = {};
+            if (!resolvedAny.agents.opencode.modelID && agentChoicesAny.modelID) {
+                resolvedAny.agents.opencode.modelID = agentChoicesAny.modelID;
+            }
+            if (!resolvedAny.agents.opencode.providerID && agentChoicesAny.providerID) {
+                resolvedAny.agents.opencode.providerID = agentChoicesAny.providerID;
+            }
+            break;
+        case 'kimi':
+            if (!resolvedAny.agents)
+                resolvedAny.agents = {};
+            if (!resolvedAny.agents.kimi)
+                resolvedAny.agents.kimi = {};
+            if (!resolvedAny.agents.kimi.model && agentChoicesAny.model) {
+                resolvedAny.agents.kimi.model = agentChoicesAny.model;
+            }
+            if (!resolvedAny.agents.kimi.thinkingEffort && agentChoicesAny.thinkingEffort) {
+                resolvedAny.agents.kimi.thinkingEffort = agentChoicesAny.thinkingEffort;
+            }
+            break;
+    }
+    return resolved;
+}
+//# sourceMappingURL=resolve-agent-choices.js.map

package/dist/runner/sync-agent-choices.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Sync agent configuration to agentChoices.
+ * Called when user saves config to remember their choices for quick switching.
+ */
+import type { AppConfig } from '../config/index.js';
+export declare function syncAgentChoices(config: AppConfig, agent: string): AppConfig;

package/dist/runner/sync-agent-choices.js

@@ -0,0 +1,73 @@
+export function syncAgentChoices(config, agent) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const configAny = config;
+    const agents = configAny.agents || {};
+    const agentCfg = agents[agent];
+    // claude reads from top-level config.claude, not agents.claude
+    if (agent !== 'claude' && !agentCfg) {
+        return config;
+    }
+    const updated = JSON.parse(JSON.stringify(config));
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const updatedAny = updated;
+    if (!updatedAny.agentChoices) {
+        updatedAny.agentChoices = {};
+    }
+    switch (agent) {
+        case 'codex':
+            if (agentCfg.model) {
+                if (!updatedAny.agentChoices.codex)
+                    updatedAny.agentChoices.codex = {};
+                updatedAny.agentChoices.codex.model = agentCfg.model;
+            }
+            if (agentCfg.modelProvider) {
+                if (!updatedAny.agentChoices.codex)
+                    updatedAny.agentChoices.codex = {};
+                updatedAny.agentChoices.codex.modelProvider = agentCfg.modelProvider;
+            }
+            break;
+        case 'pi':
+            if (agentCfg.model) {
+                if (!updatedAny.agentChoices.pi)
+                    updatedAny.agentChoices.pi = {};
+                updatedAny.agentChoices.pi.model = agentCfg.model;
+            }
+            if (agentCfg.provider) {
+                if (!updatedAny.agentChoices.pi)
+                    updatedAny.agentChoices.pi = {};
+                updatedAny.agentChoices.pi.provider = agentCfg.provider;
+            }
+            if (agentCfg.thinking) {
+                if (!updatedAny.agentChoices.pi)
+                    updatedAny.agentChoices.pi = {};
+                updatedAny.agentChoices.pi.thinking = agentCfg.thinking;
+            }
+            break;
+        case 'opencode':
+            if (agentCfg.modelID) {
+                if (!updatedAny.agentChoices.opencode)
+                    updatedAny.agentChoices.opencode = {};
+                updatedAny.agentChoices.opencode.modelID = agentCfg.modelID;
+            }
+            if (agentCfg.providerID) {
+                if (!updatedAny.agentChoices.opencode)
+                    updatedAny.agentChoices.opencode = {};
+                updatedAny.agentChoices.opencode.providerID = agentCfg.providerID;
+            }
+            break;
+        case 'kimi':
+            if (agentCfg.model) {
+                if (!updatedAny.agentChoices.kimi)
+                    updatedAny.agentChoices.kimi = {};
+                updatedAny.agentChoices.kimi.model = agentCfg.model;
+            }
+            if (agentCfg.thinkingEffort) {
+                if (!updatedAny.agentChoices.kimi)
+                    updatedAny.agentChoices.kimi = {};
+                updatedAny.agentChoices.kimi.thinkingEffort = agentCfg.thinkingEffort;
+            }
+            break;
+    }
+    return updated;
+}
+//# sourceMappingURL=sync-agent-choices.js.map