@graychennpm/codebridge 0.0.0-stage → 0.1.0

package/node_modules/@codebridge/project-catalog/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@codebridge/project-catalog",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@codebridge/work-items": "0.1.0",
+    "yaml": "2.9.0"
+  }
+}

package/node_modules/@codebridge/router/dist/channel-stream-projector.d.ts

@@ -0,0 +1,19 @@
+import type { AgentEvent } from "@codebridge/core";
+export interface ChannelStreamSnapshot {
+    thinking: string;
+    progress: string;
+    result: string;
+    liveText: string;
+    finalText: string;
+}
+export interface ChannelStreamProjectorOptions {
+    showThinking?: boolean;
+    maxProgressChars?: number;
+    emptyFinalText?: string;
+}
+export interface ChannelStreamProjector {
+    apply(event: AgentEvent): ChannelStreamSnapshot;
+    snapshot(): ChannelStreamSnapshot;
+}
+export declare function createChannelStreamProjector(options?: ChannelStreamProjectorOptions): ChannelStreamProjector;
+//# sourceMappingURL=channel-stream-projector.d.ts.map

package/node_modules/@codebridge/router/dist/channel-stream-projector.js

@@ -0,0 +1,68 @@
+import { createFeishuStreamPresenter } from "./feishu-stream-presenter.js";
+function mergeProgressText(previous, next, sameMessage) {
+    if (!previous)
+        return next;
+    if (!next || next === previous)
+        return previous;
+    if (next.startsWith(previous))
+        return next;
+    if (previous.startsWith(next))
+        return previous;
+    if (!sameMessage)
+        return next;
+    for (let size = Math.min(previous.length, next.length); size > 0; size -= 1) {
+        if (previous.endsWith(next.slice(0, size))) {
+            return previous + next.slice(size);
+        }
+    }
+    return previous + next;
+}
+export function createChannelStreamProjector(options = {}) {
+    const maxProgressChars = options.maxProgressChars ?? 1200;
+    const emptyFinalText = options.emptyFinalText ?? "（本次无输出）";
+    const { present } = createFeishuStreamPresenter({
+        showThinking: options.showThinking,
+    });
+    let thinking = "";
+    let progress = "";
+    let result = "";
+    let progressMessageId;
+    const snapshot = () => {
+        const liveSections = [
+            thinking || undefined,
+            progress ? `**最新进度**\n${progress}` : undefined,
+            result || undefined,
+        ].filter((value) => Boolean(value));
+        return {
+            thinking,
+            progress,
+            result,
+            liveText: liveSections.join("\n\n---\n\n"),
+            finalText: result.trim() || emptyFinalText,
+        };
+    };
+    return {
+        apply(event) {
+            const part = present(event);
+            if (!part)
+                return snapshot();
+            if (part.zone === "thinking") {
+                thinking += part.text;
+            }
+            else if (part.zone === "progress") {
+                const sameMessage = !(part.messageId
+                    && progressMessageId
+                    && part.messageId !== progressMessageId);
+                progress = mergeProgressText(progress, part.text, sameMessage).slice(-maxProgressChars);
+                if (part.messageId)
+                    progressMessageId = part.messageId;
+            }
+            else {
+                result += part.text;
+            }
+            return snapshot();
+        },
+        snapshot,
+    };
+}
+//# sourceMappingURL=channel-stream-projector.js.map

package/node_modules/@codebridge/router/dist/command-help.d.ts

@@ -0,0 +1,14 @@
+export interface CommandHelpItem {
+    command: string;
+    summary: string;
+}
+export type CommandHelpFormat = "markdown" | "plain";
+export declare const SLASH_COMMANDS: CommandHelpItem[];
+/** 飞书机器人自定义菜单 event_key → 模拟用户发送的文本 */
+export declare const BOT_MENU_EVENT_KEYS: Record<string, string>;
+export declare function formatCompactCommandHelp(format?: CommandHelpFormat): string;
+export declare function formatFullCommandHelp(format?: CommandHelpFormat): string;
+export declare function formatWelcomeMessage(botName?: string): string;
+export declare function formatCompactCommandHint(): string;
+export declare function formatBotMenuSetupGuide(): string[];
+//# sourceMappingURL=command-help.d.ts.map

package/node_modules/@codebridge/router/dist/command-help.js

