@tencent-ai/agent-harness 0.2.0-beta.1 → 0.2.0-beta.3

package/cli/dist-server/types/node/tools/tool-protocol.d.ts

@@ -21,18 +21,18 @@ export declare const DEFAULT_SLASH_COMMAND_TOOL_CHAR_BUDGET = 8000;
 export declare const DEFAULT_SKILL_TOOL_CHAR_BUDGET = 8000;
 export declare const DEFAULT_AGENT_TOOL_CHAR_BUDGET = 30000;
 /** Per-entry hard cap for a single skill's description */
-export declare const MAX_SKILL_DESC_CHARS = 150;
+export declare const MAX_SKILL_DESC_CHARS = 200;
 /** Minimum maxDescLen below which non-protected skills degrade to names-only (aligned with CC MIN_DESC_LENGTH=20) */
 export declare const MIN_SKILL_DESC_LENGTH = 20;
 /**
  * Env name for per-skill description hard-cap overrides.
  *
- * By default every skill's description is hard-capped to {@link MAX_SKILL_DESC_CHARS}(150)
+ * By default every skill's description is hard-capped to {@link MAX_SKILL_DESC_CHARS}(200)
  * per entry. A host can loosen (or tighten) this cap for **specific** skills — identified
  * by skill name — without changing the global default, by exporting this env.
  *
  * Format: a JSON object mapping skill name → maxChars, e.g.
- *   `{"tencent-docs-routing":300,"tencent-pptx":300}`
+ *   `{"workbuddy-office-routing":300,"tencent-pptx":300}`
  * The value is the per-entry cap that fully replaces the default for the named skill.
  * Explicitly overridden skills are also excluded from the later total-budget redistribution,
  * so an updated bundled skill keeps the same host-selected limit when its source becomes plugin.
@@ -47,7 +47,7 @@ export declare const SKILL_DESC_MAX_OVERRIDES_ENV = "CODEBUDDY_SKILL_DESC_MAX_OV
 /**
  * Parse the {@link SKILL_DESC_MAX_OVERRIDES_ENV} raw value into a `skillName → maxChars` map.
  *
- * - Expects a JSON object literal, e.g. `{"tencent-docs-routing":300}`.
+ * - Expects a JSON object literal, e.g. `{"workbuddy-office-routing":300}`.
  * - Returns an empty map for empty/undefined input, malformed JSON, or a non-object
  *   (array / string / number / null) top-level value — the caller decides whether to warn.
  * - Skips any entry with an empty (post-trim) key, a value that is not a positive integer,
@@ -377,6 +377,20 @@ export interface ToolManager {
      * 仅作用于 toolMap 中的内置工具；MCP 工具不走此路径。
      */
     ensureBuiltinDeferIndexed(toolName: string): Promise<boolean>;
+    /**
+     * 在工具执行前创建文件备份（file-history 快照），返回被跟踪的文件路径。
+     *
+     * 直连路径由 {@link executeToolWithHooks} 内部自动调用；REPL/Code Mode 沙箱
+     * 执行路径（DeferExecuteTool.routeToolCall → executeBuiltinTool）绕过该 hook
+     * 包装，需在真正执行工具前显式调用本方法，否则沙箱内的 Edit/Write 不产生
+     * FileHistorySnapshotItem，rewind 无快照可恢复（#130664）。
+     *
+     * 依赖 FileTrackService.trackFile 幂等（文件已在当前 checkpoint 即跳过），两条
+     * 路径都触达时也只落一次快照。
+     */
+    trackFileForToolCall(toolName: string, toolInput: unknown, session: Session, details?: {
+        toolCall: FunctionCallItem;
+    }): Promise<string | undefined>;
     addBackgroundTask(task: BackgroundTask): void;
     removeBackgroundTask(id: string): void;
     getBackgroundTasks(): BackgroundTask[];
@@ -494,6 +508,7 @@ export interface ToolHookManager {
         modifiedInput?: Record<string, any>;
         message?: string;
         permissionDecision?: 'allow' | 'deny' | 'ask';
+        preventContinuation?: boolean;
     }>;
     /**
      * Execute PostToolUse hooks after a tool completes successfully
@@ -801,6 +816,8 @@ export interface ImageGenerationResult extends GenerationCreditResult {
 }
 export interface VideoGenerationResult extends GenerationCreditResult {
     localPaths: string[];
+    /** 端上为适配模型能力做出的调整说明（如分辨率回落），供模型与用户知情 */
+    warnings?: string[];
 }
 /**
  * 图片生成结果
@@ -871,6 +888,7 @@ export interface VideoGenParams {
     image?: string;
     last_image?: string;
     resolution?: '480P' | '720P' | '1080P';
+    seconds?: number;
     aspect_ratio?: '16:9' | '9:16' | '1:1';
     negative_prompt?: string;
     enable_audio?: boolean;
@@ -920,3 +938,109 @@ export interface VideoService {
     /** 解析视频模型：session > env > settings > tag > fallback */
     resolveModel(session: Session | undefined, tag: string): Promise<string>;
 }
