@foxden-app/foxclaw 0.12.0 → 0.13.0

package/dist/channels/bridge_messaging_router.d.ts

@@ -1,4 +1,6 @@
-import type { TelegramRemoteFile } from '../telegram/api.js';
+import type { ChannelTextEvent } from '../core/channel_events.js';
+import type { ChannelPort } from '../core/channel_port.js';
+type LegacyPanelPort = ChannelPort & Partial<Pick<TelegramMessagingPort, 'sendRichHtml' | 'editHtml' | 'editRichHtml' | 'sendVoice' | 'clearInlineKeyboard' | 'sendDraft' | 'sendRichDraft' | 'sendRichMarkdownDraft'>>;
 import type { InlineKeyboard, TelegramMessagingPort } from './telegram/telegram_messaging_port.js';
 import type { WeixinMessagingPort } from './weixin/weixin_messaging_port.js';
 /**
@@ -8,7 +10,8 @@ import type { WeixinMessagingPort } from './weixin/weixin_messaging_port.js';
 export declare class BridgeMessagingRouter {
     private readonly telegram;
     private readonly weixin;
-    constructor(telegram: TelegramMessagingPort, weixin: WeixinMessagingPort | null);
+    constructor(telegram: LegacyPanelPort, weixin: WeixinMessagingPort | null);
+    resolveAction(event: ChannelTextEvent): import("../core/channel_events.js").ChannelCallbackEvent | null;
     get hasWeixinTransport(): boolean;
     private isWeixinScope;
     canSendToScope(scopeId: string): boolean;
@@ -29,6 +32,7 @@ export declare class BridgeMessagingRouter {
     sendRichDraft(scopeId: string, draftId: number, html: string, fallbackText: string): Promise<void>;
     sendRichMarkdownDraft(scopeId: string, draftId: number, markdown: string, fallbackText: string): Promise<void>;
     answerCallback(callbackQueryId: string, text: string): Promise<void>;
-    getFile(fileId: string): Promise<TelegramRemoteFile>;
-    downloadResolvedFile(remoteFilePath: string, destinationPath: string): Promise<number>;
+    getFile(fileId: string): ReturnType<ChannelPort['getFile']>;
+    downloadResolvedFile(remoteFilePath: string, destinationPath: string): ReturnType<ChannelPort['downloadResolvedFile']>;
 }
+export {};

package/dist/channels/bridge_messaging_router.js

@@ -10,6 +10,7 @@ export class BridgeMessagingRouter {
         this.telegram = telegram;
         this.weixin = weixin;
     }
+    resolveAction(event) { return this.isWeixinScope(event.scopeId) ? this.weixin?.resolveAction?.(event) ?? null : null; }
     get hasWeixinTransport() {
         return this.weixin !== null;
     }
@@ -41,7 +42,7 @@ export class BridgeMessagingRouter {
         if (this.isWeixinScope(scopeId)) {
             return this.requireWeixinTransport(scopeId).sendHtml(scopeId, fallbackHtml, keyboard);
         }
-        return this.telegram.sendRichHtml(scopeId, html, keyboard);
+        return this.telegram.sendRichHtml?.(scopeId, html, keyboard) ?? this.telegram.sendHtml(scopeId, fallbackHtml, keyboard);
     }
     sendRichMarkdown(scopeId, markdown, fallbackText, keyboard) {
         if (this.isWeixinScope(scopeId)) {
@@ -53,6 +54,8 @@ export class BridgeMessagingRouter {
         if (this.isWeixinScope(scopeId)) {
             throw new Error(`Voice messages are not supported for Weixin scope ${scopeId}`);
         }
+        if (!this.telegram.sendVoice)
+            throw new Error('Channel does not support sendVoice');
         return this.telegram.sendVoice(scopeId, filename, contents, caption, contentType);
     }
     editPlain(scopeId, messageId, text, keyboard) {
@@ -65,13 +68,13 @@ export class BridgeMessagingRouter {
         if (this.isWeixinScope(scopeId)) {
             return this.requireWeixinTransport(scopeId).editHtml(scopeId, messageId, text, keyboard);
         }
-        return this.telegram.editHtml(scopeId, messageId, text, keyboard);
+        return this.telegram.editHtml?.(scopeId, messageId, text, keyboard) ?? this.telegram.editRichMarkdown(scopeId, messageId, text, keyboard);
     }
     editRichHtml(scopeId, messageId, html, fallbackHtml, keyboard) {
         if (this.isWeixinScope(scopeId)) {
             return this.requireWeixinTransport(scopeId).editHtml(scopeId, messageId, fallbackHtml, keyboard);
         }
-        return this.telegram.editRichHtml(scopeId, messageId, html, keyboard);
+        return this.telegram.editRichHtml?.(scopeId, messageId, html, keyboard) ?? this.editHtml(scopeId, messageId, fallbackHtml, keyboard);
     }
     editRichMarkdown(scopeId, messageId, markdown, fallbackText, keyboard) {
         if (this.isWeixinScope(scopeId)) {
@@ -95,27 +98,35 @@ export class BridgeMessagingRouter {
         if (this.isWeixinScope(scopeId)) {
             return this.requireWeixinTransport(scopeId).clearInlineKeyboard(scopeId, messageId);
         }
-        return this.telegram.clearInlineKeyboard(scopeId, messageId);
+        return this.telegram.clearInlineKeyboard?.(scopeId, messageId) ?? Promise.resolve();
     }
     sendDraft(scopeId, draftId, text) {
         if (this.isWeixinScope(scopeId)) {
             return this.requireWeixinTransport(scopeId).sendDraft(scopeId, draftId, text);
         }
+        if (!this.telegram.sendDraft)
+            throw new Error('Channel does not support sendDraft');
         return this.telegram.sendDraft(scopeId, draftId, text);
     }
     sendRichDraft(scopeId, draftId, html, fallbackText) {
         if (this.isWeixinScope(scopeId)) {
             return this.requireWeixinTransport(scopeId).sendDraft(scopeId, draftId, fallbackText);
         }
+        if (!this.telegram.sendRichDraft)
+            throw new Error('Channel does not support sendRichDraft');
         return this.telegram.sendRichDraft(scopeId, draftId, html);
     }
     sendRichMarkdownDraft(scopeId, draftId, markdown, fallbackText) {
         if (this.isWeixinScope(scopeId)) {
             return this.requireWeixinTransport(scopeId).sendDraft(scopeId, draftId, fallbackText);
         }
+        if (!this.telegram.sendRichMarkdownDraft)
+            throw new Error('Channel does not support sendRichMarkdownDraft');
         return this.telegram.sendRichMarkdownDraft(scopeId, draftId, markdown);
     }
     answerCallback(callbackQueryId, text) {
+        if (callbackQueryId.startsWith('text:'))
+            return this.weixin?.answerCallback(callbackQueryId, text) ?? Promise.resolve();
         return this.telegram.answerCallback(callbackQueryId, text);
     }
     getFile(fileId) {

package/dist/channels/telegram/telegram_messaging_port.d.ts

@@ -1,3 +1,5 @@
+import type { AppConfig } from '../../config.js';
+import type { ChannelTextEvent } from '../../core/channel_events.js';
 import type { ChannelPort } from '../../core/channel_port.js';
 import type { TelegramGateway } from '../../telegram/gateway.js';
 import type { TelegramRemoteFile } from '../../telegram/api.js';
@@ -10,7 +12,21 @@ export type InlineKeyboard = Array<Array<{
  */
 export declare class TelegramMessagingPort implements ChannelPort {
     private readonly gateway;
+    private readonly taskPreviews;
     constructor(gateway: TelegramGateway);
+    beginTaskPreview(scopeId: string, taskId: string, text: string, reuseMessageId?: number): Promise<number>;
+    updateTaskPreview(scopeId: string, taskId: string, messageId: number, html: string): Promise<number>;
+    endTaskPreview(scopeId: string, taskId: string): Promise<void>;
+    readonly capabilities: {
+        editableMessages: boolean;
+        inlineActions: boolean;
+        maxMessageLength: number;
+    };
+    resolveIncoming(event: ChannelTextEvent, config: AppConfig, username?: string | null): import("../../telegram/addressing.js").TelegramAddressingDecision;
+    setScopeCommands(scopeId: string, commands: Array<{
+        command: string;
+        description: string;
+    }>): Promise<void>;
     sendPlain(bridgeScopeId: string, text: string, inlineKeyboard?: InlineKeyboard): Promise<number>;
     sendHtml(bridgeScopeId: string, text: string, inlineKeyboard?: InlineKeyboard): Promise<number>;
     sendRichHtml(bridgeScopeId: string, html: string, inlineKeyboard?: InlineKeyboard): Promise<number>;

package/dist/channels/telegram/telegram_messaging_port.js

@@ -1,3 +1,7 @@
+import { TelegramTaskPreviews } from '../../telegram/task_preview.js';
+import { telegramTaskResult } from '../../telegram/task_result.js';
+import { parseCommand } from '../../controller/commands.js';
+import { isDefaultTelegramScope, resolveTelegramAddressing } from '../../telegram/addressing.js';
 import { parseTelegramTargetFromBridgeScope } from '../../core/bridge_scope.js';
 import { telegramRichHtml, telegramRichMarkdown } from '../../telegram/rich.js';
 /**
@@ -5,8 +9,24 @@ import { telegramRichHtml, telegramRichMarkdown } from '../../telegram/rich.js';
  */
 export class TelegramMessagingPort {
     gateway;
+    taskPreviews;
     constructor(gateway) {
         this.gateway = gateway;
+        this.taskPreviews = new TelegramTaskPreviews(gateway);
+    }
+    beginTaskPreview(scopeId, taskId, text, reuseMessageId = 0) { return this.taskPreviews.begin(scopeId, taskId, text, reuseMessageId); }
+    updateTaskPreview(scopeId, taskId, messageId, html) { return this.taskPreviews.update(scopeId, taskId, messageId, html); }
+    endTaskPreview(scopeId, taskId) { return this.taskPreviews.end(scopeId, taskId); }
+    capabilities = { editableMessages: true, inlineActions: true, maxMessageLength: 4000 };
+    resolveIncoming(event, config, username) {
+        return resolveTelegramAddressing({ text: event.text, attachmentsCount: event.attachments.length,
+            entities: event.entities, command: parseCommand(event.text), botUsername: username ?? null,
+            isDefaultTopic: isDefaultTelegramScope({ chatType: event.chatType, allowedChatId: config.tgAllowedChatId ?? null,
+                allowedTopicId: config.tgAllowedTopicId ?? null, topicId: event.topicId, requireExplicitGroupAddressing: false }), replyToBot: event.replyToBot });
+    }
+    async setScopeCommands(scopeId, commands) {
+        const target = parseTelegramTargetFromBridgeScope(scopeId);
+        await this.gateway.setChatCommands(target.chatId, commands);
     }
     async sendPlain(bridgeScopeId, text, inlineKeyboard) {
         const target = parseTelegramTargetFromBridgeScope(bridgeScopeId);
@@ -22,7 +42,7 @@ export class TelegramMessagingPort {
     }
     async sendRichMarkdown(bridgeScopeId, markdown, inlineKeyboard) {
         const target = parseTelegramTargetFromBridgeScope(bridgeScopeId);
-        return this.gateway.sendRichMessage(target.chatId, telegramRichMarkdown(markdown, { skipEntityDetection: true }), inlineKeyboard, target.topicId);
+        return this.gateway.sendRichMessage(target.chatId, telegramTaskResult(markdown), inlineKeyboard, target.topicId);
     }
     async sendVoice(bridgeScopeId, filename, contents, caption, contentType) {
         const target = parseTelegramTargetFromBridgeScope(bridgeScopeId);
@@ -42,7 +62,7 @@ export class TelegramMessagingPort {
     }
     async editRichMarkdown(bridgeScopeId, messageId, markdown, inlineKeyboard) {
         const target = parseTelegramTargetFromBridgeScope(bridgeScopeId);
-        await this.gateway.editRichMessage(target.chatId, messageId, telegramRichMarkdown(markdown, { skipEntityDetection: true }), inlineKeyboard);
+        await this.gateway.editRichMessage(target.chatId, messageId, telegramTaskResult(markdown), inlineKeyboard);
     }
     async deleteMessage(bridgeScopeId, messageId) {
         const target = parseTelegramTargetFromBridgeScope(bridgeScopeId);

package/dist/channels/text_actions.d.ts

@@ -0,0 +1,14 @@
+import type { ChannelInlineKeyboard } from '../core/channel_port.js';
+import type { ChannelTextEvent, ChannelCallbackEvent } from '../core/channel_events.js';
+/** Scoped, expiring actions for channels without inline buttons. */
+export declare class TextActions {
+    private readonly ttlMs;
+    private readonly maxActions;
+    private readonly actions;
+    constructor(ttlMs?: number, maxActions?: number);
+    render(scopeId: string, messageId: number, keyboard: ChannelInlineKeyboard): string;
+    resolve(event: ChannelTextEvent): ChannelCallbackEvent | null;
+    clearMessage(scopeId: string, messageId: number): void;
+    clear(): void;
+    private prune;
+}

package/dist/channels/text_actions.js

@@ -0,0 +1,48 @@
+import { randomBytes } from 'node:crypto';
+/** Scoped, expiring actions for channels without inline buttons. */
+export class TextActions {
+    ttlMs;
+    maxActions;
+    actions = new Map();
+    constructor(ttlMs = 300_000, maxActions = 2000) {
+        this.ttlMs = ttlMs;
+        this.maxActions = maxActions;
+    }
+    render(scopeId, messageId, keyboard) {
+        this.prune();
+        return keyboard.flat().map(button => {
+            this.prune();
+            while (this.actions.size >= this.maxActions && this.actions.size)
+                this.actions.delete(this.actions.keys().next().value);
+            const code = randomBytes(6).toString('hex');
+            this.actions.set(code, { scopeId, data: button.callback_data, messageId, expires: Date.now() + this.ttlMs });
+            return `${button.text}  /choose ${code}`;
+        }).join('\n');
+    }
+    resolve(event) {
+        this.prune();
+        const match = /^\/choose\s+([a-f0-9]+)\s*$/i.exec(event.text);
+        const code = match?.[1];
+        if (!code)
+            return null;
+        const action = this.actions.get(code);
+        if (!action || action.scopeId !== event.scopeId)
+            return null;
+        this.actions.delete(code);
+        return { scopeId: event.scopeId, chatId: event.chatId, topicId: event.topicId, userId: event.userId,
+            messageId: action.messageId, data: action.data, callbackQueryId: `text:${code}`, ...(event.languageCode ? { languageCode: event.languageCode } : {}) };
+    }
+    clearMessage(scopeId, messageId) {
+        for (const [code, action] of this.actions)
+            if (action.scopeId === scopeId && action.messageId === messageId)
+                this.actions.delete(code);
+    }
+    clear() { this.actions.clear(); }
+    prune() {
+        for (const [code, action] of this.actions)
+            if (action.expires <= Date.now())
+                this.actions.delete(code);
+        while (this.actions.size > this.maxActions)
+            this.actions.delete(this.actions.keys().next().value);
+    }
+}

package/dist/channels/weixin/weixin_channel_adapter.d.ts

@@ -1,10 +1,9 @@
 import type { AppConfig } from '../../config.js';
-import type { BridgeSessionCore } from '../../controller/controller.js';
 import type { Logger } from '../../logger.js';
 import type { BridgeStore } from '../../store/database.js';
-import type { TelegramTextEvent } from '../../telegram/gateway.js';
+import type { ChannelTextEvent } from '../../core/channel_events.js';
 export interface IWeixinBridgeCore {
-    dispatchInboundLikeTelegramText(event: TelegramTextEvent): void;
+    dispatchInboundLikeTelegramText(event: ChannelTextEvent): void;
 }
 export declare class WeixinChannelAdapter {
     private readonly core;
@@ -13,7 +12,7 @@ export declare class WeixinChannelAdapter {
     private readonly logger;
     private readonly abort;
     private loops;
-    constructor(core: BridgeSessionCore | IWeixinBridgeCore, store: BridgeStore, config: AppConfig, logger: Logger);
+    constructor(core: IWeixinBridgeCore, store: BridgeStore, config: AppConfig, logger: Logger);
     start(): Promise<void>;
     stop(): Promise<void>;
     private listAccounts;

package/dist/channels/weixin/weixin_channel_adapter.js

@@ -26,7 +26,7 @@ function isAllowedWeixinUser(config, fromUserId) {
     }
     return config.wxAllowedIlinkUserIds.includes(fromUserId);
 }
-function buildTelegramShapedEvent(params) {
+function buildInboundEvent(params) {
     return {
         chatId: params.fromUserId,
         topicId: null,
@@ -261,7 +261,7 @@ export class WeixinChannelAdapter {
             textLen: trimmed.length,
             attachments: attachments.length,
         });
-        const event = buildTelegramShapedEvent({
+        const event = buildInboundEvent({
             scopeId,
             fromUserId,
             text: trimmed,

package/dist/channels/weixin/weixin_messaging_port.d.ts

@@ -1,3 +1,5 @@
+import type { ChannelPort } from '../../core/channel_port.js';
+import type { ChannelTextEvent } from '../../core/channel_events.js';
 import type { BridgeStore } from '../../store/database.js';
 import { getConfig, sendTyping } from './ilink/api.js';
 import type { WeixinSavedAccount } from './account_store.js';
@@ -10,15 +12,28 @@ type WeixinTypingApi = {
  * Weixin (iLink) outbound: addressed by `weixin:<accountId>:<peerUserId>` scope ids.
  * Editing/deleting Telegram messages is approximated as new plain text sends or no-ops.
  */
-export declare class WeixinMessagingPort {
+export declare class WeixinMessagingPort implements ChannelPort {
     private readonly store;
     private readonly loadAccount;
     private readonly typingApi;
+    readonly capabilities: {
+        editableMessages: boolean;
+        inlineActions: boolean;
+        maxMessageLength: number;
+    };
+    private readonly actions;
+    private readonly callbackScopes;
     private nextSyntheticId;
     constructor(store: BridgeStore, loadAccount: (accountId: string) => WeixinSavedAccount | null, typingApi?: WeixinTypingApi);
     private allocMessageId;
     sendPlain(scopeId: string, text: string, keyboard?: ChannelInlineKeyboard): Promise<number>;
     sendHtml(scopeId: string, html: string, keyboard?: ChannelInlineKeyboard): Promise<number>;
+    sendRichMarkdown(scopeId: string, text: string, keyboard?: ChannelInlineKeyboard): Promise<number>;
+    editRichMarkdown(scopeId: string, messageId: number, text: string, keyboard?: ChannelInlineKeyboard): Promise<void>;
+    resolveAction(event: ChannelTextEvent): import("../../core/channel_events.js").ChannelCallbackEvent | null;
+    answerCallback(callbackId: string, text: string): Promise<void>;
+    getFile(): Promise<never>;
+    downloadResolvedFile(): Promise<never>;
     editPlain(scopeId: string, _messageId: number, text: string, keyboard?: ChannelInlineKeyboard): Promise<void>;
     editHtml(scopeId: string, messageId: number, html: string, keyboard?: ChannelInlineKeyboard): Promise<void>;
     deleteMessage(scopeId: string, messageId: number): Promise<void>;

package/dist/channels/weixin/weixin_messaging_port.js

@@ -1,3 +1,4 @@
+import { TextActions } from '../text_actions.js';
 import { parseWeixinBridgeScope } from '../../core/bridge_scope.js';
 import { getConfig, sendTyping } from './ilink/api.js';
 import { sendMessageWeixin } from './ilink/send.js';
@@ -22,6 +23,9 @@ export class WeixinMessagingPort {
     store;
     loadAccount;
     typingApi;
+    capabilities = { editableMessages: false, inlineActions: false, maxMessageLength: 2000 };
+    actions = new TextActions();
+    callbackScopes = new Map();
     nextSyntheticId = 1;
     constructor(store, loadAccount, typingApi = DEFAULT_TYPING_API) {
         this.store = store;
@@ -34,7 +38,9 @@ export class WeixinMessagingPort {
         return id;
     }
     async sendPlain(scopeId, text, keyboard) {
-        void keyboard;
+        const messageId = this.allocMessageId();
+        const choices = keyboard?.length ? this.actions.render(scopeId, messageId, keyboard) : '';
+        const rendered = choices ? `${text}\n\n${choices}` : text;
         const parsed = parseWeixinBridgeScope(scopeId);
         if (!parsed) {
             throw new Error(`Invalid weixin scope: ${scopeId}`);
@@ -46,27 +52,49 @@ export class WeixinMessagingPort {
         const contextToken = this.store.getWeixinContextToken(scopeId);
         await sendMessageWeixin({
             to: parsed.fromUserId,
-            text,
+            text: rendered,
             opts: {
                 baseUrl: account.baseUrl,
                 token: account.botToken,
                 ...(contextToken !== null && contextToken !== '' ? { contextToken } : {}),
             },
         });
-        return this.allocMessageId();
+        return messageId;
     }
     async sendHtml(scopeId, html, keyboard) {
         return this.sendPlain(scopeId, stripHtmlBasic(html), keyboard);
     }
+    sendRichMarkdown(scopeId, text, keyboard) {
+        // Shared result summaries contain HTML fragments as well as Markdown.
+        return this.sendPlain(scopeId, stripHtmlBasic(text), keyboard);
+    }
+    async editRichMarkdown(scopeId, messageId, text, keyboard) {
+        this.actions.clearMessage(scopeId, messageId);
+        await this.sendRichMarkdown(scopeId, text, keyboard);
+    }
+    resolveAction(event) {
+        const action = this.actions.resolve(event);
+        if (action)
+            this.callbackScopes.set(action.callbackQueryId, event.scopeId);
+        return action;
+    }
+    async answerCallback(callbackId, text) {
+        const scopeId = this.callbackScopes.get(callbackId);
+        this.callbackScopes.delete(callbackId);
+        if (scopeId && text)
+            await this.sendPlain(scopeId, text);
+    }
+    async getFile() { throw new Error('Weixin attachments must be downloaded by the inbound channel'); }
+    async downloadResolvedFile() { throw new Error('Weixin attachments must be downloaded by the inbound channel'); }
     async editPlain(scopeId, _messageId, text, keyboard) {
+        this.actions.clearMessage(scopeId, _messageId);
         await this.sendPlain(scopeId, text, keyboard);
     }
     async editHtml(scopeId, messageId, html, keyboard) {
         await this.sendHtml(scopeId, html, keyboard);
     }
     async deleteMessage(scopeId, messageId) {
-        void scopeId;
-        void messageId;
+        this.actions.clearMessage(scopeId, messageId);
     }
     async sendTypingInScope(scopeId) {
         const parsed = parseWeixinBridgeScope(scopeId);
@@ -104,8 +132,7 @@ export class WeixinMessagingPort {
         }
     }
     async clearInlineKeyboard(scopeId, messageId) {
-        void scopeId;
-        void messageId;
+        this.actions.clearMessage(scopeId, messageId);
     }
     async sendDraft(scopeId, _draftId, text) {
         await this.sendPlain(scopeId, text);

package/dist/codex_app/activity.d.ts

@@ -0,0 +1,62 @@
+import type { JsonRpcNotification } from './client.js';
+export interface RawExecCommandEvent {
+    callId: string;
+    turnId: string;
+    command: string[];
+    cwd: string | null;
+    parsedCmd: any[];
+}
+export type TurnActivityState = 'thinking' | 'reading' | 'searching' | 'editing' | 'running_command' | 'approval_waiting' | 'completed' | 'interrupted';
+export type TurnOutputKind = 'commentary' | 'final_answer' | 'tool_summary' | 'error';
+export type TurnActivityEvent = {
+    kind: 'user_message';
+    turnId: string;
+    text: string;
+} | {
+    kind: 'agent_message_started';
+    turnId: string;
+    itemId: string;
+    phase: string | null;
+    outputKind: TurnOutputKind;
+    isPlan?: boolean;
+} | {
+    kind: 'agent_message_delta';
+    turnId: string;
+    itemId: string;
+    delta: string;
+    outputKind: TurnOutputKind;
+    isPlan?: boolean;
+} | {
+    kind: 'agent_message_completed';
+    turnId: string;
+    itemId: string;
+    phase: string | null;
+    text: string | null;
+    outputKind: TurnOutputKind;
+    isPlan?: boolean;
+} | {
+    kind: 'reasoning_started';
+    turnId: string;
+    state: 'thinking';
+} | {
+    kind: 'reasoning_completed';
+    turnId: string;
+    state: 'thinking';
+} | {
+    kind: 'tool_started';
+    turnId: string;
+    exec: RawExecCommandEvent;
+    state: TurnActivityState;
+} | {
+    kind: 'tool_completed';
+    turnId: string;
+    exec: RawExecCommandEvent;
+    state: TurnActivityState;
+} | {
+    kind: 'turn_completed';
+    turnId: string;
+    state: 'completed' | 'interrupted';
+};
+export declare function normalizeTurnActivityEvent(notification: JsonRpcNotification): TurnActivityEvent | null;
+export declare function classifyAgentOutput(phase: string | null, completed: boolean): TurnOutputKind;
+export declare function inferToolActivityState(event: RawExecCommandEvent): TurnActivityState;