linco-connect 1.0.6 → 1.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linco-connect",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "自研 IM 桥接多 Agent 服务",
   "main": "server.js",
   "bin": {

package/src/agentRunner.js

@@ -23,8 +23,8 @@ function resolvePendingDanger(confirmed, ws, session, config) {
   return providerFor(session).resolvePendingDanger?.(confirmed, ws, session, config) || false;
 }
 
-function resolvePendingPermission(allowed, ws, session, config) {
-  return providerFor(session).resolvePendingPermission?.(allowed, ws, session, config) || false;
+function resolvePendingPermission(allowed, ws, session, config, requestId) {
+  return providerFor(session).resolvePendingPermission?.(allowed, ws, session, config, requestId) || false;
 }
 
 function stopAgentProcess(session, options = {}) {

package/src/agents/codex.js

@@ -4,6 +4,13 @@ const { send, sendError, sendSystem } = require('../protocol');
 const { persistAgentSessionId, stopAgentProcess: stopSessionProcess, updateAgentSessionHistory } = require('../session');
 const { getOutboxDir } = require('../outgoingAttachmentHandler');
 const { createTextStreamBuffer, appendTextStream, flushTextStream, resetTextStream } = require('../streamBuffer');
+const {
+  clearPendingPermissions,
+  getPendingPermission,
+  pendingPermissionIds,
+  removePendingPermission,
+  setPendingPermission,
+} = require('../permissionState');
 
 function execute(input, ws, session, config) {
   const textForCheck = stringifyInput(input);
@@ -44,6 +51,7 @@ function runAppServerTurn(input, ws, session, config) {
   session.currentInputForNoOutput = input;
   session.sawPartialAssistantText = false;
   session.codexAssistantEnded = false;
+  session.codexEmittedAgentMessageIds = new Set();
   resetCodexAssistantText(session);
   session._lastWs = ws;
   session._lastConfig = config;
@@ -165,6 +173,7 @@ function ensureAppServer(session, config) {
         session.codexAppServer = null;
       }
       clearTurnState(session);
+      clearPendingPermissions(session, 'codex');
       // drain pending requests
       for (const [, pending] of session.codexPendingRequests) {
         pending.reject(new Error(`app-server 已退出，code=${code}`));
@@ -298,6 +307,31 @@ function resetCodexAssistantText(session) {
   resetTextStream(ensureCodexStreamState(session));
 }
 
+function codexAgentMessageId(params) {
+  return String(params.item?.id || params.itemId || params.id || '').trim();
+}
+
+function markCodexAgentMessageEmitted(session, itemId) {
+  const id = String(itemId || '').trim();
+  if (!id) return;
+  if (!(session.codexEmittedAgentMessageIds instanceof Set)) {
+    session.codexEmittedAgentMessageIds = new Set();
+  }
+  session.codexEmittedAgentMessageIds.add(id);
+}
+
+function hasCodexAgentMessageEmitted(session, itemId) {
+  const id = String(itemId || '').trim();
+  return Boolean(id && session.codexEmittedAgentMessageIds?.has(id));
+}
+
+function shouldAppendCompletedAgentMessage(session, params) {
+  const itemId = codexAgentMessageId(params);
+  if (itemId) return !hasCodexAgentMessageEmitted(session, itemId);
+  if (!session.sawPartialAssistantText) return true;
+  return params.item?.phase === 'final_answer';
+}
+
 function nextRpcId(session) {
   session.codexRpcId = (session.codexRpcId || 0) + 1;
   return session.codexRpcId;
@@ -357,16 +391,16 @@ function handleServerRequest(message, session) {
     const cmd = params.command || params.tool || '';
     session._log?.info('codex command execution approval requested', { method, command: cmd });
 
-    if (session.pendingPermission?.requestId === String(message.id)) return;
+    if (getPendingPermission(session, String(message.id), 'codex')) return;
 
-    session.pendingPermission = {
+    setPendingPermission(session, {
       provider: 'codex',
       requestId: String(message.id),
       toolName: 'exec',
       input: cmd,
       _codexMethod: method,
       _rpcId: message.id,
-    };
+    });
 
     if (ws) {
       send(ws, 'permission_request', {
@@ -509,6 +543,7 @@ function handleAppServerMessage(message, session) {
     const delta = params.delta || '';
     if (delta) {
       appendCodexAssistantText(delta, ws, session, () => send(ws, 'assistant_start', {}));
+      markCodexAgentMessageEmitted(session, codexAgentMessageId(params));
     }
     return;
   }
@@ -533,10 +568,13 @@ function handleAppServerMessage(message, session) {
       return;
     }
 
-    // final content fallback if no deltas were emitted
+    // final content fallback if this item did not emit deltas
     const text = extractFinalText(params);
-    if (text && !session.sawPartialAssistantText) {
+    const agentMessageId = codexAgentMessageId(params);
+    if (text && shouldAppendCompletedAgentMessage(session, params)) {
+      if (session.sawPartialAssistantText) appendCodexAssistantText('\n\n', ws, session, () => send(ws, 'assistant_start', {}));
       appendCodexAssistantText(text, ws, session, () => send(ws, 'assistant_start', {}));
+      markCodexAgentMessageEmitted(session, agentMessageId);
     }
     // Safety fallback: if turn/completed never arrives, clear isTurnActive so the next message doesn't get stuck.
     if (session.turnCompletedTimerId) clearTimeout(session.turnCompletedTimerId);
@@ -644,13 +682,17 @@ function updateCodexSessionStats(session, params = {}) {
   updateAgentSessionHistory(session);
 }
 
+function isCodexAssistantMessageType(type) {
+  return ['agentMessage', 'agent_message', 'message'].includes(type);
+}
+
 function extractFinalText(params) {
   if (typeof params.text === 'string') return params.text;
   if (typeof params.delta === 'string') return params.delta;
   if (Array.isArray(params.content)) {
     return params.content.map(item => typeof item === 'string' ? item : item?.text || '').join('');
   }
-  if (params.item?.type === 'agent_message' && typeof params.item.text === 'string') {
+  if (isCodexAssistantMessageType(params.item?.type) && typeof params.item.text === 'string') {
     return params.item.text;
   }
   return '';
@@ -865,7 +907,7 @@ function extractText(event) {
   if (Array.isArray(event.content)) {
     return event.content.map(item => typeof item === 'string' ? item : item?.text || '').join('');
   }
-  if (typeof event.item?.text === 'string' && ['agent_message', 'message'].includes(event.item.type)) {
+  if (typeof event.item?.text === 'string' && isCodexAssistantMessageType(event.item.type)) {
     return event.item.text;
   }
   if (event.item?.type === 'message' && Array.isArray(event.item.content)) {
@@ -886,13 +928,17 @@ function resolvePendingDanger(confirmed, ws, session, config) {
   return true;
 }
 
-function resolvePendingPermission(approved, ws, session, config) {
-  if (!session.pendingPermission) return false;
-
-  const pending = session.pendingPermission;
-  if (pending.provider !== 'codex') return false;
+function resolvePendingPermission(approved, ws, session, config, requestId) {
+  const pending = getPendingPermission(session, requestId, 'codex');
+  if (!pending) {
+    session._log?.warn('codex permission response without pending request', {
+      requestId: requestId || '',
+      pendingRequestIds: pendingPermissionIds(session, 'codex'),
+    });
+    return false;
+  }
 
-  session.pendingPermission = null;
+  removePendingPermission(session, pending.requestId);
   session._log?.info('codex permission response', { approved, toolName: pending.toolName, rpcId: pending._rpcId });
 
   // Respond to Codex RPC
@@ -928,6 +974,7 @@ function stop(session, options = {}) {
   }
   stopSessionProcess(session, options);
   clearTurnState(session);
+  clearPendingPermissions(session, 'codex');
   if (session.codexPendingRequests) {
     for (const [, pending] of session.codexPendingRequests) {
       pending.reject(new Error('用户已停止'));

package/src/agents/hermes.js

@@ -4,6 +4,13 @@ const { persistAgentSessionId, stopAgentProcess: stopSessionProcess, updateAgent
 const { getOutboxDir } = require('../outgoingAttachmentHandler');
 const { createTextStreamBuffer, appendTextStream, flushTextStream, resetTextStream } = require('../streamBuffer');
 const { DEFAULT_GATEWAY_URL, ensureHermesGateway, normalizeGatewayUrl } = require('../hermesGateway');
+const {
+  clearPendingPermissions,
+  getPendingPermission,
+  pendingPermissionIds,
+  removePendingPermission,
+  setPendingPermission,
+} = require('../permissionState');
 
 function extractText(input) {
   if (!Array.isArray(input)) return String(input || '');
@@ -178,16 +185,26 @@ function handleHermesEvent(event, ws, session, config) {
 }
 
 function handleApprovalRequest(event, ws, session) {
-  const requestId = `hermes-${event.run_id || session.hermesRunId}-${Date.now()}`;
+  const requestId = String(
+    event.requestId ||
+    event.request_id ||
+    event.approvalId ||
+    event.approval_id ||
+    event.id ||
+    `hermes-${event.run_id || session.hermesRunId}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
+  );
   const input = event.command || event.description || event.preview || '';
-  session.pendingPermission = {
+
+  if (getPendingPermission(session, requestId, 'hermes')) return;
+
+  setPendingPermission(session, {
     provider: 'hermes',
     requestId,
     runId: event.run_id || session.hermesRunId,
     toolName: 'exec',
     input,
     choices: event.choices || [],
-  };
+  });
   send(ws, 'permission_request', {
     requestId,
     toolName: 'exec',
@@ -222,7 +239,7 @@ function finishTurn(ws, session, config, options = {}) {
   session.hermesGatewayUrl = null;
   session.isTurnActive = false;
   session.currentInputForNoOutput = null;
-  session.pendingPermission = null;
+  clearPendingPermissions(session, 'hermes');
   flushHermesAssistantText(ws, session);
   resetHermesAssistantText(session);
   if (drain) drainQueue(ws, session, config);
@@ -358,14 +375,21 @@ async function resolvePendingDanger(confirmed, ws, session, config) {
   return true;
 }
 
-async function resolvePendingPermission(approved, ws, session, config) {
-  const pending = session.pendingPermission;
-  if (!pending || pending.provider !== 'hermes') return false;
+async function resolvePendingPermission(approved, ws, session, config, requestId) {
+  const pending = getPendingPermission(session, requestId, 'hermes');
+  if (!pending) {
+    config.logger?.warn('hermes permission response without pending request', {
+      sessionId: session.id,
+      requestId: requestId || '',
+      pendingRequestIds: pendingPermissionIds(session, 'hermes'),
+    });
+    return false;
+  }
 
   const agentConfig = config.agents?.hermes || {};
   const gatewayUrl = session.hermesGatewayUrl || normalizeGatewayUrl(agentConfig.gatewayUrl || agentConfig.baseUrl || DEFAULT_GATEWAY_URL);
   const runId = pending.runId || session.hermesRunId;
-  session.pendingPermission = null;
+  removePendingPermission(session, pending.requestId);
 
   try {
     await fetchJson(`${gatewayUrl}/v1/runs/${encodeURIComponent(runId)}/approval`, agentConfig, {

package/src/claudeRunner.js

@@ -6,6 +6,13 @@ const { buildOutboxSystemPrompt, getOutboxDir } = require('./outgoingAttachmentH
 const { send, sendError, sendSystem } = require('./protocol');
 const { appendTextStream, flushTextStream, resetTextStream } = require('./streamBuffer');
 const { persistClaudeSessionId, stopAgentProcess, updateAgentSessionHistory } = require('./session');
+const {
+  getPendingPermission,
+  hasPendingPermissions,
+  pendingPermissionIds,
+  removePendingPermission,
+  setPendingPermission,
+} = require('./permissionState');
 
 function executeClaudeQuery(input, ws, session, config) {
   const textForCheck = typeof input === 'string' ? input : extractText(input);
@@ -319,9 +326,7 @@ function handleClaudeMessage(parsed, ws, session, config) {
       handleControlRequest(parsed, ws, session, config);
       break;
     case 'control_cancel_request':
-      if (session.pendingPermission?.requestId === parsed.request_id) {
-        session.pendingPermission = null;
-      }
+      removePendingPermission(session, parsed.request_id);
       break;
   }
 }
@@ -423,11 +428,22 @@ function handleControlRequest(parsed, ws, session, config) {
   const input = sanitizeToolInput(toolName, request.input || {});
   const inputText = summarizeInput(input);
 
-  session.pendingPermission = {
+  if (requestID && getPendingPermission(session, requestID, 'claude')) {
+    config.logger?.info('duplicate permission request ignored', {
+      sessionId: session.id,
+      requestId: requestID,
+      toolName,
+    });
+    return;
+  }
+
+  const pending = {
+    provider: 'claude',
     requestId: requestID,
     toolName,
     input,
   };
+  setPendingPermission(session, pending);
 
   config.logger?.info('permission request received', {
     sessionId: session.id,
@@ -442,8 +458,8 @@ function handleControlRequest(parsed, ws, session, config) {
   });
 }
 
-function respondPermission(session, approved) {
-  const pending = session.pendingPermission;
+function respondPermission(session, approved, requestId) {
+  const pending = getPendingPermission(session, requestId, 'claude');
   if (!pending) return false;
 
   const response = approved
@@ -458,16 +474,23 @@ function respondPermission(session, approved) {
       response,
     },
   });
-  session.pendingPermission = null;
+  removePendingPermission(session, pending.requestId);
   return true;
 }
 
-function resolvePendingPermission(approved, ws, session, config) {
-  if (!session.pendingPermission) return false;
+function resolvePendingPermission(approved, ws, session, config, requestId) {
+  const pending = getPendingPermission(session, requestId, 'claude');
+  if (!pending) {
+    config.logger?.warn('permission response without pending request', {
+      sessionId: session.id,
+      requestId: requestId || '',
+      pendingRequestIds: pendingPermissionIds(session, 'claude'),
+    });
+    return false;
+  }
 
   try {
-    const pending = session.pendingPermission;
-    respondPermission(session, approved);
+    respondPermission(session, approved, pending.requestId);
     config.logger?.info('permission response sent', {
       sessionId: session.id,
       requestId: pending?.requestId,
@@ -499,7 +522,7 @@ function resolvePendingDanger(approved, ws, session, config) {
 }
 
 function drainMessageQueue(ws, session, config) {
-  if (session.isTurnActive || session.pendingPermission) return;
+  if (session.isTurnActive || hasPendingPermissions(session, 'claude')) return;
   const next = session.messageQueue.shift();
   if (!next) return;
   config.logger?.info('message dequeued', { sessionId: session.id, queueLength: session.messageQueue.length });

package/src/imConnector.js

@@ -222,7 +222,7 @@ class ImConnector {
       return;
     }
 
-    if (!resolvePendingPermission(!!msg.approved, session.ws, session, this.config)) {
+    if (!resolvePendingPermission(!!msg.approved, session.ws, session, this.config, msg.requestId)) {
       sendError(session.ws, '没有待确认的工具权限请求');
     }
   }

package/src/permissionState.js

@@ -0,0 +1,83 @@
+function ensurePendingPermissionMap(session) {
+  if (session.pendingPermissions instanceof Map) return session.pendingPermissions;
+
+  const map = new Map();
+  if (session.pendingPermission?.requestId) {
+    map.set(String(session.pendingPermission.requestId), session.pendingPermission);
+  }
+  session.pendingPermissions = map;
+  return map;
+}
+
+function setPendingPermission(session, pending) {
+  if (!pending?.requestId) return;
+  const map = ensurePendingPermissionMap(session);
+  map.set(String(pending.requestId), pending);
+  syncLegacyPendingPermission(session);
+}
+
+function getPendingPermission(session, requestId, provider) {
+  const map = ensurePendingPermissionMap(session);
+  const normalized = String(requestId || '').trim();
+
+  if (normalized) {
+    const pending = map.get(normalized) || null;
+    return matchesProvider(pending, provider) ? pending : null;
+  }
+
+  const matching = Array.from(map.values()).filter(pending => matchesProvider(pending, provider));
+  return matching.length === 1 ? matching[0] : null;
+}
+
+function removePendingPermission(session, requestId) {
+  const map = ensurePendingPermissionMap(session);
+  const normalized = String(requestId || '').trim();
+  if (normalized) map.delete(normalized);
+  syncLegacyPendingPermission(session);
+}
+
+function clearPendingPermissions(session, provider) {
+  const map = ensurePendingPermissionMap(session);
+  if (!provider) {
+    map.clear();
+    syncLegacyPendingPermission(session);
+    return;
+  }
+
+  for (const [requestId, pending] of map) {
+    if (matchesProvider(pending, provider)) map.delete(requestId);
+  }
+  syncLegacyPendingPermission(session);
+}
+
+function hasPendingPermissions(session, provider) {
+  const map = ensurePendingPermissionMap(session);
+  if (!provider) return map.size > 0;
+  return Array.from(map.values()).some(pending => matchesProvider(pending, provider));
+}
+
+function pendingPermissionIds(session, provider) {
+  return Array.from(ensurePendingPermissionMap(session).values())
+    .filter(pending => matchesProvider(pending, provider))
+    .map(pending => String(pending.requestId));
+}
+
+function matchesProvider(pending, provider) {
+  if (!pending) return false;
+  return !provider || pending.provider === provider;
+}
+
+function syncLegacyPendingPermission(session) {
+  const remaining = Array.from(ensurePendingPermissionMap(session).values());
+  session.pendingPermission = remaining.length ? remaining[remaining.length - 1] : null;
+}
+
+module.exports = {
+  clearPendingPermissions,
+  ensurePendingPermissionMap,
+  getPendingPermission,
+  hasPendingPermissions,
+  pendingPermissionIds,
+  removePendingPermission,
+  setPendingPermission,
+};

package/src/session.js

@@ -61,6 +61,7 @@ function createSession(config, { externalSessionId, agentType = 'claude' } = {})
     messageQueue: [],
     pendingDanger: null,
     pendingPermission: null,
+    pendingPermissions: new Map(),
     streamState: createStreamState(),
     sawPartialAssistantText: false,
     outgoingAttachments: new Map(),
@@ -294,6 +295,8 @@ function resetConversationState(session, { clearAgentSession = true, clearClaude
   session.messageQueue = [];
   session.pendingDanger = null;
   session.pendingPermission = null;
+  if (session.pendingPermissions?.clear) session.pendingPermissions.clear();
+  else session.pendingPermissions = new Map();
   session.sawPartialAssistantText = false;
   clearStreamState(session);
 }

package/src/slashCommands.js

@@ -4,6 +4,7 @@ const { resetOutgoingAttachments, startOutboxWatcher, stopOutboxWatcher } = requ
 const { sendError, sendSystem } = require('./protocol');
 const { removeAgentSessionFromHistory, saveSessionMetadata } = require('./session');
 const { stopAgentProcess } = require('./agentRunner');
+const { clearPendingPermissions } = require('./permissionState');
 
 function localCommandsHelp() {
   return `📋 Linco 本地命令：
@@ -276,7 +277,7 @@ function handleSwitch(indexOrId, ws, session, config) {
     session.currentInputForNoOutput = null;
     session.messageQueue = [];
     session.pendingDanger = null;
-    session.pendingPermission = null;
+    clearPendingPermissions(session);
   }
 
   // Verify the change persisted correctly

package/src/wsServer.js

@@ -173,7 +173,7 @@ function handleMessage(data, ws, session, config) {
     }
     if (msg.type === 'permission_response') {
       config.logger?.info('permission response received (linco)', { sessionKey: msg.sessionKey, approved: !!msg.approved });
-      if (!resolvePendingPermission(!!msg.approved, session.ws, session, config)) {
+      if (!resolvePendingPermission(!!msg.approved, session.ws, session, config, msg.requestId)) {
         sendError(session.ws, '❌ 没有待确认的工具权限请求');
       }
       return;
@@ -192,7 +192,7 @@ function handleMessage(data, ws, session, config) {
 
   if (msg.type === 'permission_response') {
     config.logger?.info('permission response received', { sessionId: session.id, approved: !!msg.approved });
-    if (!resolvePendingPermission(!!msg.approved, ws, session, config)) {
+    if (!resolvePendingPermission(!!msg.approved, ws, session, config, msg.requestId)) {
       sendError(ws, '❌ 没有待确认的工具权限请求');
     }
     return;