+export declare const AudioTranscribeService: unique symbol;
+/**
+ * 录音文件识别（长音频转文本）请求参数。
+ * `channel_num:1` 由 service 固定注入，不暴露给调用方。
+ */
+export interface AudioTranscribeOptions {
+    /** 说话人分离：0 关闭（默认）/ 1 开启（需 channel_num=1） */
+    speaker_diarization?: 0 | 1;
+    /** 临时热词表 "词|权重,..."（最多 128） */
+    hotword_list?: string;
+    /** 阿拉伯数字智能转换：0 / 1 / 3 */
+    convert_num_mode?: 0 | 1 | 3;
+    /** 脏词过滤：0 / 1 / 2 */
+    filter_dirty?: 0 | 1 | 2;
+    /** 标点过滤：0 / 1 / 2 */
+    filter_punc?: 0 | 1 | 2;
+    /** 语气词过滤：0 / 1 / 2 */
+    filter_modal?: 0 | 1 | 2;
+    /** 上游附加参数（合法 JSON 字符串），如 '{"Domain":3}' */
+    extra?: string;
+}
+/** service 内部解析出的音频来源（COS-only：始终为 audio_url）。 */
+export interface AudioSource {
+    audio_url: string;
+}
+/** 后端预签名返回项（`support:getPresignedUrls` 契约）。 */
+export interface AsrPresignItem {
+    object_key: string;
+    upload_url: string;
+    download_url: string;
+}
+/** 预签名接口响应信封。 */
+export interface AsrPresignApiResponse {
+    code: number;
+    msg?: string;
+    message?: string;
+    requestId?: string;
+    data?: {
+        expire?: number;
+        items?: AsrPresignItem[];
+    };
+}
+/** 提交任务响应信封（/v2/async/tasks/create）。 */
+export interface AsrCreateApiResponse {
+    code: number;
+    msg: string;
+    requestId: string;
+    data?: {
+        task_id?: string;
+        scene?: string;
+        status?: string;
+        created_at?: string;
+    };
+}
+/** 查询任务响应信封（/v2/async/tasks/query）。 */
+export interface AsrQueryApiResponse {
+    code: number;
+    msg: string;
+    requestId: string;
+    data?: {
+        task_id?: string;
+        scene?: string;
+        status?: 'queued' | 'in_progress' | 'completed' | 'failed';
+        created_at?: string;
+        completed_at?: string;
+        usage?: {
+            credit?: number;
+            coefficient?: number;
+            meters?: {
+                audio_second?: number;
+            };
+        };
+        attributes?: {
+            engine?: string;
+            vendor_status?: string;
+        };
+        error?: {
+            code?: string;
+            message?: string;
+        };
+        audio_transcription?: {
+            text?: string;
+        };
+    };
+}
+/** 录音文件识别结果。 */
+export interface AudioTranscribeResult {
+    /** 完整转写文本（上游 Result 原样透传） */
+    text: string;
+    /** 任务 ID */
+    taskId: string;
+    /** 实际音频时长（秒），计费依据 */
+    audioSecond?: number;
+    /** 最终积分消耗 */
+    credit?: number;
+}
+/**
+ * 录音文件识别服务接口。
+ * COS-only：本地文件先经后端预签名上传 COS，再以 audio_url 提交异步转写并轮询。
+ */
+export interface AudioTranscribeService {
+    /**
+     * 转写本地音频文件：预签名上传 → 提交任务 → 轮询直至终态。
+     */
+    transcribe(filePath: string, options: AudioTranscribeOptions, context: RunContext<Session>): Promise<AudioTranscribeResult>;
+}

package/cli/dist-server/types/vendor/cbc-core/node/agent/agent-protocol.d.ts

@@ -179,6 +179,12 @@ export declare function isBuiltinDisableableAgent(agentName: string): boolean;
  * waste prompt tokens on a tool they can never legitimately call (the SendMessage
  * tool itself returns an error when invoked outside a team context), and for
  * structured-output agents like `compact` it can pollute the model's output.
+ *
+ * **这些名字是保留字，不得被用作子代理 / teammate 预设名**（评审 #128343）：
+ * `resolveMessageSpeakerLabel` 把本名单的判定放在「子会话报自身身份」**之前**，因为历史与
+ * 用量多处按 `providerData.agent === 'compact'` 这类字符串比较判定，子会话里跑 compact 时
+ * 不能被身份名覆盖。反过来说，一旦有真实子代理取了这里的名字，它的消息会被标成生成器名
+ * 而不是自己的身份 —— 属于要靠人眼才能发现的错标。新增名字前先确认它不会与任何预设名撞。
  */
 export declare const INTERNAL_GENERATOR_AGENTS: Set<string>;
 /**
@@ -289,6 +295,13 @@ export interface AgentManager {
      * 同输入逐轮返回同一对象（prompt cache 稳定）；视图字节永不写回全局物化面。
      */
     sessionScopedAgentView(session: Session, base: Agent): Promise<Agent>;
