@armadra/agent 0.0.0-stage → 0.3.0

package/dist/agent/session-state.d.ts

@@ -0,0 +1,39 @@
+/**
+ * SessionState 快照与统计（设计 §1.2 session-state.ts、§12.6 状态栏）。[B2]
+ *
+ * 统计口径：活动分支上的全部条目（不是投影）——被压缩 / 剔除的消息仍计入用量与成本；
+ * 压缩与分支摘要请求的 usage 也计入；`usage` 条目（缓存保温等不进上下文的请求，第三波 §1.7）
+ * 计入 token 与费用但不算消息。上下文 % 用投影感知估算（§9）。
+ */
+import type { Model, ModelThinkingLevel } from "../ai/types.js";
+import type { PermissionMode } from "../permissions/types.js";
+import type { SessionManager } from "../session/manager.js";
+import type { SessionEntry } from "../session/types.js";
+import type { Agent } from "./agent.js";
+import type { SessionCacheStats, SessionState, SessionStats } from "./types.js";
+export interface StateInput {
+    agent: Agent;
+    manager: SessionManager;
+    model: Model;
+    thinkingLevel: ModelThinkingLevel;
+    permissionMode: PermissionMode;
+    isCompacting: boolean;
+    isRetrying: boolean;
+    autoCompaction: boolean;
+    autoRetry: boolean;
+}
+export declare function buildSessionState(input: StateInput): SessionState;
+export interface StatsInput {
+    sessionId: string;
+    sessionFile: string | undefined;
+    branch: readonly SessionEntry[];
+    contextTokens: number | undefined;
+    contextWindow: number | undefined;
+    /** [W3-C1b] 会话层缓存控制器的统计（未接线时缺省）。 */
+    cache?: SessionCacheStats;
+}
+export declare function computeStats(input: StatsInput): SessionStats;
+/** 缓存命中率 = cacheRead /（input + cacheRead + cacheWrite）；分母为 0 → undefined（设计 §9.1）。 */
+export declare function cacheHitRate(tokens: Pick<SessionStats["tokens"], "input" | "cacheRead" | "cacheWrite">): number | undefined;
+/** 最后一条有文本的助手消息（error / aborted 也算，供 UI 显示失败原因前的部分输出）。 */
+export declare function lastAssistantText(branch: readonly SessionEntry[]): string | null;

package/dist/agent/session-state.js

