lark-remote 0.5.12 → 0.5.13

package/dist/card/run-state.js

@@ -1,4 +1,5 @@
 import { keepTail } from '../common/truncate.js';
+import { asRecord } from '../common/tool-summary.js';
 const MAX_REASONING_CHARS = 4_000;
 const MAX_TEXT_CHARS = 12_000;
 const MAX_TOOL_DETAIL_CHARS = 3_000;
@@ -10,7 +11,7 @@ const MAX_BLOCKS = 24;
  * 禁止各自再抄一份字面量——三处漂移过一次（goal_continuing 只进白名单不进
  * 按钮判据），新增终态时必漏一处的风险是结构性的。
  */
-export const RUN_TERMINAL_STATES = [
+const RUN_TERMINAL_STATES = [
     'done',
     'error',
     'interrupted',
@@ -50,6 +51,8 @@ export function reduceRunState(state, event) {
         return reduceBackgroundJobsEvent(state, event);
     if (event.type === 'result')
         return reduceResultEvent(state, event);
+    if (event.type === 'final_answer')
+        return reduceFinalAnswerEvent(state, event);
     if (event.type === 'assistant')
         return reduceAssistantEvent(state, event);
     if (event.type === 'user')
@@ -187,7 +190,7 @@ function reduceTurnDiffEvent(state, event) {
                     id: event.itemId,
                     name: event.toolName ?? 'command',
                     input: inputStr,
-                    parsedInput: tryParseRecord(inputStr),
+                    parsedInput: asRecord(inputStr),
                     ...(event.toolHint !== undefined ? { toolHint: event.toolHint } : {}),
                     output: keepTail(event.toolOutput, MAX_TOOL_DETAIL_CHARS),
                     status: complete ? (event.toolStatus ?? 'ok') : 'running',
@@ -320,31 +323,82 @@ function reduceResultEvent(state, event) {
     // sessionId is set by system.init; undefined means init hasn't arrived yet.
     if (state.sessionId === undefined)
         return state;
+    const withFinalAnswer = promoteFinalAnswer(state, 'inferred');
     const resultEvent = event;
     const incomingSubtype = event.subtype;
     const incomingErrorMsg = incomingSubtype === 'error' ? (resultEvent.errorMessage ?? 'Agent 返回错误结果') : undefined;
     // 合并 subtype：error 优先，其次 interrupted（任一为 error 即 error；
     // 否则任一为 interrupted 即 interrupted；interrupted 不得并入 success）。
-    const mergedSubtype = state.resultSubtype === 'error' || incomingSubtype === 'error'
+    const mergedSubtype = withFinalAnswer.resultSubtype === 'error' || incomingSubtype === 'error'
         ? 'error'
-        : state.resultSubtype === 'interrupted' || incomingSubtype === 'interrupted'
+        : withFinalAnswer.resultSubtype === 'interrupted' || incomingSubtype === 'interrupted'
             ? 'interrupted'
             : 'success';
     // 合并 errorMsg：首个非 undefined 胜出（existing ?? incoming）
-    const mergedErrorMsg = state.errorMsg ?? incomingErrorMsg;
+    const mergedErrorMsg = withFinalAnswer.errorMsg ?? incomingErrorMsg;
     return {
-        ...state,
+        ...withFinalAnswer,
         terminal: 'finalizing',
         footer: null,
-        blocks: markThinkingInactive(state.blocks),
+        blocks: markThinkingInactive(withFinalAnswer.blocks),
         resultSubtype: mergedSubtype,
         errorMsg: mergedErrorMsg,
         // costUsd：首个非 undefined 胜出（与 errorMsg 合并语义一致）
-        ...(event.total_cost_usd !== undefined && state.costUsd === undefined
+        ...(event.total_cost_usd !== undefined && withFinalAnswer.costUsd === undefined
             ? { costUsd: event.total_cost_usd }
             : {}),
     };
 }
+/** Record an authoritative protocol final answer and remove its progress copy. */
+function reduceFinalAnswerEvent(state, event) {
+    if (event.type !== 'final_answer')
+        return state;
+    if (!event.text.trim() && !state.finalAnswer)
+        return state;
+    const blocks = event.itemId
+        ? state.blocks.filter((block) => block.kind !== 'text' || block.itemId !== event.itemId)
+        : state.blocks;
+    const content = event.text.trim() ? event.text : (state.finalAnswer?.content ?? '');
+    return {
+        ...state,
+        blocks,
+        finalAnswer: {
+            content,
+            timestamp: state.finalAnswer?.timestamp ?? event.timestamp,
+            complete: event.complete ?? state.finalAnswer?.complete ?? false,
+            source: 'protocol',
+        },
+        footer: 'streaming',
+    };
+}
+/**
+ * Agents without an explicit final-answer marker use their last non-empty
+ * assistant text block. Moving it out of `blocks` protects it from
+ * MAX_BLOCKS and lets the renderer assign it first claim on card space.
+ */
+function promoteFinalAnswer(state, source) {
+    if (state.finalAnswer) {
+        return state.finalAnswer.complete
+            ? state
+            : { ...state, finalAnswer: { ...state.finalAnswer, complete: true } };
+    }
+    for (let i = state.blocks.length - 1; i >= 0; i--) {
+        const block = state.blocks[i];
+        if (block.kind !== 'text' || !block.content.trim())
+            continue;
+        return {
+            ...state,
+            blocks: state.blocks.filter((_, index) => index !== i),
+            finalAnswer: {
+                content: block.content,
+                timestamp: block.timestamp,
+                complete: true,
+                source,
+            },
+        };
+    }
+    return state;
+}
 /**
  * 后台任务名单 → RunState.backgroundJobs。
  *
@@ -458,7 +512,7 @@ function reduceAssistantEvent(state, event) {
                 id: content.id,
                 name: content.name,
                 input: inputStr,
-                parsedInput: tryParseRecord(inputStr),
+                parsedInput: asRecord(inputStr),
                 ...(content.summary !== undefined ? { summary: content.summary } : {}),
                 status: 'running',
                 startedAt: event.timestamp,
@@ -618,30 +672,33 @@ function reduceFileChangeEvent(state, event) {
     };
 }
 export function finishRun(state, terminal, meta = {}) {
+    const withFinalAnswer = promoteFinalAnswer(state, 'inferred');
     // 允许从 running 或 finalizing finish（/stop、idle watchdog、进程退出 finally）。
     // finalizing 是非终态（result 已收到，进程未退出），可被 finish 转终态。
     // 如果已经是终态，仍然允许补充 meta 信息（如 usage 等，bridge finally 的
     // else-if-sawResult 分支用此路径补充 token 统计）。
-    if (state.terminal !== 'running' && state.terminal !== 'finalizing') {
+    if (withFinalAnswer.terminal !== 'running' && withFinalAnswer.terminal !== 'finalizing') {
         // Already terminal: apply meta fields if provided (e.g. usage from jsonl)
         const hasMeta = Object.keys(meta).some((k) => meta[k] !== undefined);
         if (!hasMeta)
-            return state;
-        return { ...state, ...sanitizeMeta(meta) };
+            return withFinalAnswer;
+        return { ...withFinalAnswer, ...sanitizeMeta(meta) };
     }
     // interrupted 终态的中断来源：显式传入优先；否则从顶层持久标记推导
     // （approval_expired 已置位但调用方未传 reason 的路径，如协调器过期自动
     // cancel。原因必须在终态确定，不依赖调用方记得传参）。
     const derivedReason = meta.interruptedReason ??
-        (terminal === 'interrupted' && state.approvalExpired === true ? 'approval_timeout' : undefined);
+        (terminal === 'interrupted' && withFinalAnswer.approvalExpired === true
+            ? 'approval_timeout'
+            : undefined);
     return {
-        ...state,
+        ...withFinalAnswer,
         terminal,
         footer: null,
         // 耗时定格：终态之后再渲染（补 token 统计、点「详情」重渲染）都沿用同一
         // 结束时刻，否则每次 patch 的数字都会变大。
-        finishedAt: state.finishedAt ?? Date.now(),
-        blocks: markThinkingInactive(state.blocks),
+        finishedAt: withFinalAnswer.finishedAt ?? Date.now(),
+        blocks: markThinkingInactive(withFinalAnswer.blocks),
         ...sanitizeMeta(meta),
         ...(derivedReason !== undefined ? { interruptedReason: derivedReason } : {}),
     };
@@ -673,24 +730,6 @@ function stringifyUnknown(value) {
         return String(value);
     }
 }
-/**
- * parse a (possibly truncated) string into a record, mirroring what
- * `tool-render.ts`'s `asRecord` did on every render. Returns `null` when the
- * string is empty, non-JSON, or parses to a non-object — so a truncation-broken
- * JSON yields `null` exactly as the old per-render parse did. Computed once at
- * store time and cached on `ToolEntry.parsedInput`.
- */
-function tryParseRecord(input) {
-    if (!input)
-        return null;
-    try {
-        const p = JSON.parse(input);
-        return p && typeof p === 'object' ? p : null;
-    }
-    catch {
-        return null;
-    }
-}
 function keepLatestBlocks(blocks) {
     return blocks.length <= MAX_BLOCKS ? blocks : blocks.slice(-MAX_BLOCKS);
 }

package/dist/config/codex-config.js

@@ -519,10 +519,10 @@ export function loadCodexConfig(opts = {}) {
     }
     catch {
         // config.toml 读取/解析失败：readModelCatalogJsonPath 对此返回
-        // TOML_PARSE_FAILED_SENTINEL（isCodexCatalogMode → false），进入本 catch
-        // 时 catalogMode 恒为 false——下面的 `if (catalogMode)` 分支实际不可达，
-        // 仅作防御保留。真正「catalog 声明退化」的场景（'' 哨兵）在 parse 之前
-        // 就已按 FALLBACK 兜底处理，不会走到这里。
+        // TOML_PARSE_FAILED_SENTINEL（isCodexCatalogMode → false），因此正常路径下
+        // catalogMode 恒为 false，下面的 `if (catalogMode)` 分支只在两次读取之间
+        // config.toml 被改写（TOCTOU）时可达；保留该防御，避免把“已声明 catalog、
+        // 随后配置损坏”误降级成 bundled 模型。
         if (catalogMode) {
             return {
                 currentModel: '',

package/dist/config/index.d.ts

@@ -22,6 +22,8 @@ export declare const PI_THINKING_LEVELS: readonly ["off", "minimal", "low", "med
 export declare const DEFAULT_STOP_GRACE_MS: 5000;
 /** Codex app-server turn idle timeout default (minutes). */
 export declare const DEFAULT_TURN_IDLE_TIMEOUT_MINUTES: 30;
+/** Approval timeout default (ms), shared by schema and bridge fallback. */
+export declare const DEFAULT_APPROVAL_TIMEOUT_MS: number;
 /**
  * 入站媒体默认配置（schema 默认与 connector 兜底共用，避免双源漂移）。
  *
@@ -48,10 +50,10 @@ declare const ClaudeConfigSchema: z.ZodObject<{
     permissionMode: z.ZodDefault<z.ZodEnum<{
         default: "default";
         plan: "plan";
-        bypassPermissions: "bypassPermissions";
         auto: "auto";
         manual: "manual";
         acceptEdits: "acceptEdits";
+        bypassPermissions: "bypassPermissions";
         dontAsk: "dontAsk";
     }>>;
     approvalTimeoutMs: z.ZodDefault<z.ZodNumber>;
@@ -163,10 +165,10 @@ export declare const AppConfigSchema: z.ZodObject<{
         permissionMode: z.ZodDefault<z.ZodEnum<{
             default: "default";
             plan: "plan";
-            bypassPermissions: "bypassPermissions";
             auto: "auto";
             manual: "manual";
             acceptEdits: "acceptEdits";
+            bypassPermissions: "bypassPermissions";
             dontAsk: "dontAsk";
         }>>;
         approvalTimeoutMs: z.ZodDefault<z.ZodNumber>;

package/dist/config/index.js

@@ -50,6 +50,8 @@ const DEFAULTS = {
 export const DEFAULT_STOP_GRACE_MS = DEFAULTS.STOP_GRACE_MS;
 /** Codex app-server turn idle timeout default (minutes). */
 export const DEFAULT_TURN_IDLE_TIMEOUT_MINUTES = DEFAULTS.TURN_IDLE_TIMEOUT_MINUTES;
+/** Approval timeout default (ms), shared by schema and bridge fallback. */
+export const DEFAULT_APPROVAL_TIMEOUT_MS = DEFAULTS.APPROVAL_TIMEOUT_MS;
 /**
  * 入站媒体默认配置（schema 默认与 connector 兜底共用，避免双源漂移）。
  *
@@ -83,10 +85,10 @@ const ClaudeConfigSchema = z.object({
     effort: z.enum(CLAUDE_EFFORTS).default('medium'),
     /**
      * Claude 权限模式（官方 --permission-mode 枚举 + 'default'=省略该参数）。
-     * 默认 bypassPermissions 保持现有行为（无审批卡）；配置为其他值后激活
-     * 交互式审批（control_request → run 卡审批区）。
+     * 默认 auto：低风险操作自动放行，高风险操作走审批（control_request →
+     * run 卡审批区）；bypassPermissions 仍可选，但不再是默认值。
      */
-    permissionMode: z.enum(CLAUDE_PERMISSION_MODES).default('bypassPermissions'),
+    permissionMode: z.enum(CLAUDE_PERMISSION_MODES).default('auto'),
     /** 审批请求超时（ms），默认 5 分钟；超时自动发送 cancel 并中断 turn。
      *  0 = 立即过期（fail-fast，避免审批永久挂起），不推荐；勿随意改短。 */
     approvalTimeoutMs: z.number().int().min(0).default(DEFAULTS.APPROVAL_TIMEOUT_MS),
@@ -330,7 +332,7 @@ const TEMPLATE = `feishu:
 claude:
   model: ${DEFAULTS.CLAUDE_MODEL}
   effort: medium
-  permissionMode: bypassPermissions
+  permissionMode: auto
   approvalTimeoutMs: ${DEFAULTS.APPROVAL_TIMEOUT_MS}
   idleTtlMinutes: ${DEFAULTS.CLAUDE_IDLE_TTL_MINUTES}
   stopGraceMs: ${DEFAULTS.STOP_GRACE_MS}

package/dist/inbound/turn-assembler.js

@@ -227,6 +227,12 @@ export class InboundTurnAssembler {
         }
         catch (err) {
             getLogger().error('[inbound] turn commit failed:', err?.message ?? String(err));
+            try {
+                await this.deps.onReceipt?.(ctx, '⚠️ 消息处理失败，请重试；若持续失败请查看 lark-remote 日志。');
+            }
+            catch (receiptErr) {
+                getLogger().error('[inbound] failed to report turn commit failure:', receiptErr?.message ?? String(receiptErr));
+            }
         }
     }
 }