+    /**
+     * sandbox-agent-view：把 REPL 的动态 schema 按子代理身份重新物化一遍。Code Mode 的
+     * agent 实例进程级共享（`get('ptc')` 命中同一对象），schema 在构建期用合成会话采集 ——
+     * 继承模式的子代理（Explore 等）会看到模式的全量目录。派发侧知道身份，经此覆盖。
+     * 只克隆 REPL 一个工具，视图不进 agentMap；空身份 / 同名 / 无 REPL 时原样返回基座。
+     */
+    sandboxScopedAgentView(base: Agent, sandboxAgentName: string): Promise<Agent>;
     /** served 激活链的视图预热（默认 agent），派发路径是失效兜底。 */
     prepareSessionAgentView(session: Session): Promise<void>;
     get(agentName: string): Promise<Agent | undefined>;
@@ -537,12 +550,37 @@ export interface AgentServiceRunControlOptions {
     bypassMessageQueue?: boolean;
     /** Input is already present in Session history; do not append it again. */
     skipAddHistory?: boolean;
+    /** Let an interactive host route external `/compact` before normal run admission. */
+    routeManualCompact?: boolean;
+    /**
+     * Per-call out-signal of `runDefault`: invoked once, synchronously, after
+     * this call passed run admission (its startup controller is installed on
+     * the Session) and before the agent is resolved. Not invoked when admission
+     * throws. It says nothing about the model having started or the run
+     * succeeding; without `bypassMessageQueue` the run may still be queued
+     * afterwards (see `onEnqueued`). A throwing callback is logged and does not
+     * affect the run. Internal re-runs pass fresh options and never carry it; it
+     * is stripped before AgentRunRequest and the SDK.
+     */
+    onAdmitted?: () => void;
 }
 /** Options for an isolated run or an SDK RunState resume. */
 export type AgentStandardRunOptions<TContext = Session> = AgentSdkRunOptions<TContext> & AgentServiceRunControlOptions & {
     /** Process-local provenance for fresh user turns; stripped before SDK dispatch. */
     inputOrigin?: AgentRunOrigin;
     continuation?: never;
+    /**
+     * Per-arrival out-signal: invoked when this run was routed to the message
+     * queue (skipRun, session busy) instead of executing now. Callers that owe
+     * their caller *this* prompt's own result (print / stream-json) use it to
+     * keep waiting until the queue drains and their turn actually runs.
+     *
+     * A run-scoped callback (not a shared session flag) so concurrent arrivals
+     * cannot clobber each other's outcome.
+     */
+    onEnqueued?: () => void;
+    /** Exact result of this arrival, including execution after a queue drain. */
+    onResult?: (result: NonNullable<Session['resultSubject']['value']>) => void;
 };
 /**
  * Explicitly claim the current process-local logical turn.
@@ -558,12 +596,23 @@ export type AgentCurrentContinuationOptions = AgentSdkRunOptions<Session> & Agen
 };
 export type AgentServiceRunOptions<TContext = Session> = AgentStandardRunOptions<TContext> | AgentCurrentContinuationOptions;
 export interface AgentService {
+    /** Atomically close a task's runtime only after its last result and queued work settle. */
+    tryCloseTaskSession?(session: Session, result: NonNullable<Session['resultSubject']['value']>): Promise<boolean>;
+    /** Stop accepting task work and join its physical runs before releasing dependencies. */
+    retireTaskSession?(session: Session): Promise<void>;
+    /**
+     * 有界等待该 session 上的物理 run 收尾（含它把最终产出写进 history）。
+     *
+     * `agent_end` 早于 run 的 finalize，所以「上一轮 history 已写完」不能靠 `agent_end`
+     * 判定；需要该因果的调用方（队列 drain）join 到这里。超时会放行并告警，不会挂死。
+     */
+    waitForRunsSettled?(session: Session): Promise<void>;
     run<TAgent extends Agent<any, any>>(agent: TAgent, input: string | AgentInputItem[], options: AgentCurrentContinuationOptions): Promise<void>;
     run<TAgent extends Agent<any, any>, TContext = Session>(agent: TAgent, input: string | AgentInputItem[] | RunState<TContext, TAgent>, options?: AgentStandardRunOptions<TContext>): Promise<void>;
     runDefault<TAgent extends Agent<any, any>>(input: string | AgentInputItem[], options: AgentCurrentContinuationOptions): Promise<void>;
     runDefault<TAgent extends Agent<any, any>, TContext = Session>(input: string | AgentInputItem[] | RunState<TContext, TAgent>, options?: AgentStandardRunOptions<TContext>): Promise<void>;