@@ -0,0 +1,151 @@
+const COMMAND_HELP_GROUPS = [
+    {
+        title: "常用",
+        items: [
+            { command: "/help [full]", summary: "查看快捷菜单或全部命令" },
+            { command: "/menu", summary: "查看手机快捷菜单" },
+            { command: "/status", summary: "查看 backend、目录、模型和任务状态（别名 /s）" },
+        ],
+    },
+    {
+        title: "任务控制",
+        items: [
+            { command: "/stop", summary: "停止当前 Agent 任务（别名 /cancel、/x）" },
+            { command: "/continue", summary: "恢复暂停队列（别名 /c）" },
+            { command: "/steer <指令>", summary: "向运行中的 ACP turn 注入补充指令" },
+            { command: "/approve", summary: "允许当前 Agent 工具权限请求（别名 /a）" },
+            { command: "/deny", summary: "拒绝当前 Agent 工具权限请求（别名 /d）" },
+        ],
+    },
+    {
+        title: "会话管理",
+        items: [
+            { command: "/new", summary: "新建会话（别名 /reset）" },
+            { command: "/resume", summary: "列出当前目录的本机 session（别名 /r）" },
+            { command: "/resume <N>", summary: "绑定列表中第 N 条 session" },
+            { command: "/resume last", summary: "绑定最近一条 session" },
+            { command: "/resume all", summary: "列出全部目录的本机 session" },
+            { command: "/session close <sessionId>", summary: "关闭指定 ACP session" },
+            { command: "/session delete <sessionId>", summary: "永久删除指定 ACP session" },
+        ],
+    },
+    {
+        title: "Agent 与模型",
+        items: [
+            { command: "/backend <cursor|claude|codex|pi|opencode|default>", summary: "切换 Agent（别名 /b）" },
+            { command: "/transport", summary: "兼容命令；当前仅支持 ACP，无需切换" },
+            { command: "/model [list|名称|default]", summary: "列出或切换实时模型" },
+            { command: "/effort [list|级别|default]", summary: "列出或切换实时推理强度" },
+            {
+                command: "/permission [list|模式|default]",
+                summary: "列出或切换实时 mode/权限（别名 /perm）",
+            },
+            { command: "/config [id value|default]", summary: "查看或设置 ACP 实时配置（含 boolean）" },
+            { command: "/thinking [on|off]", summary: "显示或隐藏思考/工具过程（别名 /think）" },
+        ],
+    },
+    {
+        title: "目录与工作区",
+        items: [
+            { command: "/cd <绝对路径>", summary: "切换项目目录" },
+            { command: "/roots", summary: "列出 ACP 附加目录" },
+            { command: "/root add|remove|rm <绝对路径>", summary: "管理 ACP 附加目录" },
+            { command: "/ws list", summary: "列出命名工作区" },
+            { command: "/ws save <名称>", summary: "保存当前目录为工作区" },
+            { command: "/ws use <名称>", summary: "切换到命名工作区" },
+            { command: "/ws remove <名称>", summary: "删除命名工作区" },
+        ],
+    },
+    {
+        title: "文件与 Git",
+        items: [
+            { command: "/send <文件路径>", summary: "把本机文件发到当前聊天" },
+            { command: "/clone <git-url> [目录名]", summary: "克隆仓库并切换目录" },
+            { command: "/pull", summary: "在当前目录执行 git pull --ff-only" },
+        ],
+    },
+];
+export const SLASH_COMMANDS = COMMAND_HELP_GROUPS.flatMap((group) => group.items);
+const COMPACT_COMMANDS = [
+    { command: "/s", summary: "查看当前状态（/status）" },
+    { command: "/c", summary: "恢复暂停队列（/continue）" },
+    { command: "/r last", summary: "续聊最近会话（/resume last）" },
+    { command: "/new", summary: "新建会话" },
+    { command: "/x", summary: "停止当前任务（/stop）" },
+    { command: "/b", summary: "切换 Agent（cursor / claude / codex / pi / opencode）" },
+    { command: "/model", summary: "查看或切换模型" },
+    { command: "/permission", summary: "查看或切换权限" },
+    { command: "/ws list", summary: "查看工作区" },
+];
+/** 飞书机器人自定义菜单 event_key → 模拟用户发送的文本 */
+export const BOT_MENU_EVENT_KEYS = {
+    fcb_help: "/help",
+    fcb_status: "/status",
+    fcb_resume: "/resume",
+    fcb_resume_last: "/resume last",
+    fcb_new: "/new",
+    fcb_stop: "/stop",
+    fcb_backend_cursor: "/backend cursor",
+    fcb_backend_claude: "/backend claude",
+    fcb_backend_codex: "/backend codex",
+    fcb_model: "/model",
+    fcb_permission: "/permission",
+    fcb_ws_list: "/ws list",
+};
+function heading(text, format) {
+    return format === "markdown" ? `**${text}**` : text;
+}
+function commandLine(item, format) {
+    const command = format === "markdown" ? `\`${item.command}\`` : item.command;
+    return `${command} — ${item.summary}`;
+}
+export function formatCompactCommandHelp(format = "markdown") {
+    return [
+        heading("码桥快捷菜单", format),
+        "",
+        ...COMPACT_COMMANDS.map((item) => commandLine(item, format)),
+        "",
+        commandLine({ command: "/help full", summary: "查看全部命令" }, format),
+    ].join("\n");
+}
+export function formatFullCommandHelp(format = "markdown") {
+    const lines = [heading("码桥全部命令", format)];
+    for (const group of COMMAND_HELP_GROUPS) {
+        lines.push("", heading(group.title, format), ...group.items.map((item) => commandLine(item, format)));
+    }
+    return lines.join("\n");
+}
+export function formatWelcomeMessage(botName = "CodeBridge") {
+    const quick = [
+        "`/s` 查看状态（`/status`）",
+        "`/r last` 续聊最近 session（`/resume last`）",
+        "`/b` 切换 Agent（`/backend`：cursor / claude / codex / pi / opencode）",
+        "`/menu` 快捷菜单",
+    ];
+    return [
+        `👋 欢迎使用 **${botName}**`,
+        "",
+        "在飞书里远程驱动本机 Cursor / Claude Code / Codex / Pi / OpenCode。",
+        "直接发消息开始；也可用斜杠命令：",
+        "",
+        ...quick.map((line) => `- ${line}`),
+        "",
+        "---",
+        "💡 在飞书开放平台为机器人配置**自定义菜单**后，常用命令可固定在输入框上方。",
+        "配置说明见项目 `docs/zh-CN/feishu-bot-menu.md`",
+    ].join("\n");
+}
+export function formatCompactCommandHint() {
+    return "快捷：`/menu` · `/s` · `/c` · `/r last` · `/x` · `/new` · `/b`";
+}
+export function formatBotMenuSetupGuide() {
+    return [
+        "建议在飞书开放平台 → 机器人 → 自定义菜单 中配置（单聊）：",
+        "  · 展示样式：悬浮菜单",
+        "  · 动作类型：发送文字 或 推送事件",
+        "  · 发送文字示例：/status、/resume last、/new",
+        "  · 推送事件 event_key 见 docs/zh-CN/feishu-bot-menu.md",
+        "  · 订阅事件：application.bot.menu_v6、im.chat.access_event.bot_p2p_chat_entered_v1",
+    ];
+}
+//# sourceMappingURL=command-help.js.map

