@tencent-ai/codebuddy-code 2.139.0-dev.c47174a.202608271521 → 2.139.0-dev.d4a09ae.202608281607

package/dist-server/types/node/a2a/a2a-gate.d.ts

@@ -1,4 +1,5 @@
-import type { AbTestService } from '@genie/product';
+import { type AbTestService } from '@genie/product';
+import type { Logger } from '@genie/telemetry';
 /**
  * Env var that force-enables outbound A2A independent of cloud product
  * config — set it truthy (`1`/`true`/`yes`/`on`, see `BooleanUtils.isTruthy`)
@@ -13,12 +14,33 @@ import type { AbTestService } from '@genie/product';
  * authority stays with cloud config (see CODEBUDDY.md §10's kill-switch
  * semantics) so an operator can still remotely disable A2A even on hosts
  * that happen to have this env var lingering in their process environment.
+ *
+ * Independent of, and AND'd with, `ENV_REMOTE_AGENTS_URL` below — this env
+ * var only ever forces the *feature switch* on, never bypasses the
+ * "is there actually a discovery URL configured" requirement.
  */
 export declare const ENV_A2A_OUTBOUND_ENABLED = "CODEBUDDY_A2A_OUTBOUND_ENABLED";
+/**
+ * Discovery source for outbound A2A agents (issue #99451 Part B). Read LIVE
+ * from `process.env` at the point of use — see `A2aAgentDiscoveryService`'s
+ * doc comment for why this must never be cached earlier (prewarm
+ * per-session env only lands at `activate`).
+ *
+ * ANDed into `isA2AOutboundEnabled()`: even if the feature switch is on, the
+ * gate stays off with no discovery source configured — there would be
+ * nothing to discover, and the 4 A2A tools would otherwise expose
+ * themselves to the model only to fail on first use.
+ */
+export declare const ENV_REMOTE_AGENTS_URL = "CODEBUDDY_REMOTE_AGENTS_URL";
 /**
  * Resolve whether outbound A2A is enabled for the current process.
  *
- * Check order (first hit wins):
+ * `CODEBUDDY_REMOTE_AGENTS_URL` is checked FIRST — cheap, synchronous, and
+ * lets us skip the `AbTestService` round trip entirely (and log a specific
+ * "off because no URL" reason, distinct from "off because the feature flag
+ * is off") when there's no discovery source configured at all.
+ *
+ * Feature-switch check order (first hit wins):
  *   1. `CODEBUDDY_A2A_OUTBOUND_ENABLED` truthy → enabled, no `AbTestService`
  *      round trip needed.
  *   2. `ProductFeature.A2AOutbound` via `AbTestService` (existing behavior).
@@ -27,5 +49,10 @@ export declare const ENV_A2A_OUTBOUND_ENABLED = "CODEBUDDY_A2A_OUTBOUND_ENABLED"
  *      `abTestService` is `undefined` in unassembled-container unit tests;
  *      those paths fall back to disabled, matching the same conservative
  *      default.
+ *
+ * `logger` is optional (debug-level only — this is called from every A2A
+ * tool's `isEnabled`/`execute`, so it must stay quiet by default) and used
+ * solely for the Logging section's "why is the gate off" diagnostic — it
+ * does not affect the returned value.
  */
-export declare function isA2AOutboundEnabled(abTestService?: AbTestService): Promise<boolean>;
+export declare function isA2AOutboundEnabled(abTestService?: AbTestService, logger?: Pick<Logger, 'debug'>): Promise<boolean>;

package/dist-server/types/node/a2a/a2a-protocol.d.ts

