linkshell-cli 0.3.14 → 0.3.16

package/dist/cli/src/runtime/acp/agent-workspace.d.ts

@@ -3,8 +3,11 @@ import type { AgentProvider } from "./provider-resolver.js";
 export declare class AgentWorkspaceProxy {
     private readonly input;
     private clients;
+    private codexRpcBridge;
     private agentProtocols;
     private providerCapabilities;
+    private providerCapabilityErrors;
+    private capabilitiesRevision;
     private initialized;
     private status;
     private error;
@@ -35,6 +38,7 @@ export declare class AgentWorkspaceProxy {
     handleEnvelope(envelope: Envelope): Promise<void>;
     stop(): void;
     private clientForProvider;
+    private codexRpc;
     private protocolForProvider;
     private initialize;
     private ensureProviderClient;

package/dist/cli/src/runtime/acp/agent-workspace.js

@@ -6,8 +6,9 @@ import { createEnvelope, parseTypedPayload, } from "@linkshell/protocol";
 import { AcpClient } from "./acp-client.js";
 import { ClaudeSdkClient } from "./claude-sdk-client.js";
 import { ClaudeStreamJsonClient } from "./claude-stream-json-client.js";
+import { CodexRpcBridge } from "./codex-rpc-bridge.js";
 import { listClaudeStoredSessions, loadClaudeStoredTimeline } from "./claude-sessions.js";
-import { listCodexStoredSessions, loadCodexStoredTimeline } from "./codex-sessions.js";
+import { loadCodexStoredTimeline } from "./codex-sessions.js";
 import { resolveAgentCommand } from "./provider-resolver.js";
 const PERMISSION_TIMEOUT_MS = 5 * 60_000;
 const MAX_TIMELINE_ITEMS = 200;
@@ -1176,8 +1177,11 @@ function normalizeAgentStatus(value) {
 export class AgentWorkspaceProxy {
     input;
     clients = new Map();
+    codexRpcBridge;
     agentProtocols = new Map();
     providerCapabilities = new Map();
+    providerCapabilityErrors = new Map();
+    capabilitiesRevision = 0;
     initialized = false;
     status = "unavailable";
     error;
@@ -1202,6 +1206,32 @@ export class AgentWorkspaceProxy {
     }
     async handleEnvelope(envelope) {
         switch (envelope.type) {
+            case "agent.codex.rpc": {
+                const payload = parseTypedPayload("agent.codex.rpc", envelope.payload);
+                try {
+                    this.codexRpc().send(payload);
+                }
+                catch (error) {
+                    const idValue = payload && typeof payload === "object" && "id" in payload
+                        ? payload.id
+                        : undefined;
+                    if (typeof idValue === "string" || typeof idValue === "number") {
+                        this.input.send(createEnvelope({
+                            type: "agent.codex.rpc",
+                            hostDeviceId: this.input.hostDeviceId,
+                            payload: {
+                                jsonrpc: "2.0",
+                                id: idValue,
+                                error: {
+                                    code: -32000,
+                                    message: error instanceof Error ? error.message : String(error),
+                                },
+                            },
+                        }));
+                    }
+                }
+                break;
+            }
             case "agent.v2.capabilities.request":
                 await this.initialize();
                 this.sendCapabilities();
@@ -1274,6 +1304,8 @@ export class AgentWorkspaceProxy {
         }
     }
     stop() {
+        this.codexRpcBridge?.stop();
+        this.codexRpcBridge = undefined;
         for (const client of this.clients.values()) {
             client.stop();
         }
@@ -1282,6 +1314,16 @@ export class AgentWorkspaceProxy {
     clientForProvider(provider) {
         return this.clients.get(provider);
     }
+    codexRpc() {
+        this.codexRpcBridge ??= new CodexRpcBridge({
+            command: this.input.command,
+            cwd: this.input.cwd,
+            hostDeviceId: this.input.hostDeviceId,
+            send: this.input.send,
+            verbose: this.input.verbose,
+        });
+        return this.codexRpcBridge;
+    }
     protocolForProvider(provider) {
         return this.agentProtocols.get(provider);
     }
@@ -1290,7 +1332,9 @@ export class AgentWorkspaceProxy {
             return;
         this.initialized = true;
         // Eagerly start all detected providers so capabilities report real status
-        const startPromises = this.input.availableProviders.map((p) => this.ensureProviderClient(p));
+        const startPromises = this.input.availableProviders
+            .filter((provider) => provider !== "codex")
+            .map((p) => this.ensureProviderClient(p));
         await Promise.allSettled(startPromises);
         this.status = "idle";
         this.error = undefined;
@@ -1396,10 +1440,13 @@ export class AgentWorkspaceProxy {
         try {
             const result = await listModels.call(client);
             const runtimeCapabilities = parseModelListCapabilities(result);
-            if (runtimeCapabilities)
+            if (runtimeCapabilities) {
                 this.providerCapabilities.set(provider, runtimeCapabilities);
+                this.providerCapabilityErrors.delete(provider);
+            }
         }
         catch (error) {
+            this.providerCapabilityErrors.set(provider, error instanceof Error ? error.message : String(error));
             if (this.input.verbose) {
                 process.stderr.write(`[agent:v2] model/list failed for ${provider}: ${error instanceof Error ? error.message : String(error)}\n`);
             }
@@ -1407,7 +1454,6 @@ export class AgentWorkspaceProxy {
     }
     async syncProviderSessions() {
         await this.initialize();
-        this.upsertProviderSessions("codex", listCodexStoredSessions(this.input.cwd));
         this.upsertProviderSessions("claude", listClaudeStoredSessions(this.input.cwd));
         for (const [provider, client] of this.clients) {
             try {
@@ -1460,12 +1506,14 @@ export class AgentWorkspaceProxy {
     sendCapabilities() {
         const providers = this.input.availableProviders.map((provider) => {
             const client = this.clients.get(provider);
-            const protocol = this.agentProtocols.get(provider);
+            const protocol = provider === "codex" ? "codex-app-server" : this.agentProtocols.get(provider);
             const runtimeCapabilities = this.providerCapabilities.get(provider);
-            const enabled = Boolean(client);
+            const enabled = provider === "codex" ? true : Boolean(client);
+            const hasRuntimeModels = Boolean(runtimeCapabilities?.models?.length);
             const supportsImages = enabled && protocolSupportsImages(protocol);
+            const isClaudeSdk = protocol === "claude-agent-sdk";
             const isClaudeFallback = protocol === "claude-stream-json";
-            const supportsPermission = enabled && !isClaudeFallback;
+            const supportsPermission = enabled && (isClaudeSdk || !isClaudeFallback);
             const supportsReasoningEffort = enabled;
             const commands = mergeCommands(defaultProviderCommands(provider, this.input.cwd, enabled), runtimeCapabilities?.commands);
             const currentMode = [...this.conversations.values()].find((conversation) => conversation.provider === provider)?.collaborationMode;
@@ -1474,12 +1522,15 @@ export class AgentWorkspaceProxy {
                 label: providerLabel(provider),
                 enabled,
                 reason: enabled ? undefined : `${providerLabel(provider)} 未安装或启动失败`,
+                providerProtocol: protocol,
                 supportsImages,
                 supportsPermission,
                 supportsPlan: enabled,
                 supportsCancel: enabled,
                 models: runtimeCapabilities?.models ?? [{ id: "default", label: "默认模型" }],
                 defaultModel: runtimeCapabilities?.defaultModel,
+                modelsSource: hasRuntimeModels ? "runtime" : enabled ? "fallback" : "unavailable",
+                modelListError: this.providerCapabilityErrors.get(provider),
                 reasoningEfforts: supportsReasoningEffort
                     ? runtimeCapabilities?.reasoningEfforts ?? (provider === "claude" ? [...CLAUDE_REASONING_EFFORTS] : [...ALL_REASONING_EFFORTS])
                     : [],
@@ -1493,6 +1544,7 @@ export class AgentWorkspaceProxy {
                     plan: enabled,
                     cancel: enabled,
                     reasoningEffort: supportsReasoningEffort,
+                    claudeSdk: isClaudeSdk,
                     streamJsonFallback: isClaudeFallback,
                 },
             };
@@ -1508,6 +1560,7 @@ export class AgentWorkspaceProxy {
                 providers,
                 protocolVersion: 1,
                 workspaceProtocolVersion: 2,
+                capabilitiesRevision: ++this.capabilitiesRevision,
                 error: anyEnabled ? undefined : "没有可用的 Agent provider。请安装 Claude Code 或 Codex CLI。",
                 supportsSessionList: anyEnabled,
                 supportsSessionLoad: anyEnabled,
@@ -2021,6 +2074,9 @@ export class AgentWorkspaceProxy {
                 this.conversationByAgentSessionId.set(agentSessionId, conversationId);
                 const conversation = this.conversations.get(conversationId);
                 if (conversation) {
+                    if (conversation.agentSessionId && conversation.agentSessionId !== agentSessionId) {
+                        this.conversationByAgentSessionId.delete(conversation.agentSessionId);
+                    }
                     conversation.agentSessionId = agentSessionId;
                     conversation.lastActivityAt = Date.now();
                     this.emitConversation(conversation);
@@ -2935,6 +2991,8 @@ export class AgentWorkspaceProxy {
             ...existing,
             ...toolCall,
             id: targetToolId,
+            input: toolCall.input ?? existing?.input,
+            output: toolCall.output ?? existing?.output,
             createdAt: existing?.createdAt ?? toolCall.createdAt ?? Date.now(),
         };
         this.toolConversationIds.set(toolCall.id, conversationId);