@@ -0,0 +1,119 @@
+/**
+ * SessionState 快照与统计（设计 §1.2 session-state.ts、§12.6 状态栏）。[B2]
+ *
+ * 统计口径：活动分支上的全部条目（不是投影）——被压缩 / 剔除的消息仍计入用量与成本；
+ * 压缩与分支摘要请求的 usage 也计入；`usage` 条目（缓存保温等不进上下文的请求，第三波 §1.7）
+ * 计入 token 与费用但不算消息。上下文 % 用投影感知估算（§9）。
+ */
+import { modelRefOf } from "../ai/providers/channels.js";
+export function buildSessionState(input) {
+    const { agent, manager, model } = input;
+    return {
+        isStreaming: agent.isRunning,
+        isCompacting: input.isCompacting,
+        isRetrying: input.isRetrying,
+        model: modelRefOf(model),
+        thinkingLevel: input.thinkingLevel,
+        permissionMode: input.permissionMode,
+        sessionId: manager.id,
+        sessionFile: manager.file(),
+        cwd: manager.cwd,
+        sessionName: manager.name(),
+        messageCount: agent.messages.filter((message) => message.role !== "system").length,
+        pendingMessageCount: agent.steeringQueue.size + agent.followUpQueue.size,
+        steeringMode: agent.steeringQueue.mode,
+        followUpMode: agent.followUpQueue.mode,
+        autoCompaction: input.autoCompaction,
+        autoRetry: input.autoRetry,
+    };
+}
+function addUsage(totals, usage) {
+    totals.input += usage.input;
+    totals.output += usage.output;
+    totals.cacheRead += usage.cacheRead;
+    totals.cacheWrite += usage.cacheWrite;
+    totals.total +=
+        usage.totalTokens > 0
+            ? usage.totalTokens
+            : usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
+}
+export function computeStats(input) {
+    const tokens = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 };
+    let userMessages = 0;
+    let assistantMessages = 0;
+    let toolCalls = 0;
+    let toolResults = 0;
+    let cost = 0;
+    const addCost = (usage) => {
+        if (cost === undefined)
+            return;
+        cost = usage.cost === undefined ? undefined : cost + usage.cost.total;
+    };
+    for (const entry of input.branch) {
+        if (entry.type === "message") {
+            const { message } = entry;
+            if (message.role === "user")
+                userMessages++;
+            else if (message.role === "toolResult")
+                toolResults++;
+            else if (message.role === "assistant") {
+                assistantMessages++;
+                toolCalls += message.content.filter((block) => block.type === "toolCall").length;
+                addUsage(tokens, message.usage);
+                addCost(message.usage);
+            }
+        }
+        else if (entry.type === "usage") {
+            addUsage(tokens, entry.usage);
+            addCost(entry.usage);
+        }
+        else if ((entry.type === "compaction" || entry.type === "branch_summary") && entry.usage) {
+            addUsage(tokens, entry.usage);
+            addCost(entry.usage);
+        }
+    }
+    const contextPercent = input.contextWindow === undefined ||
+        input.contextTokens === undefined ||
+        input.contextWindow <= 0
+        ? undefined
+        : Math.min(100, Math.round((input.contextTokens / input.contextWindow) * 1000) / 10);
+    const stats = {
+        sessionId: input.sessionId,
+        sessionFile: input.sessionFile,
+        userMessages,
+        assistantMessages,
+        toolCalls,
+        toolResults,
+        tokens,
+        cost,
+        contextTokens: input.contextTokens,
+        contextWindow: input.contextWindow,
+        contextPercent,
+    };
+    const rate = cacheHitRate(tokens);
+    if (rate !== undefined)
+        stats.cacheHitRate = rate;
+    if (input.cache !== undefined)
+        stats.cache = input.cache;
+    return stats;
+}
+/** 缓存命中率 = cacheRead /（input + cacheRead + cacheWrite）；分母为 0 → undefined（设计 §9.1）。 */
+export function cacheHitRate(tokens) {
+    const denominator = tokens.input + tokens.cacheRead + tokens.cacheWrite;
+    return denominator > 0 ? tokens.cacheRead / denominator : undefined;
+}
+/** 最后一条有文本的助手消息（error / aborted 也算，供 UI 显示失败原因前的部分输出）。 */
+export function lastAssistantText(branch) {
+    for (let i = branch.length - 1; i >= 0; i--) {
+        const entry = branch[i];
+        if (entry?.type !== "message" || entry.message.role !== "assistant")
+            continue;
+        const text = entry.message.content
+            .filter((block) => block.type === "text")
+            .map((block) => block.text)
+            .join("");
+        if (text.trim() !== "")
+            return text;
+    }
+    return null;
+}

package/dist/agent/session-subagent.d.ts