@@ -2,23 +2,23 @@
  * Outbound A2A (Agent2Agent) protocol surface — CloudAgent Phase 1.
  *
  * Scope (see issue #99451): agent-cli acts ONLY as an outbound A2A client /
- * orchestrator. It discovers Agent Cards from a host-supplied discovery URL
- * (see `RemoteAgentsConfig` in control-signal-protocol.ts) and invokes them
- * via the official `@a2a-js/sdk`. There is no agent-cli A2A server, no
+ * orchestrator. It discovers Agent Cards from a discovery URL supplied via
+ * the `CODEBUDDY_REMOTE_AGENTS_URL` env var (see `a2a-gate.ts`) and invokes
+ * them via the official `@a2a-js/sdk`. There is no agent-cli A2A server, no
  * remote-agent callback, and no A2A streaming (`sendMessageStream`/
- * `subscribeToTask`) in Phase 1 — `sendMessage` always blocks until a
- * terminal or interrupted state, and `getTask`/`cancelTask` are simple
- * point-in-time queries, not the start of a polling loop owned by agent-cli
- * (the model re-invokes `A2AGetTask` itself when it wants to check again —
- * see `A2AGetTaskTool`).
+ * `subscribeToTask`) in Phase 1 — `sendMessage` always returns immediately
+ * with whatever the initial response is, and `A2AGetTaskTool` owns a
+ * bounded poll loop for non-terminal tasks (see that tool's doc comment).
  *
- * Discovery is LAZY, not eager at `initialize`: the host only hands us a
- * URL + optional auth headers at
- * `initialize` time (`A2aAgentDiscoveryService.setConfig`); the actual
- * network fetch happens on first use, gated by `A2aDiscoveryReadyService`
- * (single shared readiness gate, mirrors `McpReadyService` — see that
- * file's doc comment for why a shared gate beats each tool independently
- * deciding whether to fetch).
+ * Discovery is LAZY: the actual network fetch happens on first A2A tool
+ * use, gated by `A2aDiscoveryReadyService` (single shared readiness gate,
+ * mirrors `McpReadyService` — see that file's doc comment for why a shared
+ * gate beats each tool independently deciding whether to fetch). The
+ * discovery URL itself is read live from `process.env` at `discover()`-call
+ * time (issue #99451 Part B) — never cached earlier, per this repo's
+ * prewarm convention (see `CODEBUDDY.md` §1.1's "env 消费同理" section):
+ * a prewarmed standby process only gets the real per-session env merged in
+ * at `activate`, and discovery's first use always happens after that point.
  *
  * State is process-global (like `SdkInitializeStateService`, not
  * per-ACP-session like `AgentScopedMcpManager`): CloudAgent's real
@@ -30,35 +30,25 @@
  * All Symbols/interfaces live here per the repo's `xxx-protocol.ts` convention
  * (Symbol + interface; implementations live in sibling files).
  */
-import type { RemoteAgentsConfig } from '../control-signal/control-signal-protocol';
 export declare const A2aAgentRegistry: unique symbol;
 export declare const A2aClientService: unique symbol;
 export declare const A2aAgentDiscoveryService: unique symbol;
 export declare const A2aDiscoveryReadyService: unique symbol;
-/**
- * Auth headers applied to an agent's own `sendMessage`/`getTask`/`cancelTask`
- * calls. Internal registry shape — NOT part of the wire protocol anymore
- * (see `RemoteAgentsConfig` in control-signal-protocol.ts for the actual
- * host-supplied contract). `A2aAgentDiscoveryService` populates this from
- * the single discovery-level `auth` config shared across every discovered
- * agent (raw A2A `AgentCard`s carry no credentials of their own).
- */
-export interface A2AAgentAuthConfig {
-    headers?: Record<string, string>;
-}
 /**
  * Internal input shape for `A2aAgentRegistry.register()` — NOT part of the
  * wire protocol (see module doc comment: the host only supplies a discovery
  * URL now, not this shape directly). `A2aAgentDiscoveryService` maps each
  * fetched raw `AgentCard` into one of these, deriving `agentId` from the
- * card's own `name` field.
+ * card's own `name` field. No per-agent auth: the discovery URL (and every
+ * discovered agent's own calls, via the same proxy path) is routed through
+ * our own infrastructure, which handles auth uniformly (issue #99451 Part
+ * B) — see `A2aAgentDiscoveryService`'s doc comment.
  */
 export interface A2AAgentDefinition {
     agentId: string;
     agentCard: Record<string, unknown>;
     /** Additional natural-language aliases for discovery, beyond the card's own name/description/skills. */
     aliases?: string[];
-    auth?: A2AAgentAuthConfig;
 }
 /**
  * URI of the private codebuddy.ai extension that lets a caller pin a
@@ -82,9 +72,6 @@ export interface A2aRegisteredAgent {
     agentId: string;
     agentCard: A2aAgentCard;
     aliases: string[];
-    auth?: {
-        headers?: Record<string, string>;
-    };
 }
 /**
  * Minimal shape of an A2A v1.0 AgentCard this registry actually reads.
@@ -163,18 +150,11 @@ export interface A2aAgentRegistry {
  */
 export interface A2aAgentDiscoveryService {
     /**
-     * Store the discovery config (URL + optional auth headers). No I/O —
-     * safe to call from `InitializeHandler` without blocking the handshake.
-     * `undefined` clears the config and any previously discovered agents
-     * (mirrors the old `a2aAgents: []` "host says no agents this time"
-     * semantics, now expressed by omitting `remoteAgentsConfig` entirely).
-     */
-    setConfig(config: RemoteAgentsConfig | undefined): void;
-    /**
-     * Fetch the configured URL, parse the response as a JSON array of A2A
-     * v1.0 `AgentCard` objects, map each into an `A2AAgentDefinition`
-     * (`agentId` derived from `agentCard.name`, `auth` from the shared
-     * discovery-level config), and register the result via
+     * Fetch `CODEBUDDY_REMOTE_AGENTS_URL` (read live from `process.env` at
+     * call time — see module doc comment on why this must never be cached
+     * earlier), parse the response as a JSON array of A2A v1.0 `AgentCard`
+     * objects, map each into an `A2AAgentDefinition` (`agentId` derived
+     * from `agentCard.name`), and register the result via
      * `A2aAgentRegistry.register()`. Always performs a fresh fetch when
      * called — caching/dedup against repeated calls is `A2aDiscoveryReadyService`'s
      * job, not this service's.
@@ -184,7 +164,7 @@ export interface A2aAgentDiscoveryService {
      * `A2AAgentSearchTool`'s existing empty-registry response, not a thrown
      * error.
      *
-     * No-op (resolves immediately) when no config has been set.
+     * No-op (resolves immediately) when the env var is unset/empty.
      */
     discover(options?: {
         signal?: AbortSignal;
@@ -192,7 +172,7 @@ export interface A2aAgentDiscoveryService {
 }
 /**
  * Single shared readiness gate ensuring the discovery fetch runs exactly
- * once (per config generation) no matter which of the 4 A2A tools is the
+ * once per process lifetime no matter which of the 4 A2A tools is the
  * first to need it. Mirrors `McpReadyService`'s "trigger once, let every
  * caller await the same in-flight promise" shape — deliberately NOT
  * duplicated per tool (an earlier draft of this refactor called
@@ -204,19 +184,18 @@ export interface A2aAgentDiscoveryService {
 export interface A2aDiscoveryReadyService {
     /**
      * Triggers `A2aAgentDiscoveryService.discover()` if not already
-     * started for the current config, and awaits it. Idempotent and safe
-     * to call from every A2A tool's guard — concurrent callers await the
-     * same in-flight fetch rather than each starting their own.
+     * started, and awaits it. Idempotent and safe to call from every A2A
+     * tool's guard — concurrent callers await the same in-flight fetch
+     * rather than each starting their own.
      */
     waitForDiscovery(): Promise<void>;
     /**
      * Drop the cached in-flight/completed fetch so the NEXT `waitForDiscovery()`
-     * call triggers a fresh `discover()`. Call this whenever
-     * `A2aAgentDiscoveryService.setConfig()` changes the config (a new
-     * `initialize` control_request with a different `remoteAgentsConfig`,
-     * or one that clears it) — otherwise a process that got its discovery
-     * URL rotated mid-session would keep serving the stale, already-fetched
-     * agent list forever.
+     * call triggers a fresh `discover()`. Test/process-teardown use — in
+     * production there is exactly one discovery source per process
+     * lifetime (issue #99451 Part B: `CODEBUDDY_REMOTE_AGENTS_URL` is a
+     * process-env value, not something that changes mid-session), so
+     * nothing in the normal request path calls this anymore.
      */
     reset(): void;
 }
@@ -245,7 +224,17 @@ export interface A2aSendMessageResult {
     /** Raw SDK response, retained for `ToolResult.rawResponse` (diagnostics only, never shown raw to the model). */
     raw: unknown;
 }
-export type A2aTaskStatus = 'submitted' | 'working' | 'completed' | 'failed' | 'canceled' | 'rejected' | 'input-required' | 'auth-required';
+export type A2aTaskStatus = 'submitted' | 'working' | 'completed' | 'failed' | 'canceled' | 'rejected' | 'input-required' | 'auth-required'
+/**
+ * The wire's `TASK_STATE_UNSPECIFIED` (a legal, spec-defined "unknown or
+ * indeterminate state" per the A2A `TaskState` enum) or an enum value this
+ * SDK version doesn't recognize yet (`TaskState.UNRECOGNIZED`) — NOT an
+ * agent-cli-side error. Non-terminal: `A2AGetTaskTool` keeps polling
+ * through it exactly like `submitted`/`working`, on the theory that a
+ * spec-compliant remote agent reporting this will eventually resolve to a
+ * real state.
+ */
+ | 'unknown';
 export interface A2aArtifactSummary {
     name?: string;
     mediaType?: string;
@@ -273,16 +262,20 @@ export interface A2aTaskSnapshot {
 /**
  * Thin wrapper around `@a2a-js/sdk`'s `ClientFactory` + `Client`. Owns the
  * per-`agentId` `Client` cache so repeated calls to the same agent within the
- * process lifetime reuse the negotiated transport. Phase 1 scope: `sendMessage`
- * blocks until a terminal/interrupted state; `getTask`/`cancelTask` are single
- * point-in-time calls (no polling loop, no `sendMessageStream`/`subscribeToTask`).
+ * process lifetime reuse the negotiated transport. `sendMessage`/`getTask`/
+ * `cancelTask` are each a single RPC call — whatever status the remote agent
+ * returns (terminal or not) is returned as-is, unmodified; no polling loop
+ * and no `sendMessageStream`/`subscribeToTask` live here (issue #99451 Phase
+ * 2: the poll loop for a non-terminal task lives exclusively in
+ * `A2AGetTaskTool`, one layer up — see that tool's doc comment).
  */
 export interface A2aClientService {
     /**
-     * Send a message to `agentId` (optionally targeting `skillId`) and block
-     * until a terminal or interrupted (`input-required`/`auth-required`)
-     * state is reached. `contextId`/`taskId` are supplied by the caller to
-     * continue a prior turn; omit both to start a new task/context.
+     * Send a message to `agentId` (optionally targeting `skillId`) and
+     * return whatever the single `message/send` RPC call gets back —
+     * terminal, `working`, `input-required`, anything — unmodified.
+     * `contextId`/`taskId` are supplied by the caller to continue a prior
+     * turn; omit both to start a new task/context.
      */
     sendMessage(agentId: string, params: {
         text: string;

package/dist-server/types/node/control-signal/control-signal-protocol.d.ts

@@ -120,35 +120,6 @@ export interface SdkCapabilities {
         form?: boolean;
     };
 }
-/**
- * Host-managed authentication reference for the outbound A2A discovery
- * endpoint. Headers are forwarded on the discovery fetch itself AND reused
- * for every discovered agent's own `sendMessage`/`getTask`/`cancelTask`
- * calls (raw A2A `AgentCard`s carry no credentials of their own — see
- * `RemoteAgentsConfig`'s doc comment) — never exposed to the model (not in
- * tool schemas, prompts, or logs).
- */
-export interface RemoteAgentsAuthConfig {
-    headers?: Record<string, string>;
-}
-/**
- * Outbound A2A agent discovery source, supplied by a trusted host (e.g.
- * CloudAgent) at session start via the SDK `initialize` control_request.
- * Replaces the old inline `a2aAgents` array (issue #99451 Phase 1): instead
- * of the host pushing a fully-resolved agent list, it hands the CLI ONE
- * discovery URL that returns a plain array of standard A2A v1.0 `AgentCard`
- * objects (no host-specific wrapper shape) — the CLI fetches it itself,
- * lazily, on first A2A tool use (see `A2aAgentDiscoveryService`).
- *
- * `agentId` (the stable key used in `@Agent`/`@Agent.Skill` routing) is
- * derived from each card's own `name` field, since a standard `AgentCard`
- * has no separate host-assigned identifier.
- */
-export interface RemoteAgentsConfig {
-    /** Discovery endpoint. Expected to return a JSON array of A2A v1.0 AgentCard objects. */
-    url: string;
-    auth?: RemoteAgentsAuthConfig;
-}
 /**
  * 初始化请求
  */
@@ -168,13 +139,6 @@ export interface ControlInitializeRequest {
     capabilities?: SdkCapabilities;
     /** 是否有 prompt 将在初始化后发送（用于 resume 时决定是否回放历史） */
     hasPrompt?: boolean;
-    /**
-     * 出站 A2A agent 发现源（CloudAgent 一期：仅同步出站调用）。由 AbTestService 的
-     * `ProductFeature.A2AOutbound` 端到端门控；关闭时完全忽略此字段，不发起任何
-     * 网络请求。真正的 fetch 发生在模型首次调用任一 A2A 工具时（懒加载），initialize
-     * 握手本身只存配置，不阻塞在网络 I/O 上。
-     */
-    remoteAgentsConfig?: RemoteAgentsConfig;
 }
 /**
  * 初始化响应

package/dist-server/types/node/tools/a2a-get-task-tool.d.ts

@@ -1,7 +1,9 @@
 import { AbTestService } from '@genie/product';
+import { Logger } from '@genie/telemetry';
 import { RunContext } from '@openai/agents';
 import { z } from 'zod';
 import { A2aAgentRegistry, A2aClientService, A2aDiscoveryReadyService } from '../a2a/a2a-protocol';
+import { FunctionCallItem } from '../agent/openai-agents-types';
 import { Session } from '../session/session-protocol';
 import { BaseTool } from './base-tool';
 import { Tool, ToolCallArgumentRenderer, ToolNames, ToolResult } from './tool-protocol';
@@ -15,13 +17,46 @@ declare const A2AGetTaskParameters: z.ZodObject<{
     agent_id: string;
     task_id: string;
 }>;
+export declare const ENV_POLL_INTERVAL_MS = "CODEBUDDY_A2A_POLL_INTERVAL_MS";
+export declare const ENV_POLL_BACKOFF_MULTIPLIER = "CODEBUDDY_A2A_POLL_BACKOFF_MULTIPLIER";
+export declare const ENV_POLL_MAX_INTERVAL_MS = "CODEBUDDY_A2A_POLL_MAX_INTERVAL_MS";
+export declare const ENV_POLL_MAX_ATTEMPTS = "CODEBUDDY_A2A_POLL_MAX_ATTEMPTS";
+export declare const ENV_POLL_MAX_DURATION_MS = "CODEBUDDY_A2A_POLL_MAX_DURATION_MS";
+export interface A2APollPolicy {
+    /** Initial poll interval, ms. Default 2s. */
+    initialIntervalMs: number;
+    /** Exponential backoff multiplier applied after each poll. Default 1.5x. */
+    backoffMultiplier: number;
+    /** Interval cap the backoff schedule never exceeds. Default 30s. */
+    maxIntervalMs: number;
+    /** Hard cap on poll attempts — a secondary, independent circuit breaker from `maxDurationMs`. Default 60. */
+    maxAttempts: number;
+    /** Overall wall-clock budget for the whole loop, ms. Default 15 minutes. */
+    maxDurationMs: number;
+}
+/**
+ * Resolve the effective poll policy, applying any env overrides on top of
+ * `DEFAULT_POLL_POLICY`. Read fresh on every `execute()` call — not cached
+ * — so a test/host can change the env between calls.
+ */
+export declare function resolvePollPolicy(): A2APollPolicy;
 /**
- * A2AGetTask — retrieve the current state of a previously created A2A task
- * (issue #99451, CloudAgent Phase 1). Single point-in-time query, not a
- * polling loop: the model calls this again itself if it wants a fresher
- * snapshot later. Reconciles a task whose status the caller didn't act on
- * immediately, or checks on a task the remote agent is still working on
- * after an earlier `input-required`/`auth-required` response.
+ * A2AGetTask — wait for a previously created outbound A2A task to finish
+ * (issue #99451 CloudAgent Phase 1; Phase 2 revises this from a bare
+ * single-shot query into the tool that owns the ENTIRE bounded, streamed
+ * poll loop — see the design doc's "A.7 Tool ownership split" section).
+ *
+ * Every non-terminal status — including `input-required`/`auth-required` —
+ * is relayed (A.2's live-progress mechanism, reusing the foreground Bash
+ * tool's `session.inputSubject.next({status: 'in_progress', ...})` pattern)
+ * and polled straight through with exponential backoff (A.3), never treated
+ * as a stop condition (A.5): the remote agent's own resolution path for
+ * those states (e.g. a WeCom approval card) is out of band from agent-cli
+ * entirely, so there is nothing for this tool to pause and ask the model
+ * about. Only the 4 true terminal states (`completed`/`failed`/`canceled`/
+ * `rejected`) or one of the two independent circuit breakers
+ * (`maxAttempts`/`maxDurationMs`, both env-overridable — see
+ * `resolvePollPolicy()`) stop the loop.
  *
  * Restricted to the main session, same recursive-delegation guard as
  * `A2ASendMessageTool` (see that tool's doc comment).
@@ -31,6 +66,7 @@ export declare class A2AGetTaskTool extends BaseTool implements Tool {
     protected readonly client?: A2aClientService;
     protected readonly abTestService?: AbTestService;
     protected readonly discoveryReadyService?: A2aDiscoveryReadyService;
+    protected readonly logger: Logger;
     name: ToolNames;
     description: string;
     needsApproval: boolean;
@@ -48,6 +84,46 @@ export declare class A2AGetTaskTool extends BaseTool implements Tool {
     isEnabled: (args: {
         runContext: RunContext<Session>;
     }) => Promise<boolean>;
-    execute(input: z.infer<typeof A2AGetTaskParameters>, context: RunContext<Session>): Promise<ToolResult>;
+    execute(input: z.infer<typeof A2AGetTaskParameters>, context: RunContext<Session>, details?: {
+        toolCall: FunctionCallItem;
+    }): Promise<ToolResult>;
+    private pollOnce;
+    /**
+     * A.2's live-progress relay — the SAME `session.inputSubject.next({...})`
+     * shape the foreground Bash tool uses for its own streaming updates
+     * (`bash-tool.ts`'s `updateToolResult()`), reusing the tool call's own
+     * `callId` and a single `streamingResultId` held for the whole loop.
+     * `providerData.toolResult.rawResponse.a2a` carries the FULL snapshot
+     * (including `snapshot.raw`'s structured `parts`/`metadata`), not just
+     * the derived text — required for a frontend that knows how to render a
+     * structured interrupt payload (e.g. a WeCom `wecom_part_type: 'approval'`
+     * card, see A.2) to have the data it needs.
+     *
+     * **Also pushes the SAME item to `session.combineSubject`** — traced
+     * empirically (issue #99451 Phase 2 e2e work) that `inputSubject.next()`
+     * alone, exactly as Bash's own `updateToolResult()` does it, never
+     * reaches either transport's actual subscription: both
+     * `stream-json-view.ts` and `acp-agent.ts` subscribe ONLY to
+     * `session.combineSubject` (`{type: 'input', data: item}`), and nothing
+     * bridges `inputSubject` into `combineSubject` except
+     * `SessionManager.addHistory()`'s explicit dual-push for REAL history
+     * items — which a live, ephemeral, non-terminal relay frame like this
+     * one deliberately is not (it's never persisted to `session.history`).
+     * Confirmed live: Bash's OWN in-progress streaming updates do NOT
+     * currently reach stream-json `-p` output either (only its terminal
+     * result does) — that's a pre-existing gap in `bash-tool.ts`, out of
+     * scope to fix here, but exactly why this method can't just copy Bash's
+     * `inputSubject`-only call and call it done: A.2's actual requirement is
+     * multiple live relay frames on BOTH transports, so this pushes to both
+     * subjects explicitly rather than reproducing that gap.
+     */
+    private relayProgress;
+    /**
+     * Fallback result when a circuit breaker (not a terminal status) stops
+     * the loop. Per A.5: surfaces the last observed status/clarification —
+     * useful context even though it wasn't treated as a stop condition, the
+     * loop stopped because of the budget, not because of an interrupt.
+     */
+    private buildBudgetExceededResult;
 }
 export {};

package/dist-server/types/node/tools/a2a-send-message-tool.d.ts

@@ -1,4 +1,5 @@
 import { AbTestService } from '@genie/product';
+import { Logger } from '@genie/telemetry';
 import { RunContext } from '@openai/agents';
 import { z } from 'zod';
 import { A2aAgentRegistry, A2aClientService, A2aDiscoveryReadyService } from '../a2a/a2a-protocol';
@@ -20,9 +21,14 @@ declare const A2ASendMessageParameters: z.ZodObject<{
 }>;
 export declare function continuationKey(agentId: string, skillId: string | undefined): string;
 /**
- * A2ASendMessage — invoke one outbound A2A agent synchronously (issue #99451,
- * CloudAgent Phase 1). Foreground call: blocks until the remote agent
- * reaches a terminal or interrupted state, then returns.
+ * A2ASendMessage — invoke one outbound A2A agent (issue #99451 CloudAgent
+ * Phase 1; ownership split revised in Phase 2, see the design doc's "A.7
+ * Tool ownership split" section). Single, non-looping RPC call: makes
+ * exactly one `message/send` request and returns whatever it gets back to
+ * the model UNMODIFIED — terminal, `working`, `input-required`, anything.
+ * No polling, no streaming, no waiting for a terminal state — that's
+ * `A2AGetTaskTool`'s job (see its doc comment), which this tool's own
+ * description tells the model to call when the result isn't final.
  *
  * Restricted to the main session: subagent/team sessions never see this tool
  * enabled, which is the enforcement point that prevents A2A-triggered
@@ -36,6 +42,7 @@ export declare class A2ASendMessageTool extends BaseTool implements Tool {
     protected readonly client?: A2aClientService;
     protected readonly abTestService?: AbTestService;
     protected readonly discoveryReadyService?: A2aDiscoveryReadyService;
+    protected readonly logger: Logger;
     name: ToolNames;
     description: string;
     needsApproval: boolean;

package/dist-server/types/node/tools/a2a-tool-guards.d.ts

@@ -1,4 +1,5 @@
 import { AbTestService } from '@genie/product';
+import type { Logger } from '@genie/telemetry';
 import { A2aAgentRegistry, A2aDiscoveryReadyService, A2aRegisteredAgent } from '../a2a/a2a-protocol';
 import { Session } from '../session/session-protocol';
 import { ToolErrorCode } from './tool-error-codes';
@@ -28,7 +29,7 @@ export declare function isSubSession(session: Session | undefined): boolean;
  * assembled (e.g. a headless build without the A2A feature), matching this
  * function's existing tolerance for missing components via `hasRequiredComponents`.
  */
-export declare function assertA2AToolAllowed(hasRequiredComponents: boolean, session: Session | undefined, abTestService: AbTestService | undefined, discoveryReadyService?: A2aDiscoveryReadyService): Promise<void>;
+export declare function assertA2AToolAllowed(hasRequiredComponents: boolean, session: Session | undefined, abTestService: AbTestService | undefined, discoveryReadyService?: A2aDiscoveryReadyService, logger?: Pick<Logger, 'debug'>): Promise<void>;
 /** Look up `agentId` in the registry, throwing a consistent "not registered" error (with the list of available agents) if missing. */
 export declare function requireA2AAgent(registry: A2aAgentRegistry, agentId: string): A2aRegisteredAgent;
 /** Classify a thrown A2aClientService error into the right ToolErrorCode by matching known message patterns (see a2a-client-service.ts's doc comment on why we match text rather than `instanceof` typed SDK errors — this SDK version's JSON-RPC transport doesn't reconstruct semantic error subclasses). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tencent-ai/codebuddy-code",
-  "version": "2.139.0-dev.c47174a.202608271521",
+  "version": "2.139.0-dev.d4a09ae.202608281607",
   "description": "Use CodeBuddy, Tencent's AI assistant, right from your terminal. CodeBuddy can understand your codebase, edit files, run terminal commands, and handle entire workflows for you.",
   "main": "lib/node/index.js",
   "typings": "lib/node/index.d.ts",

package/product.cloudhosted.json

@@ -824,6 +824,6 @@
     "SelectImage": true,
     "SkipToolCallSupportCheck": true
   },
-  "commit": "c47174a63599a2d8644e6898d361d06ff662631e",
-  "date": "2026-08-27T07:20:10.926Z"
+  "commit": "d4a09ae479e13e4ffdc70d77b5f1bd584aeb6128",
+  "date": "2026-08-28T08:06:20.634Z"
 }

package/product.internal.json

@@ -831,6 +831,6 @@
       }
     }
   },
-  "commit": "c47174a63599a2d8644e6898d361d06ff662631e",
-  "date": "2026-08-27T07:20:10.988Z"
+  "commit": "d4a09ae479e13e4ffdc70d77b5f1bd584aeb6128",
+  "date": "2026-08-28T08:06:20.692Z"
 }

package/product.ioa.json

@@ -1327,6 +1327,6 @@
       }
     }
   },
-  "commit": "c47174a63599a2d8644e6898d361d06ff662631e",
-  "date": "2026-08-27T07:20:10.911Z"
+  "commit": "d4a09ae479e13e4ffdc70d77b5f1bd584aeb6128",
+  "date": "2026-08-28T08:06:20.622Z"
 }

package/product.json

@@ -1239,6 +1239,22 @@
       "name": "tool-deferexecutetool-description",
       "template": "Execute a deferred tool by name. Use this to invoke tools discovered via ToolSearch without needing them in the active tools list.\n\nUsage:\n- First use ToolSearch to discover a tool and learn its parameter schema\n- Then call this tool with the exact tool name and parameters\n- Parameters are validated against the tool's schema before execution\n- The target tool's permission checks and hooks are applied normally\n\nExample:\nDeferExecuteTool({ toolName: \"ImageGen\", params: { prompt: \"a sunset over mountains\" } })\n\nNotes:\n- If parameter validation fails, a detailed error with the expected schema is returned\n- You can skip ToolSearch if you already know the tool name and parameters from a previous turn\n- This tool follows standard permission checks (may require approval depending on permissions configuration)\n"
     },
+    {
+      "name": "tool-a2aagentsearch-description",
+      "template": "Search for outbound A2A (Agent2Agent) agents authorized for this conversation.\n\nUse this to discover which agents are available before calling A2ASendMessage:\n- Pass `query` with a natural-language description of the task (\"translate a document\", \"look up an order status\") to search by name/description/skill.\n- Pass `agent_id` to look up one agent directly when you already know its exact id (e.g. from an explicit @Agent mention).\n- Omit both to list every agent currently authorized.\n\nResults include each agent's `agent_id`, name, description, and declared skills (with their own `id`/name/description). A `supports_skill_routing` flag tells you whether `A2ASendMessage`'s `skill_id` parameter will actually be honored by that agent — if false, send the task as a plain message and let the agent dispatch it itself.\n\nThis tool never contacts the network; it only reads the agents registered for this session.\n"
+    },
+    {
+      "name": "tool-a2asendmessage-description",
+      "template": "Send a message to one outbound A2A (Agent2Agent) agent authorized for this conversation.\n\nParameters:\n- `agent_id` (required): exact id from A2AAgentSearch or an explicit @Agent mention.\n- `message` (required): a concise, self-contained task or question. Do not paste the whole conversation — state the goal and only the context the agent actually needs (the agent has no visibility into this conversation otherwise).\n- `skill_id` (optional): route directly to one declared skill, for @Agent.Skill-style precise dispatch. Only effective when A2AAgentSearch reported `supports_skill_routing: true` for that agent; otherwise this is ignored.\n\nThis call is NOT synchronous: it returns immediately with whatever single reply the agent gave, and does not wait for the task to finish. Check the returned status: only completed/failed/canceled/rejected are final. For ANY other status — working, submitted, input-required, or auth-required — you MUST immediately call A2AGetTask with the returned task_id, in the same turn, before doing anything else with this task. Do not wait, and do not ask the user for permission first.\n\nauth-required and input-required are NOT a signal to stop and hand off to the user by themselves — calling A2AGetTask to check status is just reading state, not performing a login or filling credentials on the user's behalf, so it does not conflict with any policy against automating logins. A2AGetTask polls automatically with backoff, relays the agent's own request (e.g. \"please sign in\", a clarifying question) to the user exactly once, and keeps waiting for the remote task to advance — it will surface the eventual outcome once the user (or the agent) resolves whatever it was waiting on.\n\nBehavior notes:\n- Calling the same `agent_id` (and `skill_id`, if used) again in a later turn continues the same conversation with that agent automatically — you don't need to restate prior context.\n- To message multiple agents in one turn, call this tool once per agent as parallel tool calls — one agent failing does not affect the others.\n- Any files or links the agent produced are returned as part of the result text.\n- Not available inside a sub-agent or team-member session — only the main conversation can call outbound A2A agents.\n"
+    },
+    {
+      "name": "tool-a2agettask-description",
+      "template": "Wait for a previously created outbound A2A task to finish, polling automatically.\n\nParameters:\n- `agent_id` (required): the same agentId passed to the original A2ASendMessage call.\n- `task_id` (required): the taskId from a prior A2ASendMessage or A2AGetTask result.\n\nThis call polls the remote task's real, current state with backoff, showing live progress as it goes, up to a bounded time/attempt limit. It returns once the task reaches a final state (completed/failed/canceled/rejected), or a \"still running\" result if the bound is hit first — if you get \"still running\", immediately call A2AGetTask again with the same task_id to keep waiting; do not give up after one bounded call.\n\nIf the task is waiting on external input or auth (input-required/auth-required), that request is relayed to the user once and polling continues with backoff — the next call/round of polling reflects the task's real state at that later point in time, not a repeat of what you already saw. Checking status this way is just reading state, not performing a login or filling credentials on the user's behalf, so calling this while the task is waiting on the user to complete a login/approval step out of band does not conflict with any policy against automating logins.\n\nNot available inside a sub-agent or team-member session — only the main conversation can query outbound A2A tasks.\n"
+    },
+    {
+      "name": "tool-a2acanceltask-description",
+      "template": "Request cancellation of a previously created outbound A2A task.\n\nParameters:\n- `agent_id` (required): the same agentId passed to the original A2ASendMessage call.\n- `task_id` (required): the taskId from a prior A2ASendMessage or A2AGetTask result.\n\nCancellation is a best-effort request, not a guarantee. If the task has already reached a terminal state (completed/failed/canceled/rejected), the call fails and the tool result will say so — that is expected, not an error to retry. Use A2AGetTask if you need to check the task's status before deciding whether to cancel it.\n\nNot available inside a sub-agent or team-member session — only the main conversation can cancel outbound A2A tasks.\n"
+    },
     {
       "name": "tool-describetool-description",
       "template": "Get detailed information about a specific tool by name.\n\nUse this when you already know the tool name and need its full definition (description and input schema). This is more efficient than searching when the tool name is known.\n\nUsage:\n- Provide the exact tool name (case-sensitive)\n- Returns the tool's full description and parameter schema\n- The tool is automatically activated for use in subsequent messages\n\nIf the tool is not found, consider using ToolSearch to discover available tools by description.\n"
@@ -2197,25 +2213,21 @@
     },
     {
       "name": "A2AAgentSearch",
-      "description": "tool-a2aagentsearch-description",
-      "deferLoading": true
+      "description": "tool-a2aagentsearch-description"
     },
     {
       "name": "A2ASendMessage",
-      "description": "tool-a2asendmessage-description",
-      "deferLoading": true
+      "description": "tool-a2asendmessage-description"
     },
     {
       "name": "A2AGetTask",
-      "description": "tool-a2agettask-description",
-      "deferLoading": true
+      "description": "tool-a2agettask-description"
     },
     {
       "name": "A2ACancelTask",
-      "description": "tool-a2acanceltask-description",
-      "deferLoading": true
+      "description": "tool-a2acanceltask-description"
     }
   ],
-  "commit": "c47174a63599a2d8644e6898d361d06ff662631e",
-  "date": "2026-08-27T07:20:10.911Z"
+  "commit": "d4a09ae479e13e4ffdc70d77b5f1bd584aeb6128",
+  "date": "2026-08-28T08:06:20.642Z"
 }

package/product.selfhosted.json

@@ -361,6 +361,6 @@
     "ScheduledTasks": true,
     "SkipToolCallSupportCheck": true
   },
-  "commit": "c47174a63599a2d8644e6898d361d06ff662631e",
-  "date": "2026-08-27T07:20:10.978Z"
+  "commit": "d4a09ae479e13e4ffdc70d77b5f1bd584aeb6128",
+  "date": "2026-08-28T08:06:20.646Z"
 }