package/node_modules/@codebridge/router/dist/feishu-stream-presenter.d.ts

@@ -0,0 +1,18 @@
+import type { AgentEvent } from "@codebridge/core";
+export type FeishuStreamZone = "thinking" | "progress" | "result";
+export interface FeishuStreamPart {
+    zone: FeishuStreamZone;
+    text: string;
+    messageId?: string;
+}
+export interface FeishuStreamPresenterOptions {
+    /** false 时隐藏内部思考/工具，但保留进度检查点与最终答案；缺省 true */
+    showThinking?: boolean;
+}
+/** 飞书流式：思考区与结果区直通渲染，不做汇总或去重 */
+export declare function createFeishuStreamPresenter(options?: FeishuStreamPresenterOptions): {
+    present: (event: AgentEvent) => FeishuStreamPart | null;
+};
+/** @deprecated 使用 createFeishuStreamPresenter */
+export declare function createFeishuStreamFormatter(): (event: AgentEvent) => string;
+//# sourceMappingURL=feishu-stream-presenter.d.ts.map

package/node_modules/@codebridge/router/dist/feishu-stream-presenter.js

@@ -0,0 +1,193 @@
+/** 飞书流式：思考区与结果区直通渲染，不做汇总或去重 */
+export function createFeishuStreamPresenter(options = {}) {
+    const showThinking = options.showThinking ?? true;
+    const toolStatuses = new Map();
+    const toolNames = new Map();
+    let lastPlan;
+    let latestUsage;
+    let lastMode;
+    let lastConfigKey;
+    let lastCommandsKey;
+    let lastSessionTitle;
+    let lastResultMessageId;
+    let resultTrailingNewlines = 0;
+    const present = (event) => {
+        switch (event.type) {
+            case "tool_start":
+                if (event.toolCallId)
+                    toolNames.set(event.toolCallId, event.name);
+                if (event.toolCallId && event.status) {
+                    toolStatuses.set(event.toolCallId, event.status);
+                }
+                return showThinking
+                    ? { zone: "thinking", text: `\n- \`${event.name}\`\n` }
+                    : null;
+            case "tool_update": {
+                const key = event.toolCallId;
+                const name = event.name ?? toolNames.get(key) ?? "tool";
+                if (event.name)
+                    toolNames.set(key, event.name);
+                if (!showThinking)
+                    return null;
+                const state = event.status ?? "in_progress";
+                if (toolStatuses.get(key) === state)
+                    return null;
+                toolStatuses.set(key, state);
+                return {
+                    zone: "thinking",
+                    text: `\n  ↳ \`${name}\`（${state}）\n`,
+                };
+            }
+            case "tool_end": {
+                const name = event.name ??
+                    (event.toolCallId ? toolNames.get(event.toolCallId) : undefined) ??
+                    "tool";
+                if (event.toolCallId) {
+                    toolStatuses.delete(event.toolCallId);
+                    toolNames.delete(event.toolCallId);
+                }
+                if (!showThinking)
+                    return null;
+                return event.status === "failed"
+                    ? { zone: "thinking", text: `\n✗ \`${name}\`（failed）\n` }
+                    : { zone: "thinking", text: `\n✓ \`${name}\`\n` };
+            }
+            case "thought_delta":
+                return showThinking ? { zone: "thinking", text: event.text } : null;
+            case "text_delta": {
+                if (event.phase === "commentary") {
+                    return {
+                        zone: "progress",
+                        text: event.text,
+                        messageId: event.messageId,
+                    };
+                }
+                let text = event.text;
+                if (event.messageId &&
+                    lastResultMessageId &&
+                    event.messageId !== lastResultMessageId) {
+                    const leadingNewlines = text.match(/^\n*/)?.[0].length ?? 0;
+                    text =
+                        "\n".repeat(Math.max(0, 2 - resultTrailingNewlines - leadingNewlines)) + text;
+                }
+                if (event.messageId)
+                    lastResultMessageId = event.messageId;
+                resultTrailingNewlines = Math.min(2, text.match(/\n*$/)?.[0].length ?? 0);
+                return { zone: "result", text, messageId: event.messageId };
+            }
+            case "plan": {
+                if (!showThinking)
+                    return null;
+                const text = event.entries
+                    .map((entry) => {
+                    const mark = entry.status === "completed"
+                        ? "x"
+                        : entry.status === "in_progress"
+                            ? ">"
+                            : " ";
+                    return `- [${mark}] ${entry.content}`;
+                })
+                    .join("\n");
+                const rendered = `\n**计划**\n${text}\n`;
+                if (rendered === lastPlan)
+                    return null;
+                lastPlan = rendered;
+                return { zone: "thinking", text: rendered };
+            }
+            case "plan_update": {
+                if (!showThinking)
+                    return null;
+                const plan = event.plan;
+                const rendered = plan?.type === "markdown"
+                    ? `\n**计划**\n${plan.content ?? ""}\n`
+                    : plan?.type === "file"
+                        ? `\n**计划文件**：${plan.uri ?? "(unknown)"}\n`
+                        : plan?.entries
+                            ? `\n**计划**\n${plan.entries
+                                .map((entry) => `- ${entry.status}: ${entry.content}`)
+                                .join("\n")}\n`
+                            : "";
+                if (!rendered || rendered === lastPlan)
+                    return null;
+                lastPlan = rendered;
+                return { zone: "thinking", text: rendered };
+            }
+            case "plan_removed":
+                lastPlan = undefined;
+                return null;
+            case "usage_update":
+                latestUsage = event;
+                return null;
+            case "current_mode_update":
+                if (!showThinking || lastMode === event.currentModeId)
+                    return null;
+                lastMode = event.currentModeId;
+                return {
+                    zone: "thinking",
+                    text: `\n⚙️ mode: \`${event.currentModeId}\`\n`,
+                };
+            case "config_option_update": {
+                if (!showThinking)
+                    return null;
+                const key = JSON.stringify(event.configOptions.map((option) => [option.id, option.currentValue]));
+                if (key === lastConfigKey)
+                    return null;
+                lastConfigKey = key;
+                const values = event.configOptions
+                    .filter((option) => option.currentValue !== undefined)
+                    .map((option) => `${option.name}=\`${option.currentValue}\``)
+                    .join(" · ");
+                return values
+                    ? { zone: "thinking", text: `\n⚙️ config: ${values}\n` }
+                    : null;
+            }
+            case "available_commands_update": {
+                if (!showThinking)
+                    return null;
+                const key = JSON.stringify(event.availableCommands);
+                if (key === lastCommandsKey)
+                    return null;
+                lastCommandsKey = key;
+                const commands = event.availableCommands
+                    .map((command) => `/${command.name}`)
+                    .join(" ");
+                return commands
+                    ? { zone: "thinking", text: `\n⌘ 可用命令: ${commands}\n` }
+                    : null;
+            }
+            case "session_info_update":
+                if (!showThinking || !event.title || event.title === lastSessionTitle) {
+                    return null;
+                }
+                lastSessionTitle = event.title;
+                return { zone: "thinking", text: `\n📝 ${event.title}\n` };
+            case "error":
+                return { zone: "result", text: `\n❌ ${event.message}\n` };
+            case "done":
+                if (showThinking && event.exitCode === 0 && latestUsage) {
+                    const usage = latestUsage;
+                    latestUsage = undefined;
+                    const cost = usage.cost
+                        ? ` · ${usage.cost.amount} ${usage.cost.currency}`
+                        : "";
+                    return {
+                        zone: "thinking",
+                        text: `\n📊 context ${usage.used.toLocaleString()}/${usage.size.toLocaleString()}${cost}\n`,
+                    };
+                }
+                latestUsage = undefined;
+                return event.exitCode === 0
+                    ? null
+                    : { zone: "result", text: `\n（退出码 ${event.exitCode}）\n` };
+            default:
+                return null;
+        }
+    };
+    return { present };
+}
+/** @deprecated 使用 createFeishuStreamPresenter */
+export function createFeishuStreamFormatter() {
+    const { present } = createFeishuStreamPresenter();
+    return (event) => present(event)?.text ?? "";
+}
+//# sourceMappingURL=feishu-stream-presenter.js.map

