@qwen-code/channel-base 0.19.3-nightly.20260701.a974594d7 → 0.19.4

package/README.md

@@ -67,6 +67,15 @@ For a complete working example, see [`@qwen-code/channel-plugin-example`](../plu
 
 Migration note for existing TypeScript plugins: if your adapter constructor or factory explicitly types `bridge` as `AcpBridge`, change that annotation to `ChannelAgentBridge` and keep using only the methods exposed by that contract. JavaScript plugins are unaffected at runtime, and standalone `qwen channel start` still passes the current `AcpBridge` implementation.
 
+## Runtime modes
+
+Channel adapters can run in two host modes:
+
+- `qwen channel start [name]` is the standalone service. It uses `AcpBridge` over a `qwen-code --acp` child process and remains the default channel command.
+- `qwen serve --channel <name>` and `qwen serve --channel all` are experimental daemon-managed modes. `qwen serve` starts one out-of-process channel worker, the worker connects back to the daemon through the SDK, and adapters receive a `DaemonChannelBridge`-backed `ChannelAgentBridge` facade.
+
+In daemon-managed mode, one daemon is bound to one workspace. Every selected channel's `cwd` must resolve to that same workspace. The optional `shellCommand` method is exposed to adapters only when the daemon advertises the `session_shell_command` capability.
+
 ## Architecture
 
 ```
@@ -160,6 +169,8 @@ constructor(name: string, config: ChannelConfig, bridge: ChannelAgentBridge, opt
 
 `ChannelAgentBridge` is the adapter-facing contract. Channel adapters, channel plugins, `ChannelBase`, and `SessionRouter` should depend on this type instead of a concrete bridge implementation.
 
+`shellCommand` is optional. Adapters should check for it before enabling `!cmd`-style features because daemon-managed hosts expose it only when the connected daemon supports shell execution.
+
 ```typescript
 interface ChannelAgentBridge {
   readonly availableCommands: AvailableCommand[];

package/dist/ChannelAgentBridge.d.ts

@@ -29,6 +29,7 @@ interface ChannelAgentBridgeEventMap {
 }
 export interface ChannelAgentBridge {
     readonly availableCommands: AvailableCommand[];
+    getAvailableCommands?(sessionId: string): AvailableCommand[];
     on<K extends keyof ChannelAgentBridgeEventMap>(eventName: K, listener: (...args: ChannelAgentBridgeEventMap[K]) => void): unknown;
     off<K extends keyof ChannelAgentBridgeEventMap>(eventName: K, listener: (...args: ChannelAgentBridgeEventMap[K]) => void): unknown;
     newSession(cwd: string): Promise<string>;

package/dist/ChannelBase.d.ts

@@ -1,8 +1,9 @@
-import type { ChannelConfig, Envelope } from './types.js';
+import type { ChannelConfig, ChannelMemoryCallbacks, Envelope, SessionTarget } from './types.js';
 import { GroupGate } from './GroupGate.js';
 import { SenderGate } from './SenderGate.js';
 import { SessionRouter } from './SessionRouter.js';
 import type { ChannelAgentBridge, ToolCallEvent } from './ChannelAgentBridge.js';
+import type { ChannelLoop, ChannelLoopInput } from './ChannelLoopStore.js';
 /**
  * Max time /clear waits for a cancelled in-flight turn to wind down before
  * purging anyway. A wedged ACP child (stuck tool call, not reading stdin, or
@@ -15,11 +16,26 @@ export declare const CLEAR_CANCEL_TIMEOUT_MS = 3000;
 export interface ChannelBaseOptions {
     router?: SessionRouter;
     proxy?: string;
+    channelMemory?: ChannelMemoryCallbacks;
     /**
      * Set when a channel owns a supplied router and should consume bridge
      * events directly.
      */
     registerBridgeEvents?: boolean;
+    groupHistoryPath?: string;
+    loopController?: ChannelLoopController;
+}
+export interface ChannelLoopController {
+    create(input: ChannelLoopInput): Promise<ChannelLoop>;
+    createForTarget?(input: ChannelLoopInput, maxEnabledLoops: number): Promise<ChannelLoop | undefined>;
+    listForTarget(channelName: string, target: SessionTarget): Promise<ChannelLoop[]>;
+    disable(id: string): Promise<boolean>;
+    validateCron(cron: string): void;
+    nextFireTime?(job: ChannelLoop): Date;
+}
+export interface ChannelLoopPromptOptions {
+    timeoutMs?: number;
+    shouldContinue?: () => Promise<boolean>;
 }
 /** Handler for a slash command. Return true if handled, false to forward to agent. */
 type CommandHandler = (envelope: Envelope, args: string) => Promise<boolean>;
@@ -32,6 +48,9 @@ export declare abstract class ChannelBase {
     protected name: string;
     /** Resolved proxy URL, available to subclasses for adapter-specific clients. */
     protected proxy?: string;
+    private readonly channelMemory?;
+    private groupHistory;
+    private readonly loopController?;
     private instructedSessions;
     private commands;
     /** Per-session promise chain to serialize prompt + send (followup mode). */
@@ -53,8 +72,14 @@ export declare abstract class ChannelBase {
     abstract connect(): Promise<void>;
     abstract sendMessage(chatId: string, text: string): Promise<void>;
     abstract disconnect(): void;
+    supportsProactiveSend(): boolean;
+    protected supportsProactiveTarget(target: SessionTarget): boolean;
+    protected pushProactive(target: SessionTarget, text: string): Promise<void>;
     /** Replace the bridge instance (used after crash recovery restart). */
     setBridge(bridge: ChannelAgentBridge): void;
+    runLoopPrompt(job: ChannelLoop, options?: ChannelLoopPromptOptions): Promise<string | undefined>;
+    private runLoopBridgePrompt;
+    private cancelTimedOutLoopPrompt;
     onToolCall(_chatId: string, _event: ToolCallEvent): void;
     onSessionDied(sessionId: string): void;
     private attachBridgeEvents;
@@ -91,9 +116,29 @@ export declare abstract class ChannelBase {
     protected registerCancelCommand(name?: string): void;
     /** Register shared slash commands. Called from constructor. */
     private registerSharedCommands;
+    private handleLoopCommand;
+    private handleLoopAdd;
+    private handleLoopList;
+    private handleLoopInspect;
+    private formatLoopListLine;
+    private lastLoopStatus;
+    private formatNextFireTime;
+    private handleLoopCancel;
+    private loopTargetFromEnvelope;
+    private isStoredLoopTargetAuthorized;
     /** Check if a message text matches a registered local command. */
     protected isLocalCommand(text: string): boolean;
     private findActiveSessionId;
+    private channelMemoryTarget;
+    private invalidateSessionContext;
+    private dropQueuedTurnIfStale;
+    private isAuthorizedForChannelMemory;
+    private isSenderAuthorizedForChannelMemory;
+    private ensureChannelMemoryAuthorized;
+    private getChannelMemory;
+    private channelMemoryErrorMessage;
+    private channelMemoryUserErrorMessage;
+    private logChannelMemoryError;
     /**
      * Whether the resolved session is SHARED across senders. `single` collapses
      * the whole channel to one `__single__` session for EVERY sender — group OR
@@ -103,6 +148,7 @@ export declare abstract class ChannelBase {
      * and the host-shell (`!`) gate.
      */
     private isSharedSession;
+    private isSharedSessionTarget;
     /**
      * Whether `envelope.senderId` may act on the resolved session's destructive or
      * workspace-leaking commands (/clear, /who). A SHARED session with a non-empty
@@ -172,6 +218,12 @@ export declare abstract class ChannelBase {
      * isRecognizedCommand's no-await contract.
      */
     private getAgentCommandsForSession;
+    private groupHistoryKey;
+    private groupHistoryLimit;
+    private recordPendingGroupHistory;
+    private drainPendingGroupHistory;
+    private clearPendingGroupHistory;
+    private prependGroupHistoryContext;
     handleInbound(envelope: Envelope): Promise<void>;
     protected onPairingRequired(chatId: string, code: string | null): Promise<void>;
 }