@@ -0,0 +1,54 @@
+/**
+ * 子 Agent（设计 §5.2 task、D14）：`ToolContext.spawnSubagent` 的实现，供 B3 的 task 工具调用。[B2]
+ *
+ * - 同进程新会话：独立 JSONL（头的 parentSession 指回父文件；父为内存会话则子也在内存），首条
+ *   `custom{customType:"ama.task"}` 记父 toolCallId。
+ * - 深度 ≤ 1（子会话 depth 1、无 spawnSubagent）；并发 ≤ 4（排队等待）。
+ * - 工具子集缺省 = 父的活动集，总是去掉 task；继承父的权限管线、Hook 与系统提示静态部分；
+ *   broker 包一层，请求带 `context{depth, parentToolCallId}`，审批事件转发到父会话。
+ * - 父 abort 级联；结果 = 子的最后助手文本 + 用量 + 子会话文件。
+ * - [W3-C1b] 子会话有自己的缓存控制器（统计独立、未命中不进父链，`warmSubagents` 为 false 时
+ *   不保温）；结果带 `cache{hitRate, reBilledTokens}`，并汇总进父会话的「子任务」统计。
+ */
+import { SessionManager } from "../session/manager.js";
+import type { SubagentRequest, SubagentResult } from "../tools/types.js";
+import type { AgentSessionOptions } from "./session-core.js";
+import type { SessionEvent, SessionStats } from "./types.js";
+export declare const DEFAULT_SUBAGENT_CONCURRENCY = 4;
+export declare const DEFAULT_SUBAGENT_MAX_TURNS = 30;
+export declare const TASK_CUSTOM_TYPE = "ama.task";
+/** 计数信号量。 */
+export declare class SubagentPool {
+    private readonly limit;
+    private running;
+    private readonly waiters;
+    constructor(limit: number);
+    acquire(signal: AbortSignal): Promise<void>;
+    release(): void;
+}
+export interface SubagentParent {
+    readonly options: AgentSessionOptions;
+    readonly manager: SessionManager;
+    readonly cwd: string;
+    readonly depth: number;
+    childBase(): Pick<AgentSessionOptions, "model" | "thinkingLevel" | "activeTools" | "system">;
+    /** 子会话的审批事件转发给父会话的订阅者（RPC 客户端 / TUI 据此作答）。 */
+    emit?(event: SessionEvent): void;
+    /** [W3-C1b] 父会话的缓存控制器：汇总子会话的命中与重计费。 */
+    readonly cache?: {
+        addSubagent(tokens: {
+            cacheRead: number;
+            prompt: number;
+        }, reBilledTokens: number): void;
+    };
+}
+export interface ChildSession {
+    readonly manager: SessionManager;
+    prompt(text: string): Promise<unknown>;
+    abort(): Promise<void>;
+    subscribe(listener: (event: SessionEvent) => void): () => void;
+    getStats(): SessionStats;
+    getLastAssistantText(): string | null;
+    dispose(): Promise<void>;
+}
+export declare function runSubagent(parent: SubagentParent, request: SubagentRequest, pool: SubagentPool, createChild: (options: AgentSessionOptions) => ChildSession): Promise<SubagentResult>;

package/dist/agent/session-subagent.js