-    runOneTime<TContext = Session>(agentName: string, input: string | AgentInputItem[], options?: NonStreamRunOptions<TContext>): Promise<string>;
-    runOneTime<TContext = Session>(agentName: string, input: string | AgentInputItem[], options?: StreamRunOptions<TContext>): Promise<string>;
+    runOneTime<TContext = Session>(agentName: string, input: string | AgentInputItem[], options?: NonStreamRunOptions<TContext> & OneTimeRunOptions): Promise<string>;
+    runOneTime<TContext = Session>(agentName: string, input: string | AgentInputItem[], options?: StreamRunOptions<TContext> & OneTimeRunOptions): Promise<string>;
     /**
      * Run a one-shot agent call in a forked (isolated) session that inherits
      * the conversation history from the parent session. The forked session is
@@ -629,6 +678,11 @@ export interface ForkedAgentOptions {
     /** Optional cap on number of turns (default: 1 for one-shot) */
     maxTurns?: number;
 }
+/** Options of `runOneTime` on top of the SDK run options. */
+export interface OneTimeRunOptions {
+    /** X-Agent-Purpose of the call; defaults to the agent's `AGENT_PURPOSE_MAP` entry, else its name. */
+    purpose?: string;
+}
 export interface RunRequest {
     prompt?: string;
     inputFormat?: 'text' | 'stream-json';
@@ -670,6 +724,8 @@ export interface AgentRunRequest<TContext = Session> extends SessionOptions {
     skipAddHistory?: boolean;
     bypassMessageQueue?: boolean;
     inputOrigin?: AgentRunOrigin;
+    /** Process-local arrival callback; never passed to the SDK. */
+    onResult?: AgentStandardRunOptions['onResult'];
     traceId?: string;
     /**
      * #59319-5: 普通 run 二次裁决发现 session 仍 busy 时由 AgentService 设置。
@@ -779,6 +835,8 @@ export declare enum CustomAgentSavePath {
 }
 export declare enum OutputStyleType {
     DEFAULT = "default",
+    PROACTIVE = "proactive",
+    CONCISE = "concise",
     EXPLANATORY = "explanatory",
     LEARNING = "learning"
 }

package/cli/dist-server/types/vendor/cbc-core/node/agent/agent-purpose-protocol.d.ts

@@ -58,7 +58,9 @@ export declare enum AgentPurpose {
     /** Auto mode permission risk classification (runOneTime: AUTO_MODE_CLASSIFIER) */
     AutoModeClassifier = "auto_mode_classifier",
     /** Automation scheduled task execution */
-    Automation = "automation"
+    Automation = "automation",
+    /** `/btw` side question on a forked Session (runForked); Claude Code's `side_question` source */
+    SideQuestion = "side_question"
 }
 /**
  * Dynamic purpose prefix for built-in subagents.
@@ -127,6 +129,9 @@ export declare const AUXILIARY_PURPOSES: ReadonlySet<string>;
  * 时 purpose 可能尚未设置的普通对话仍按原行为发出 MODEL_REQUEST_STARTED。
  */
 export declare function isAuxiliaryPurpose(purpose?: string): boolean;
+/** Purposes of compaction summary calls (X-Agent-Type `compaction`). */
+export declare const COMPACTION_PURPOSES: ReadonlySet<string>;
+export declare function isCompactionPurpose(purpose?: string): boolean;
 /**
  * 按 purpose 旁路 agent 生命周期事件（agent_start / agent_end / tool / handoff）。
  *
@@ -145,9 +150,8 @@ export declare function isAuxiliaryPurpose(purpose?: string): boolean;
  *
  * 因此这里只收 PreMessage 这一种 purpose。
  *
- * 依赖前提：`PreMessageCompactStrategy` 在 runOneTime 前后设置 / 还原
- * `session.agentPurpose`，且用 try/finally 保证异常路径也会还原——否则 purpose 泄漏
- * 会让**主 run** 也被误旁路，反而放大本要修复的孤儿 run 问题。
+ * The purpose is scoped to the summary call (`runOneTime` → `runWithAgentPurpose`), so it
+ * cannot leak onto the pending main run.
  *
  * multi-session（#44317）回归时，PreMessage 承载应改回临时子 Session；本名单保留为
  * 冗余防线即可（临时 Session 上旁路是无害的）。

package/cli/dist-server/types/vendor/cbc-core/node/agent/agent-purpose-scope.d.ts

@@ -0,0 +1,46 @@
+import type { AgentType } from '../../../../workspace/telemetry/lib/common/index.js';
+interface PurposeCarrier {
+    agentPurpose?: string;
+    conversationRequestId?: string;
+}
+/**
+ * Runs an auxiliary model call (title, summary, WebFetch analysis, ...) on a
+ * caller-owned Session without writing its purpose / request id onto the shared
+ * Session, where a concurrent main run would read and send them as its own.
+ */
+export declare function runWithAgentPurpose<T>(session: object, purpose: string, callback: () => T, options?: {
+    conversationRequestId?: string;
+}): T;
+/** True when the current async chain is an auxiliary call scoped to `session`. */
+export declare function isInAgentPurposeScope(session: object | undefined): boolean;
+/** Purpose of the model call running in the current async chain. */
+export declare function getEffectiveAgentPurpose(session: PurposeCarrier | undefined): string | undefined;
+/** Request id of the model call running in the current async chain. */
+export declare function getEffectiveConversationRequestId(session: PurposeCarrier | undefined): string | undefined;
+/** Purposes whose model calls are steps of a Session's own agent loop. */
+export declare function isMainConversationPurpose(purpose: string | undefined): boolean;
+/** True when the model call in the current async chain is a step of `session`'s agent loop. */
+export declare function isMainLoopModelCall(session: PurposeCarrier | undefined): boolean;
+/** True when the model call in the current async chain has an `AUXILIARY_PURPOSES` purpose. */
+export declare function isAuxiliaryPurposeCall(session: PurposeCarrier | undefined): boolean;
+/**
+ * Runs `callback` outside any purpose scope. A run started from a helper call's async
+ * chain (e.g. a queued message drained on its agent_end) is a new agent-loop run.
+ */
+export declare function runOutsideAgentPurposeScope<T>(callback: () => T): T;
+export type ModelCallAgentType = AgentType;
+/** Role of the Session's own agent loop, for request-level events. */
+export declare function resolveSessionAgentType(session: {
+    meta?: Record<string, unknown>;
+}): 'main' | 'subagent' | 'team';
+/**
+ * Role of the model call in the current async chain (X-Agent-Type / telemetry
+ * `agentType`), mirroring Claude Code's `x-claude-code-request-class`: compaction
+ * summaries report `compaction`, other one-shot helpers (title, WebFetch analysis,
+ * ...) report `auxiliary`, whatever Session they run on. The specific helper
+ * stays in X-Agent-Purpose.
+ */
+export declare function resolveModelCallAgentType(session: PurposeCarrier & {
+    meta?: Record<string, unknown>;
+}): ModelCallAgentType;
+export {};

package/cli/dist-server/types/vendor/cbc-core/node/agent/agent-service.d.ts

@@ -3,10 +3,11 @@ import { AuthenticationManager } from '../../../../workspace/authentication/lib/
 import { type AbortLinkDisposer, Agent, type AgentInputItem, type NonStreamRunOptions, RunState, type StreamRunOptions } from '../../../cbc-shared/node/index.js';
 import { type LanguageModel } from '../../../../workspace/product/lib/common/index.js';
 import { Logger } from '../../../../workspace/telemetry/lib/common/index.js';
+import { type ManualCompactRequestHandler as ManualCompactRequestHandlerContract } from '../context/context-protocol';
 import { type FileRollbackOperationLock as FileRollbackOperationLockContract } from '../file-rollback/file-rollback-service-protocol';
 import { Session, SessionManager } from '../session/session-protocol';
 import { SessionRunStateMachine } from '../session/session-run-state-machine-protocol';
-import { type AgentCurrentContinuationOptions, AgentManager, AgentRunInterceptor, AgentRunRequest, AgentService, type AgentStandardRunOptions, RunnerProvider } from './agent-protocol';
+import { type AgentCurrentContinuationOptions, AgentManager, AgentRunInterceptor, AgentRunRequest, AgentService, type AgentStandardRunOptions, type OneTimeRunOptions, RunnerProvider } from './agent-protocol';
 import { type AgentRunScope as IAgentRunScope } from './agent-run-scope';
 import { AgentPluginRefresh, AgentRunObserver, AgentRuntimeResolver } from './agent-runtime-protocol';
 export declare class AgentServiceImpl implements AgentService {
@@ -22,6 +23,7 @@ export declare class AgentServiceImpl implements AgentService {
     protected readonly agentRunInterceptorProvider: Provider<AgentRunInterceptor>;
     protected readonly fileRollbackOperationLock?: FileRollbackOperationLockContract;
     protected readonly logger: Logger;
+    protected readonly manualCompactRequestHandler?: ManualCompactRequestHandlerContract;
     /**
      * Preserve the pre-start cancellation snapshot across runDefault's agent
      * lookup controller and run()'s own controller. This is process-local
@@ -38,6 +40,22 @@ export declare class AgentServiceImpl implements AgentService {
      */
     private lifecycleOwners;
     protected getLifecycleOwners(): WeakMap<Session, AbortController>;
+    tryCloseTaskSession(session: Session, result: NonNullable<Session['resultSubject']['value']>): Promise<boolean>;
+    retireTaskSession(session: Session): Promise<void>;
+    waitForRunsSettled(session: Session): Promise<void>;
+    /**
+     * 有界 join：等到该 session 上的物理 run 全部交还 lifecycle owner 与 in-flight 信号。
+     *
+     * 为什么需要它而不是直接看 `agent_end`：`finalizeRun` 晚于本轮把最终产出写进
+     * history，`agent_end` 却早于 `finalizeRun`。任何依赖「上一轮 history 已写完」这个
+     * 因果的调用方（如队列 drain）必须 join 到这里。
+     *
+     * Bounded: `runSettledSubject` is optional, so a session built without
+     * one has nothing to observe and would hang the caller's cleanup — which
+     * owns hook, MCP and background-shell teardown. `agent_end` 也可能来自没有物理
+     * run 的路径（skipRun / 迟到事件），无界等待会把调用方永久挂住。
+     */
+    private joinRunsSettled;
     /** compare-and-delete：仅当 token 仍指向本轮 controller 时清除。 */
     private clearLifecycleOwner;
     /** 本轮是否是当前 lifecycle owner。 */
@@ -154,6 +172,7 @@ export declare class AgentServiceImpl implements AgentService {
     protected resolveRunOneTimeModel(agentName: string, session?: Session): Promise<LanguageModel>;
     run<TAgent extends Agent<any, any>>(agent: TAgent, input: string | AgentInputItem[], options: AgentCurrentContinuationOptions): Promise<void>;
     run<TAgent extends Agent<any, any>, TContext = Session>(agent: TAgent, input: string | AgentInputItem[] | RunState<TContext, TAgent>, options?: AgentStandardRunOptions<TContext>): Promise<void>;
+    private runPipeline;
     /**
      * #59319-stream: 抽取的 physical run cleanup 逻辑。
      * 非 stream 路径由 run() finally 同步调用；
@@ -187,8 +206,14 @@ export declare class AgentServiceImpl implements AgentService {
     private prepareRunAdmission;
     runDefault<TAgent extends Agent<any, any>>(input: string | AgentInputItem[], options: AgentCurrentContinuationOptions): Promise<void>;
     runDefault<TAgent extends Agent<any, any>, TContext = Session>(input: string | AgentInputItem[] | RunState<TContext, TAgent>, options?: AgentStandardRunOptions<TContext>): Promise<void>;
-    runOneTime<TContext = Session>(agentName: string, input: string | AgentInputItem[], options?: NonStreamRunOptions<TContext>): Promise<string>;
-    runOneTime<TContext = Session>(agentName: string, input: string | AgentInputItem[], options?: StreamRunOptions<TContext>): Promise<string>;
+    /**
+     * Streams the text of a one-shot run on `session`. A reused caller Session is shared
+     * with its in-flight main run, so the call's purpose and request id live in its async
+     * scope instead of on the Session.
+     */
+    private streamOneTimeText;
+    runOneTime<TContext = Session>(agentName: string, input: string | AgentInputItem[], options?: NonStreamRunOptions<TContext> & OneTimeRunOptions): Promise<string>;
+    runOneTime<TContext = Session>(agentName: string, input: string | AgentInputItem[], options?: StreamRunOptions<TContext> & OneTimeRunOptions): Promise<string>;
     /**
      * Enhanced version of runOneTime that supports per-request overrides
      * for temperature, maxTokens, maxTurns, systemPrompt, and bypassPermissions.

package/cli/dist-server/types/vendor/cbc-core/node/agent/index.d.ts

@@ -1,11 +1,15 @@
 export * from './agent-protocol';
 export * from './agent-purpose-protocol';
+export * from './agent-purpose-scope';
+export * from './model-step-sequence';
+export * from './model-call-failure';
 export * from './agent-runtime-protocol';
 export * from './agent-run-scope';
 export * from './agent-service';
 export * from './agent-factory';
 export * from './runner-factory';
 export * from './runner-provider';
+export * from './speaker-label';
 export * from './ordered-tools-agent';
 export * from './tool-call-loop-detector-protocol';
 export * from './tool-call-loop-detector-service';

package/cli/dist-server/types/vendor/cbc-core/node/agent/interceptors/input-interceptors.d.ts

@@ -17,12 +17,7 @@ export declare class MessageQueueAgentRunInterceptor implements AgentRunIntercep
     protected readonly logger: Logger;
     protected readonly stateMachine: SessionRunStateMachine;
     intercept(request: AgentRunRequest): Promise<void>;
-    /**
-     * 触发后不再重复打 error（防日志风暴）；下次"有实际工作"分支复位 counter/flag，
-     * session 自动恢复处理能力。
-     */
-    private trackEmptyDrainAndMaybeTripGuard;
-    private resetEmptyDrainLoopGuard;
+    private consumeQueueItems;
 }
 /**
  * 用户查询包裹拦截器

package/cli/dist-server/types/vendor/cbc-core/node/agent/model-call-failure.d.ts

@@ -0,0 +1,9 @@
+import type { ModelCallGeneration } from '../session/session-protocol';
+/**
+ * Marks `error` as the failure of one model call. The call's ids live in the model-call
+ * async scope, which does not reach the consumer of the SDK run stream; the error does.
+ * An error rethrown through an outer call keeps the innermost call's mark.
+ */
+export declare function markModelCallFailure<T>(error: T, sessionId: string, generation: ModelCallGeneration): T;
+/** The model call of this Session that failed with `error`; undefined when the failure is not one. */
+export declare function getFailedModelCall(error: unknown, sessionId: string): ModelCallGeneration | undefined;

package/cli/dist-server/types/vendor/cbc-core/node/agent/model-step-sequence.d.ts

@@ -0,0 +1,11 @@
+import type { Session } from '../session/session-protocol';
+type StepSequenceSession = Pick<Session, 'id' | 'history' | 'agentPurpose' | 'modelStepSeq'>;
+/** Latest step of the Session's agent loop, restored from persisted history after resume. */
+export declare function currentModelStepSeq(session: StepSequenceSession): number;
+/**
+ * Step number for the model call in the current async chain. Agent-loop calls
+ * advance the counter; auxiliary calls reuse the latest step. The counter never
+ * resets across runs, compaction continuations or teammate wake-ups.
+ */
+export declare function allocateModelStepSeq(session: StepSequenceSession): number;
+export {};

package/cli/dist-server/types/vendor/cbc-core/node/agent/runner-factory.d.ts

@@ -1,4 +1,4 @@
-import { type RunConfig, Runner } from '../../../cbc-shared/node/index.js';
+import { type AgentInputItem, type RunConfig, Runner } from '../../../cbc-shared/node/index.js';
 import { ProductManager } from '../../../../workspace/product/lib/common/index.js';
 import { Logger } from '../../../../workspace/telemetry/lib/common/index.js';
 import { type NotificationInjectionBuffer as INotificationInjectionBuffer } from '../message-queue/notification-injection-buffer-protocol';
@@ -15,6 +15,15 @@ import { ToolCallLoopDetector } from './tool-call-loop-detector-protocol';
  * Used by finishReasonErrorInterceptor to detect prior retries across both mechanisms.
  */
 export declare const TRUNCATION_RETRY_MARKER = "Do NOT repeat the same oversized tool call. Break it into smaller operations.";
+export interface ModelInputMemoryPressure {
+    heapUsed: number;
+    heapLimit: number;
+    headroom: number;
+    inputItems: number;
+    estimatedInputBytes?: number;
+    reject: boolean;
+}
+export declare function assessModelInputMemoryPressure(input: AgentInputItem[], heapUsed?: number, heapLimit?: number): ModelInputMemoryPressure;
 /**
  * Tool-specific hints for how to decompose a truncated tool call into smaller operations.
  */
@@ -72,6 +81,7 @@ export declare class RunnerFactoryImpl implements RunnerFactory {
      */
     protected readonly acpBroadcastService?: AgentQueueOutput;
     create(config?: Partial<RunConfig>): Promise<Runner>;
+    private assertModelInputCloneHeadroom;
     /**
      * 在每次模型请求前检查是否需要自动压缩。
      * 此时所有工具都已执行完毕，可以安全地触发压缩。
@@ -80,10 +90,10 @@ export declare class RunnerFactoryImpl implements RunnerFactory {
     /**
      * Mode B：把「立即发送」队列项注入正在运行的 turn（#73022）。
      *
-     * 调用点在 `callModelInputFilter`（见 `create()`），即**每次模型请求之前**，
-     * 且此时本轮工具已全部执行完、tool result 已回填。选这个边界是因为既不用
-     * 打断在跑的工具，也不会破坏 `tool_call` 与 `tool_result` 的配对——Codex 与
-     * Claude Code 同样选在这个位置。
+     * 调用点在 `callModelInputFilter`（见 `create()`），即**每次模型请求之前**。
+     * rich message / notification / drain prompt 仍在这里注入请求副本；真实 steer
+     * 由 `continuationInputProvider` 在 `prepareTurn` 前写入 SDK RunState，避免后续
+     * 工具 step 从权威状态重建请求时丢失。
      *
      * 注入内容已经进入本次模型请求，无需再为“曾经注入过”强制续圈。只有模型响应期间
      * 新到达、尚未被取出的消息，才由 `__codebuddySteerPending` 在收尾时实时判定是否
@@ -101,6 +111,22 @@ export declare class RunnerFactoryImpl implements RunnerFactory {
      *   `create()` 注释）。payload 与授权同为调用局部值，天然不跨 run 共享。
      */
     private injectSendNowItems;
+    /**
+     * Drain steer only at the SDK continuation boundary, before it prepares the next model step.
+     *
+     * The returned model items are installed by the SDK into RunState.generatedItems before
+     * `prepareTurn`. This makes steer authoritative input for every later tool/model step instead
+     * of an ephemeral `callModelInputFilter` addition. The visible history stays the bare user
+     * message; it is admitted exactly once, by the stream consumer, in RunState order.
+     */
+    private takeSteerContinuationInput;
+    /**
+     * Visible-history + ACP admission of one drained steer group.
+     *
+     * Ordering is the caller's responsibility (continuation-history-queue.ts); this only performs
+     * the writes and must never throw back into the run.
+     */
+    private admitSteerToVisibleHistory;
     /**
      * #100404：落定来源一（rich queue sendNow）的消费。
      *
@@ -129,11 +155,11 @@ export declare class RunnerFactoryImpl implements RunnerFactory {
      * （`session/session-manager.ts` 的 `MODEL_STREAM_STARTED`），涉及跨模块反向布线与
      * 事件类型白名单依赖，另开 issue 跟进。
      *
-     * **落史顺序反转（显式接受）**：`modelData.input` 的 push 顺序是来源一 → 二 → 三 → 四，
-     * 但来源一的 `addHistory` 推迟到本方法内执行，来源二/三/四仍在 `injectSendNowItems` 里
-     * 就地 addHistory。同一 model step 同时命中多个来源时，history 里队员消息会排在
-     * steer / 通知之后，与模型当时看到的输入顺序相反。已确认下游按 role/type 消费、不依赖
-     * 交错位置，故接受该反转，不做「四来源 historyItems 统一收敛」的重构。
+     * **落史顺序反转（显式接受）**：`modelData.input` 的 filter push 顺序是来源一 → 三 → 四，
+     * 但来源一的 `addHistory` 推迟到本方法内执行，来源三/四仍在 `injectSendNowItems` 里
+     * 就地 addHistory。同一 model step 同时命中多个来源时，history 里队员消息会排在通知
+     * 之后，与模型当时看到的输入顺序相反。steer 已在更早的 SDK continuation 边界同时进入
+     * RunState 与可见历史，不参与这段反转。下游按 role/type 消费、不依赖交错位置，故接受。
      *
      * at-most-once 由**作用域**保证，不再依赖「commit 前清暂存」这类补偿动作：`pending` 是
      * 单次 `callModelInputFilter` 调用的局部值，每次调用最多把它 commit 一次，也不可能被
@@ -211,10 +237,10 @@ export declare class RunnerFactoryImpl implements RunnerFactory {
      * model / agent / argumentsDisplayText 等键同样会跟着走，它们是惰性字段、上游不解读，
      * 这里不做处理；真正需要清掉的只有语义已经反转的 discard。
      *
-     * 改写与删标记都只作用于当轮副本（见 filterTruncatedToolCalls 的
-     * "Scope of the rewrite"），session.history 里的原值保持不变。
+     * 返回一个浅复制的新 item；providerData 仅在需要删除 discard 时 copy-on-write。
+     * session.history 与 SDK 传入的原 item 始终保持不变。
      */
-    private rewriteCallArguments;
+    private withRewrittenCallArguments;
     /**
      * SDK callModelInputFilter: called before every model API request within the SDK run loop.
      *
@@ -240,13 +266,23 @@ export declare class RunnerFactoryImpl implements RunnerFactory {
      *   message instructing the model to break the call into smaller operations. This
      *   turns the SDK's automatic retry into a valid, useful request.
      *
-     * Scope of the rewrite: `agents-core`'s `applyCallModelInputFilter` hands us a
-     * `structuredClone` of the turn input and clones our return value again, explicitly so
-     * that filter-side mutations cannot touch cached turn state. So every rewrite here
-     * lands on a per-turn copy only — `session.history` keeps the malformed arguments and
-     * we redo the same rewrite on every subsequent turn. That is correct but not free:
-     * anything reported from this path must be aggregated per turn rather than logged per
-     * call, or a long session with N bad calls emits N log lines every turn.
+     * Scope of the rewrite: this filter opts into the SDK's `preserveInputIdentity` mode,
+     * so existing history items arrive by identity and MUST remain immutable. Repairs use
+     * item-level copy-on-write and array-level shallow copies; the SDK still creates isolated
+     * model/session copies after the filter returns. `session.history` therefore keeps the
+     * malformed arguments and we redo the same rewrite on every subsequent turn. Anything
+     * reported from this path must be aggregated per turn rather than logged per call.
+     */
+    /**
+     * 模型输入的两步修复，**顺序不能反**：
+     *
+     * 1. `filterTruncatedToolCalls` 先跑。截断（finish_reason=length）与坏 JSON 的
+     *    call 正是「参数半截 + 没有任何 result」那一类；它删掉这些 call 的同时会注入
+     *    拆解引导与防循环停止标记。若先按配对摘掉它们，该分支因 `invalidCallIds` 为空
+     *    直接早退，模型拿不到任何引导，退回 #75892 那条老路，而且请求本身合法、无错可见。
+     * 2. `filterUnpairedToolCalls` 后跑，收掉剩下的孤儿（参数合法但结果丢失、重复 callId、
+     *    头部被截断留下的孤儿结果）。本地正文里的孤儿是持久化的，留着每次恢复都被上游 400。
      */
+    private repairModelInput;
     private filterTruncatedToolCalls;
 }