package/node_modules/@codebridge/router/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./channel-stream-projector.js";
+export * from "./command-help.js";
+export * from "./feishu-stream-presenter.js";
+export * from "./orchestrator.js";
+export * from "./session-list-format.js";
+export * from "./session-router.js";
+export * from "./session-rotation.js";
+export * from "./slash-commands.js";
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@codebridge/router/dist/index.js

@@ -0,0 +1,9 @@
+export * from "./channel-stream-projector.js";
+export * from "./command-help.js";
+export * from "./feishu-stream-presenter.js";
+export * from "./orchestrator.js";
+export * from "./session-list-format.js";
+export * from "./session-router.js";
+export * from "./session-rotation.js";
+export * from "./slash-commands.js";
+//# sourceMappingURL=index.js.map

package/node_modules/@codebridge/router/dist/model-effort.d.ts

@@ -0,0 +1,5 @@
+import type { BackendConfigOption } from "@codebridge/core";
+export declare function formatDynamicOptionHelp(backendId: string, label: string, command: string, option: BackendConfigOption, current?: string): string;
+export declare function formatDynamicModelHelp(backendId: string, option: BackendConfigOption, current?: string): string;
+export declare function matchBackendConfigValue(option: BackendConfigOption, desired: string): string | undefined;
+//# sourceMappingURL=model-effort.d.ts.map