@@ -0,0 +1,157 @@
+/**
+ * 子 Agent（设计 §5.2 task、D14）：`ToolContext.spawnSubagent` 的实现，供 B3 的 task 工具调用。[B2]
+ *
+ * - 同进程新会话：独立 JSONL（头的 parentSession 指回父文件；父为内存会话则子也在内存），首条
+ *   `custom{customType:"ama.task"}` 记父 toolCallId。
+ * - 深度 ≤ 1（子会话 depth 1、无 spawnSubagent）；并发 ≤ 4（排队等待）。
+ * - 工具子集缺省 = 父的活动集，总是去掉 task；继承父的权限管线、Hook 与系统提示静态部分；
+ *   broker 包一层，请求带 `context{depth, parentToolCallId}`，审批事件转发到父会话。
+ * - 父 abort 级联；结果 = 子的最后助手文本 + 用量 + 子会话文件。
+ * - [W3-C1b] 子会话有自己的缓存控制器（统计独立、未命中不进父链，`warmSubagents` 为 false 时
+ *   不保温）；结果带 `cache{hitRate, reBilledTokens}`，并汇总进父会话的「子任务」统计。
+ */
+import { AmaError } from "../errors.js";
+import { SessionManager } from "../session/manager.js";
+import { ZERO_USAGE } from "./loop.js";
+export const DEFAULT_SUBAGENT_CONCURRENCY = 4;
+export const DEFAULT_SUBAGENT_MAX_TURNS = 30;
+export const TASK_CUSTOM_TYPE = "ama.task";
+/** 计数信号量。 */
+export class SubagentPool {
+    limit;
+    running = 0;
+    waiters = [];
+    constructor(limit) {
+        this.limit = limit;
+    }
+    async acquire(signal) {
+        while (this.running >= this.limit) {
+            if (signal.aborted)
+                throw new AmaError("aborted", "aborted");
+            await new Promise((resolve) => this.waiters.push(resolve));
+        }
+        this.running++;
+    }
+    release() {
+        this.running--;
+        this.waiters.shift()?.();
+    }
+}
+/** 子会话的 broker：请求带上发起方上下文（对话框标 `[task]`），其余原样交给父链。 */
+function brokersForChild(brokers, context) {
+    return (brokers ?? []).map((broker) => ({
+        ask: (request, signal) => broker.ask({ ...request, context }, signal),
+    }));
+}
+function failed(text) {
+    return { text, usage: { ...ZERO_USAGE }, stopReason: "error", isError: true };
+}
+export async function runSubagent(parent, request, pool, createChild) {
+    if (parent.depth > 0)
+        return failed("subagents cannot spawn subagents");
+    await pool.acquire(request.signal);
+    try {
+        const base = parent.childBase();
+        let model = base.model;
+        if (request.model !== undefined) {
+            const lookup = parent.options.providers.findModel(request.model);
+            if (!lookup.ok)
+                return failed(`unknown model ${request.model}`);
+            model = lookup.model;
+        }
+        const parentFile = parent.manager.file();
+        const headerOptions = parentFile === undefined ? {} : { parentSession: parentFile };
+        const dir = parent.manager.directory();
+        const childManager = dir === undefined
+            ? SessionManager.inMemory(parent.cwd, headerOptions)
+            : SessionManager.create(dir, parent.cwd, headerOptions);
+        childManager.append({
+            type: "custom",
+            customType: TASK_CUSTOM_TYPE,
+            data: {
+                parentToolCallId: request.parentToolCallId,
+                description: request.description,
+                parentSession: parentFile,
+            },
+        });
+        const available = new Set((parent.options.tools ?? []).map((tool) => tool.name));
+        const names = (request.tools ?? base.activeTools ?? [...available]).filter((name) => name !== "task" && available.has(name));
+        const child = createChild({
+            ...parent.options,
+            ...base,
+            sessionManager: childManager,
+            model,
+            thinkingLevel: request.thinkingLevel ?? base.thinkingLevel ?? "off",
+            activeTools: names,
+            brokers: brokersForChild(parent.options.brokers, {
+                depth: parent.depth + 1,
+                parentToolCallId: request.parentToolCallId,
+            }),
+            depth: parent.depth + 1,
+            maxTurns: request.maxTurns ?? DEFAULT_SUBAGENT_MAX_TURNS,
+            subagents: false,
+        });
+        const onAbort = () => void child.abort();
+        request.signal.addEventListener("abort", onAbort, { once: true });
+        const unsubscribe = child.subscribe((event) => {
+            if (event.type === "tool_execution_start")
+                request.onUpdate?.(`[task] ${event.toolName}`);
+            else if (event.type === "permission_request" || event.type === "permission_resolved")
+                parent.emit?.(event);
+        });
+        let error;
+        try {
+            if (request.signal.aborted)
+                throw new AmaError("aborted", "aborted");
+            await child.prompt(request.prompt);
+        }
+        catch (caught) {
+            error = caught instanceof Error ? caught.message : String(caught);
+        }
+        finally {
+            request.signal.removeEventListener("abort", onAbort);
+            unsubscribe();
+        }
+        const stats = child.getStats();
+        const last = child.manager
+            .branch()
+            .findLast((entry) => entry.type === "message" && entry.message.role === "assistant");
+        const stopReason = error !== undefined
+            ? "error"
+            : last?.type === "message" && last.message.role === "assistant"
+                ? last.message.stopReason
+                : "stop";
+        const result = {
+            text: child.getLastAssistantText() ?? error ?? "",
+            usage: {
+                input: stats.tokens.input,
+                output: stats.tokens.output,
+                cacheRead: stats.tokens.cacheRead,
+                cacheWrite: stats.tokens.cacheWrite,
+                totalTokens: stats.tokens.total,
+            },
+            stopReason,
+            isError: error !== undefined || stopReason === "error" || stopReason === "aborted",
+        };
+        const cache = stats.cache;
+        if (cache !== undefined) {
+            result.cache = { reBilledTokens: cache.reBilledTokens };
+            if (cache.hitRate !== undefined)
+                result.cache.hitRate = cache.hitRate;
+            // 不报缓存的子会话不进命中率分母（同父会话口径）
+            const reported = cache.reporting === "reported";
+            const { input, cacheRead, cacheWrite } = stats.tokens;
+            parent.cache?.addSubagent(reported
+                ? { cacheRead, prompt: input + cacheRead + cacheWrite }
+                : { cacheRead: 0, prompt: 0 }, cache.reBilledTokens);
+        }
+        const childFile = childManager.file();
+        if (childFile !== undefined)
+            result.sessionFile = childFile;
+        await child.dispose();
+        return result;
+    }
+    finally {
+        pool.release();
+    }
+}

package/dist/agent/session-sync.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 会话的落盘与同步辅助（设计 §8、§11.1 第 16 步）。[B2]
+ *
+ * - `persistMessage`：Agent 的 message_end → 会话条目（LLM 消息 → `message`；custom → `custom_message`）。
+ * - `recordModelState`：路径上最近的 model_change / thinking_level_change 与当前不同则补记。
+ * - `syncSystemMessage`：目标系统提示 + 工具表与转录重放的状态比对，落全量（首条）或补丁；
+ *   中途只追加工具时 tools / rules 节保持已发送的文本（前缀稳定，§9.1）。
+ * - `runHookWithEvents`：调 HookDispatcher（公共字段按本会话的 depth / sessionId / sessionFile 覆盖），
+ *   逐条发 hook_executed；Hook 自身出错记 warning、按无决策处理。
+ */
+import type { Model, ModelThinkingLevel } from "../ai/types.js";
+import type { HookEvent, HookEventPayload, HookOutcome } from "../hooks/types.js";
+import type { AgentMessage } from "../session/types.js";
+import type { ToolDefinition } from "../tools/types.js";
+import type { SessionCore } from "./session-core.js";
+import { type SystemPromptInput } from "./system-prompt.js";
+export declare function persistMessage(core: SessionCore, message: AgentMessage): void;
+export declare function recordModelState(core: SessionCore, model: Model, thinkingLevel: ModelThinkingLevel): void;
+export declare function syncSystemMessage(core: SessionCore, input: Omit<SystemPromptInput, "tools" | "cwd">, tools: readonly ToolDefinition[]): void;
+export declare function runHookWithEvents(core: Pick<SessionCore, "options" | "emit" | "log" | "depth" | "manager">, event: HookEvent, payload: HookEventPayload, signal?: AbortSignal): Promise<HookOutcome | undefined>;

package/dist/agent/session-sync.js

@@ -0,0 +1,111 @@
+/**
+ * 会话的落盘与同步辅助（设计 §8、§11.1 第 16 步）。[B2]
+ *
+ * - `persistMessage`：Agent 的 message_end → 会话条目（LLM 消息 → `message`；custom → `custom_message`）。
+ * - `recordModelState`：路径上最近的 model_change / thinking_level_change 与当前不同则补记。
+ * - `syncSystemMessage`：目标系统提示 + 工具表与转录重放的状态比对，落全量（首条）或补丁；
+ *   中途只追加工具时 tools / rules 节保持已发送的文本（前缀稳定，§9.1）。
+ * - `runHookWithEvents`：调 HookDispatcher（公共字段按本会话的 depth / sessionId / sessionFile 覆盖），
+ *   逐条发 hook_executed；Hook 自身出错记 warning、按无决策处理。
+ */
+import { assembleSections, currentSystemState, definedSections, diffSystem, toolDecls, } from "./system-prompt.js";
+export function persistMessage(core, message) {
+    if (message.role === "custom") {
+        const input = {
+            type: "custom_message",
+            customType: message.customType,
+            content: message.content,
+            display: message.display,
+        };
+        if (message.details !== undefined)
+            input.details = message.details;
+        core.appendEntry(input);
+    }
+    else if (message.role !== "compactionSummary" && message.role !== "branchSummary") {
+        core.appendEntry({ type: "message", message });
+    }
+}
+export function recordModelState(core, model, thinkingLevel) {
+    let provider;
+    let modelId;
+    let channel;
+    let thinking;
+    for (const entry of core.manager.branch()) {
+        if (entry.type === "model_change") {
+            provider = entry.provider;
+            modelId = entry.modelId;
+            channel = entry.channel;
+        }
+        else if (entry.type === "thinking_level_change")
+            thinking = entry.thinkingLevel;
+    }
+    if (provider !== model.provider || modelId !== model.id || channel !== model.channel) {
+        core.appendEntry({
+            type: "model_change",
+            provider: model.provider,
+            modelId: model.id,
+            ...(model.channel !== undefined ? { channel: model.channel } : {}),
+        });
+    }
+    if (thinking !== thinkingLevel) {
+        core.appendEntry({ type: "thinking_level_change", thinkingLevel });
+    }
+}
+export function syncSystemMessage(core, input, tools) {
+    recordModelState(core, core.model(), core.thinkingLevel());
+    const sections = definedSections(assembleSections({ ...input, tools, cwd: core.cwd }));
+    const current = currentSystemState(core.agent.messages);
+    if (current !== undefined)
+        keepSectionsOnToolAppend(current, sections, tools);
+    const patch = diffSystem(current, sections, toolDecls(tools));
+    if (patch === undefined)
+        return;
+    core.appendEntry({ type: "message", message: patch });
+    core.agent.messages.push(patch);
+}
+/**
+ * 会话中途只**追加**工具（宿主晚注册、setActiveTools 加名字）时，保留已发送的 tools / rules 节：
+ * 新工具的声明经请求工具表末尾追加，system 文本不变，前缀缓存不失效（设计 §9.1）。
+ * 有工具被移除时照常重写这两节。
+ */
+function keepSectionsOnToolAppend(current, sections, tools) {
+    const now = new Set(tools.map((tool) => tool.name));
+    if (current.tools.some((tool) => !now.has(tool.name)))
+        return;
+    for (const name of ["tools", "rules"]) {
+        const sent = current.sections[name];
+        if (sent === undefined)
+            delete sections[name];
+        else
+            sections[name] = sent;
+    }
+}
+export async function runHookWithEvents(core, event, payload, signal) {
+    const hooks = core.options.hooks;
+    if (hooks === undefined || !hooks.has(event, payload.toolName))
+        return undefined;
+    try {
+        // 公共字段按本会话覆盖：子 Agent 的 depth / sessionId / sessionFile 不再沿用主会话的。
+        const outcome = await hooks.run(event, payload, signal, {
+            depth: core.depth,
+            sessionId: core.manager.id,
+            sessionFile: core.manager.file(),
+        });
+        for (const result of outcome.results) {
+            core.emit({
+                type: "hook_executed",
+                event: result.event,
+                command: result.command,
+                exitCode: result.exitCode,
+                durationMs: result.durationMs,
+            });
+        }
+        for (const warning of outcome.warnings)
+            core.log("warn", warning);
+        return outcome;
+    }
+    catch (error) {
+        core.log("warn", `${event} hook failed: ${String(error)}`);
+        return undefined;
+    }
+}