package/node_modules/@codebridge/router/dist/model-effort.js

@@ -0,0 +1,33 @@
+function formatOptionValue(value, currentValue) {
+    const label = value.name && value.name.toLowerCase() !== value.value.toLowerCase()
+        ? `\`${value.value}\` — ${value.name}`
+        : `\`${value.value}\``;
+    const current = currentValue === value.value ? "（适配器默认）" : "";
+    const description = value.description ? `：${value.description}` : "";
+    return `- ${label}${current}${description}`;
+}
+export function formatDynamicOptionHelp(backendId, label, command, option, current) {
+    const lines = [
+        `**${backendId}** 可用 ${label}（适配器实时列表）：`,
+        ...option.values.map((value) => formatOptionValue(value, option.currentValue)),
+    ];
+    if (current)
+        lines.push("", `当前会话: \`${current}\``);
+    lines.push("", `用法: \`/${command} <名称>\` | \`/${command} default\` 恢复适配器默认`);
+    return lines.join("\n");
+}
+export function formatDynamicModelHelp(backendId, option, current) {
+    return formatDynamicOptionHelp(backendId, "model", "model", option, current);
+}
+export function matchBackendConfigValue(option, desired) {
+    const want = desired.trim().toLowerCase();
+    const exactValue = option.values.find((value) => value.value.toLowerCase() === want);
+    if (exactValue)
+        return exactValue.value;
+    const exactName = option.values.find((value) => value.name?.toLowerCase() === want);
+    if (exactName)
+        return exactName.value;
+    const prefixes = option.values.filter((value) => value.value.toLowerCase().startsWith(want));
+    return prefixes.length === 1 ? prefixes[0].value : undefined;
+}
+//# sourceMappingURL=model-effort.js.map