package/dist/agent/session-tools.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 会话侧的工具装配（设计 §5.1、§6.3）：tool-runner 的注入项。[B2]
+ *
+ * 一次工具调用的门禁顺序（§6.3）：schema 校验（tool-runner）→ 命令式 Hook PreToolUse（deny / block
+ * 一票否决；updatedInput 替换输入；allow / ask 作为 hookDecision 交给管线）→ 权限管线（B3，注入）→
+ * ask 时走审批链（宿主 broker → UI broker → 无人值守 deny；超时 deny）→ 执行 → PostToolUse
+ * （additionalContext 追加到结果末尾；block 把结果改为错误）。
+ *
+ * （W3-B9a-2）ask 时请求带 `context{depth, readFiles}` 与执行前预览 `preview`（只读、有上限，
+ * 见 permissions/preview.ts）；预览出错或为空则缺省，不影响审批。`permission_request` 事件同样带
+ * `preview`，RPC 客户端可直接显示。
+ */
+import type { ToolCallBlock } from "../ai/types.js";
+import type { ApprovalDecision, ApprovalRequest } from "../permissions/types.js";
+import type { ToolContext, ToolResult } from "../tools/types.js";
+import type { SessionCore } from "./session-core.js";
+import { type ToolRunnerOptions } from "./tool-runner.js";
+import type { NestedCallInfo, ToolCallGate, ToolCallGateContext } from "./types.js";
+/** 审批链：依次问每个 broker，第一个给出决定的为准；全部弃权 → deny。 */
+export declare function requestApproval(core: SessionCore, request: ApprovalRequest, signal: AbortSignal): Promise<ApprovalDecision>;
+export declare function gateToolCall(core: SessionCore, call: ToolCallBlock, ctx: ToolCallGateContext): Promise<ToolCallGate>;
+export declare function afterToolCall(core: SessionCore, call: ToolCallBlock, result: ToolResult, parent?: NestedCallInfo): Promise<ToolResult>;
+export declare function createToolContext(core: SessionCore, runner: ToolRunnerOptions, call: ToolCallBlock, signal: AbortSignal, onUpdate: (partial: string) => void): ToolContext;
+export declare function createToolRunnerOptions(core: SessionCore): ToolRunnerOptions;