package/node_modules/@codebridge/router/dist/orchestrator.d.ts

@@ -0,0 +1,56 @@
+import type { ActiveRunStatus, AgentEvent, AppConfig, BackendConfigOption, RunAttachment } from "@codebridge/core";
+import { type CliSessionSummary } from "@codebridge/runner-client";
+import { SessionRouter } from "./session-router.js";
+export interface OrchestratorOptions {
+    dataDir: string;
+    config: AppConfig;
+    onEvent?: (runId: string, event: AgentEvent) => void;
+}
+export declare class RunOrchestrator {
+    private readonly options;
+    readonly router: SessionRouter;
+    private readonly client;
+    private readonly activeChatRuns;
+    constructor(options: OrchestratorOptions);
+    updateConfig(config: AppConfig): void;
+    private chatRunKey;
+    hasActiveRun(chatId: string, topicId?: string): boolean;
+    /** 活跃任务已运行的毫秒数；无活跃任务时返回 undefined */
+    activeRunElapsedMs(chatId: string, topicId?: string): number | undefined;
+    activeRunStatus(chatId: string, topicId?: string): ActiveRunStatus | undefined;
+    cancelActiveForChat(chatId: string, topicId?: string): Promise<boolean>;
+    steerActiveForChat(chatId: string, topicId: string | undefined, prompt: string): Promise<{
+        ok: boolean;
+        outcome?: string;
+        error?: string;
+    }>;
+    runAgent(chatId: string, topicId: string | undefined, prompt: string, attachments?: RunAttachment[]): AsyncGenerator<AgentEvent>;
+    doctor(): Promise<unknown>;
+    health(): Promise<{
+        ok: boolean;
+        version?: string;
+    }>;
+    authorizeDirectory(directory: string): Promise<{
+        ok: boolean;
+        path?: string;
+        error?: string;
+    }>;
+    listSessions(chatId: string, topicId?: string, options?: {
+        all?: boolean;
+        limit?: number;
+    }): Promise<CliSessionSummary[]>;
+    /** prompt_feishu：把 /approve /deny 转给当前 run 挂起的权限请求 */
+    resolveActivePermission(chatId: string, topicId: string | undefined, approve: boolean): Promise<boolean>;
+    listConfigOptions(chatId: string, topicId?: string): Promise<BackendConfigOption[]>;
+    closeSession(chatId: string, topicId: string | undefined, sessionId: string): Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+    deleteSession(chatId: string, topicId: string | undefined, sessionId: string): Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+    private manageSession;
+}
+export declare function agentEventToMarkdown(event: AgentEvent): string;
+//# sourceMappingURL=orchestrator.d.ts.map