@qoder-ai/qoder-agent-sdk 1.0.57 → 1.0.59

package/README.md

@@ -6,6 +6,8 @@ The SDK starts `qodercli` for you, streams agent messages back to Node.js, and
 lets your application configure tools, permissions, working directories, MCP
 servers, hooks, and interactive sessions.
 
+For compression billing messages, see [压缩费用消息接口](doc/compact-usage.md).
+
 ## Installation
 
 ```bash
@@ -23,49 +25,55 @@ installed if your application uses SDK tools or MCP integration.
 
 ## Runtime Behavior
 
-The npm package uses `WorkerTransport.default` for `query()` by default. During
-`npm install`, its postinstall script downloads the Worker runtime selected by
-the package's pinned CLI version into `dist/_worker`. It does not download the
-process CLI unless `QODER_INSTALL_BUNDLED_CLI=1` is set.
-
-You can still select a transport explicitly on the same `query()` entry:
+`query()` always runs through a process-wide qodercli daemon. The first query
+starts that daemon and reuses it for later queries in the same process; pass
+`options.daemon` to bind a query to a daemon you started yourself with
+`startDaemon()`. The daemon owns the CLI process boundary, so the SDK does not
+spawn a separate CLI per query. Call `shutdownDaemon()` before your host
+process exits to stop the shared daemon.
+
+During `npm install`, the postinstall script downloads the CLI binary selected
+by the package's pinned CLI version into `dist/_bundled`; worker packages also
+deliver the worker runtime into `dist/_worker`.
+
+The daemon launches qodercli either as a native process carrier or as a Node
+worker runtime. `startDaemon()` / `initDaemon()` accept
+`launchMode: 'process' | 'worker'`; without it, the first query's
+`options.transport` (`ProcessTransport` or `WorkerTransport`) selects the
+carrier, otherwise the package's `DEFAULT_RUNTIME_TRANSPORT` applies. Worker
+mode launches the bundled `dist/_worker` runtime, or the runtime passed through
+`pathToQoderWorkerRuntime`; when no worker runtime is available the daemon
+falls back to the process carrier. A later query whose launch mode differs from
+the ready daemon is rejected with `DaemonConfigurationConflictError`.
+
+The process carrier uses `pathToQoderCLIExecutable` when provided, then
+`QODERCLI_PATH`, then the bundled CLI, then a locally installed `qodercli`.
+JavaScript CLI entries run through `executable` (or the SDK host's Node binary).
+
+`Options.transport`, `ProcessTransport`, and `WorkerTransport` remain
+available: selecting either transport no longer spawns a per-query process or
+worker, it selects the shared daemon's carrier. Query options that configure
+the CLI process, such as `pathToQoderCLIExecutable`, `executable`,
+`executableArgs`, `env`, `proxy`, `vpcEndpoint`, and `auth`, configure the
+shared daemon instead. Because the daemon is shared, every query in one process
+must pass compatible daemon-level options.
+
+`options.extraHeaders` accepts a `Record<string, string>` for the first Qoder
+main-model request of the first queryable input and its network retries. Later
+tool continuations, subagents, and queries do not inherit these headers. Existing
+built-in headers take precedence. Use a paired CLI build with `extra_headers`
+support. For example, after the host obtains the user's paid-usage confirmation:
 
 ```ts
-import {
-  qodercliAuth,
-  query,
-  WorkerTransport,
-} from "@qoder-ai/qoder-agent-sdk";
-
-const q = query({
-  prompt: "Summarize this repository.",
+query({
+  prompt,
   options: {
-    auth: qodercliAuth(),
-    transport: WorkerTransport.default,
+    ...options,
+    extraHeaders: { "Cosy-Paid-Confirmed": "true" },
   },
 });
 ```
 
-The worker transport uses the runtime installed at
-`dist/_worker/qoder-worker-runtime.obf.mjs`. To use another Worker runtime,
-pass its path explicitly with
-`new WorkerTransport({ pathToQoderWorkerRuntime })`. Environment variables do
-not override the Worker runtime entry.
-
-The package includes a `dist/runtime-manifest.json` that records the default
-runtime and the URL template for qodercli Worker runtime artifacts. At
-installation time, the SDK resolves exactly one artifact for its own brand,
-the current operating system, and the current architecture. It does not fall
-back to the universal artifact. The SDK package itself does not need to host a
-copy of the archive. The presence of `dist/_worker` is used as an integrity
-check after installation, not as the mode selector.
-
-The installed Worker runtime is self-contained. Platform packages include the
-matching native keychain, PTY, image-processing, and ripgrep assets. Linux
-packages retain both glibc and musl image-processing bindings. OpenHarmony does
-not have an install-delivered platform artifact and must use an explicitly
-supplied runtime source.
-
 If your environment blocks install scripts or network downloads, skip postinstall
 runtime downloads:
 
@@ -73,27 +81,13 @@ runtime downloads:
 QODER_SKIP_DOWNLOAD=1 npm install @qoder-ai/qoder-agent-sdk zod
 ```
 
-`QODER_SKIP_DOWNLOAD` only affects install-time downloads. It does not change the
-package's default runtime. Then point the process transport at an existing
-`qodercli`:
+`QODER_SKIP_DOWNLOAD` only affects install-time downloads. Point the daemon at
+an existing `qodercli` with:
 
 ```bash
 export QODERCLI_PATH=/absolute/path/to/qodercli
 ```
 
-To use an existing Worker runtime, pass its absolute path through
-`new WorkerTransport({ pathToQoderWorkerRuntime })`.
-
-`query()` is the only query entry point and defaults to Worker. Pass
-`transport: ProcessTransport.default`,
-`transport: WorkerTransport.default`, or a custom transport provider when a
-single call needs to override the package default.
-
-`pathToQoderCLIExecutable` accepts either local runtime form. Native binaries
-and ordinary CLI `.js`/`.mjs` entries use the process transport; recognized
-`qoder-worker-runtime*.mjs` entries use the Worker transport. An explicit
-`transport` provider always takes precedence over automatic path selection.
-
 ## Authentication
 
 Every SDK query needs an explicit authentication option.
@@ -213,6 +207,11 @@ for await (const message of q) {
 }
 ```
 
+## Business Attribution
+
+For Qoder integrations, set product on the daemon and type on each query.
+See the [short integration guide](doc/business-context.md).
+
 ## Code Security
 
 Built-in code security is disabled by default in SDK sessions. Enable only the
@@ -452,8 +451,8 @@ non-fatal `system/mirror_error` messages. Each append batch is submitted once:
 the SDK does not retry a mutation whose commit outcome may be unknown.
 `loadTimeoutMs` defaults to 60,000 ms.
 Session storage cannot be combined with `persistSession: false`, file
-checkpointing, custom transports, or the Cloud Agent runtime. Session storage
-supports the built-in Process and Worker transports. Use
+checkpointing, or the Cloud Agent runtime. It works on daemon-backed queries.
+Use
 `importSessionToStore(sessionId, store, options)` to copy an existing local main
 transcript, child-agent transcripts, and metadata into a store.
 

package/dist/core/default-runtime.d.ts

@@ -2,7 +2,9 @@ export type DefaultRuntimeTransport = 'process' | 'worker';
 /**
  * The default transport baked into the packaged SDK bundle.
  *
- * Development / plain `tsc` builds default to `process`. Release bundles replace
- * `__QODER_DEFAULT_RUNTIME_TRANSPORT__` through esbuild `define`.
+ * Development / plain `tsc` builds default to `process`. Legacy bundles may
+ * replace `__QODER_DEFAULT_RUNTIME_TRANSPORT__` through esbuild `define`; the
+ * value is retained for integrations that read it, while every Query now
+ * executes through the process-wide daemon.
  */
 export declare const DEFAULT_RUNTIME_TRANSPORT: DefaultRuntimeTransport;

package/dist/core/errors.d.ts

@@ -2,6 +2,18 @@
  * Custom error types for the Qoder Agent SDK.
  */
 import type { SDKResultMessage } from '../protocol/messages.js';
+export declare class QoderCliProcessError extends Error {
+    readonly code: "QODER_CLI_PROCESS_ERROR";
+    readonly exitCode?: number | null;
+    readonly signal?: NodeJS.Signals | null;
+    readonly stderr?: string;
+    constructor(message: string, options?: {
+        exitCode?: number | null;
+        signal?: NodeJS.Signals | null;
+        stderr?: string;
+        cause?: unknown;
+    });
+}
 /** JSONL 帧超过传输预算；输入与输出使用不同错误码，避免把执行端输出问题归因于用户输入。 */
 export declare class FrameTooLargeError extends Error {
     readonly direction: 'input' | 'output';

package/dist/core/process-transport.d.ts

@@ -1,41 +1,26 @@
 /**
- * ProcessTransport — Spawns qodercli as a child process and
- * manages stdin/stdout communication using JSONL (JSON Lines) format.
+ * ProcessTransport compatibility surface.
  *
- * This is the primary transport for Node.js environments. It:
- * 1. Builds CLI arguments from the provided options
- * 2. Spawns the CLI process (or delegates to a custom spawner)
- * 3. Reads stdout line-by-line, parsing each as JSON
- * 4. Writes to stdin as JSON + newline
- * 5. Handles graceful shutdown: close stdin → wait → SIGTERM → wait → SIGKILL
+ * The child-process implementation is gone: selecting this transport now runs
+ * the Query through the process-wide daemon. The exported types and members
+ * stay so existing integrations keep compiling and keep the same behavior.
  */
 import type { QueryTransportProvider, Transport } from './transport.js';
-import type { StdoutMessage } from '../types/control.js';
 import type { SdkPluginConfig, ToolConfig } from '../types/common.js';
 import type { PermissionMode } from '../types/permissions.js';
 import type { McpServerConfigForProcessTransport, McpServerToolPolicy } from '../types/mcp.js';
 import type { InternalAuthOptions } from '../types/auth.js';
 import type { SecurityScanOptions, SpawnedProcess, SpawnOptions, SettingSource } from '../types/options.js';
 import type { DiagnosticsSink } from './sdk-diagnostics.js';
-export declare class QoderCliProcessError extends Error {
-    readonly code: "QODER_CLI_PROCESS_ERROR";
-    readonly exitCode?: number | null;
-    readonly signal?: NodeJS.Signals | null;
-    readonly stderr?: string;
-    constructor(message: string, options?: {
-        exitCode?: number | null;
-        signal?: NodeJS.Signals | null;
-        stderr?: string;
-        cause?: unknown;
-    });
-}
-/**
- * Options for configuring the ProcessTransport.
- *
- * These map 1:1 to the CLI flags and environment variables that the
- * qodercli understands.
- */
+export { QoderCliProcessError } from './errors.js';
+type ToolsOption = string[] | {
+    type: 'preset';
+    preset: 'qodercli';
+};
 export interface ProcessTransportOptions {
+    business?: {
+        type: string;
+    };
     /** Path to the Qoder CLI executable (binary or script) */
     pathToQoderCLIExecutable?: string;
     /** Override executable name (node, bun, deno) for script entry points */
@@ -120,95 +105,7 @@ export interface ProcessTransportOptions {
      */
     onAuthExpired?: () => void;
 }
-type ToolsOption = string[] | {
-    type: 'preset';
-    preset: 'qodercli';
-};
-export declare class ProcessTransport implements Transport, QueryTransportProvider<ProcessTransportOptions> {
+export declare class ProcessTransport implements QueryTransportProvider<ProcessTransportOptions> {
     static readonly default: ProcessTransport;
-    private process;
-    private customHandle;
-    private options;
-    private ready;
-    private closed;
-    private shutdownStarted;
-    private initializePromise;
-    private authExpiredFired;
-    private pendingInput;
-    private diagnostics?;
-    private processExitError;
-    private processStopped;
-    private closeTimer;
-    private killTimer;
-    private stderrTail;
-    private launchOptionsBuilder;
-    constructor(options?: ProcessTransportOptions);
     create(options: ProcessTransportOptions): Transport;
-    /**
-     * Build CLI arguments, resolve the executable, spawn the process,
-     * and mark the transport as ready.
-     */
-    initialize(): Promise<void>;
-    private _doInitialize;
-    /** Write a JSON line to stdin. */
-    write(data: string): void;
-    private writeReadyLine;
-    private flushPendingInput;
-    /** Whether the transport is ready to send/receive. */
-    isReady(): boolean;
-    /** Signal that no more input will be sent (close stdin). */
-    endInput(): void;
-    private endReadyInput;
-    /**
-     * Async generator that yields parsed JSON messages from stdout.
-     *
-     * Uses readline to split stdout into lines. Each non-empty line is
-     * expected to be a complete JSON object (JSONL format).
-     *
-     * The generator completes when:
-     * - The readline interface closes (process exited or stdout ended)
-     * - The transport is closed
-     */
-    readMessages(): AsyncGenerator<StdoutMessage, void, unknown>;
-    /**
-     * Close the transport with graceful shutdown:
-     *
-     * 1. Close stdin (signal to CLI that no more input is coming)
-     * 2. Wait CLOSE_GRACE_MS for the process to exit on its own
-     * 3. Send SIGTERM
-     * 4. Wait KILL_GRACE_MS for the process to exit
-     * 5. Send SIGKILL if still running
-     */
-    close(): void;
-    /** 回收进程资源，不改变调用方主动关闭状态；异常仍由读取循环传播。 */
-    private shutdownProcess;
-    private hasProcessStopped;
-    private finishProcess;
-    private observeProcess;
-    /**
-     * Get the underlying process PID, if available.
-     */
-    get pid(): number | undefined;
-    /**
-     * Get the stdout stream from the process or custom handle.
-     */
-    private getStdout;
-    private appendStderr;
-    private createSpawnError;
-    private createProcessExitError;
-    private getStderrTail;
-    private waitForProcessExit;
-    /**
-     * Resolve the executable command and arguments.
-     *
-     * If the CLI path is a script file (.js/.mjs/.ts/.tsx/.jsx), we need
-     * an interpreter (node/bun/deno). Otherwise the path is a native binary
-     * and is used directly as the command.
-     */
-    private resolveExecutable;
-    /** 清理 runtime 已消费或不再可能消费的启动制品。 */
-    private cleanupLaunchArtifacts;
-    /** Fire `onAuthExpired` at most once per session. */
-    private fireAuthExpired;
-}
-export {};
+}

package/dist/core/query-transport.d.ts

@@ -1,6 +1,16 @@
-import { type ProcessTransportOptions } from './process-transport.js';
+import type { ProcessTransportOptions } from './process-transport.js';
+import type { RuntimeLaunchOptions } from './runtime-launch-options.js';
 import type { QueryTransportProvider, Transport } from './transport.js';
+/** SDK-internal options for the daemon session transport provider. */
+export interface DaemonQueryTransportOptions extends RuntimeLaunchOptions {
+    /** SDK-internal: config root created by SessionStore materialization. */
+    materializedSessionConfigDir?: string;
+}
+/**
+ * Options a custom transport provider receives. Kept as the historical
+ * `ProcessTransportOptions` shape so existing providers keep compiling.
+ */
 export type QueryTransportCreateOptions = ProcessTransportOptions;
 export type QueryTransportProviderOption = QueryTransportProvider<QueryTransportCreateOptions>;
 export declare function isQueryTransportProvider(value: unknown): value is QueryTransportProviderOption;
-export declare function createQueryTransport(provider: QueryTransportProviderOption, options: QueryTransportCreateOptions): Transport;
+export declare function createQueryTransport<T extends object>(provider: QueryTransportProvider<T>, options: T): Transport;

package/dist/core/runtime-launch-options.d.ts

@@ -18,6 +18,9 @@ type ToolsOption = string[] | {
     preset: 'qodercli';
 };
 export interface RuntimeLaunchOptions {
+    business?: {
+        type: string;
+    };
     cwd?: string;
     env?: Record<string, string | undefined>;
     proxy?: string;

package/dist/core/worker-transport.d.ts

@@ -1,16 +1,14 @@
 /**
- * WorkerTransport — runs qoder-worker-runtime inside a Node worker thread.
+ * WorkerTransport compatibility surface.
  *
- * This transport keeps the existing SDK stream-json protocol but replaces the
- * child-process boundary with worker stdin/stdout/stderr streams. It is meant
- * for hosts that already own a Node runtime, including Node SEA hosts, and want
- * to avoid spawning a second qoder SEA process.
+ * The worker-thread implementation is gone: selecting this transport now runs
+ * the Query through the process-wide daemon. The exported classes, helpers and
+ * option types stay so existing integrations keep compiling and running.
  */
 import type { QueryTransportProvider, Transport } from './transport.js';
 import type { ProcessTransportOptions } from './process-transport.js';
-import type { StdoutMessage } from '../types/control.js';
 import type { DiagnosticsSink } from './sdk-diagnostics.js';
-import { type RuntimeLaunchOptions } from './runtime-launch-options.js';
+import type { RuntimeLaunchOptions } from './runtime-launch-options.js';
 import { hasResolvableQoderWorkerRuntime, resolveQoderWorkerRuntimePath } from './worker-runtime-path.js';
 export { hasResolvableQoderWorkerRuntime, resolveQoderWorkerRuntimePath };
 export declare class QoderWorkerRuntimeError extends Error {
@@ -49,52 +47,10 @@ export interface WorkerRuntimeTransportOptions extends RuntimeLaunchOptions, Wor
     onAuthExpired?: () => void;
 }
 export declare class WorkerTransport implements QueryTransportProvider<ProcessTransportOptions> {
-    static readonly default: WorkerTransport;
     private readonly options;
+    static readonly default: WorkerTransport;
     constructor(options?: WorkerTransportOptions);
+    /** query() 用它把 worker 选择映射成 daemon 的宿主形态。 */
+    getPathToQoderWorkerRuntime(): string | undefined;
     create(options: ProcessTransportOptions): Transport;
-}
-export declare class WorkerRuntimeTransport implements Transport {
-    private worker;
-    private options;
-    private ready;
-    private closed;
-    private initializePromise;
-    private authExpiredFired;
-    private pendingInput;
-    private diagnostics?;
-    private workerExitError;
-    private stderrTail;
-    private observedExitCode;
-    private launchOptionsBuilder;
-    private closeTimer;
-    private closePromise;
-    private abortSignal?;
-    private abortListener?;
-    constructor(options?: WorkerRuntimeTransportOptions);
-    initialize(): Promise<void>;
-    private _doInitialize;
-    write(data: string): void;
-    isReady(): boolean;
-    endInput(): void;
-    readMessages(): AsyncGenerator<StdoutMessage, void, unknown>;
-    close(): Promise<void>;
-    private performClose;
-    get threadId(): number | undefined;
-    private writeReadyLine;
-    private flushPendingInput;
-    private endReadyInput;
-    private destroyWorkerStreams;
-    private appendStderr;
-    private createWorkerError;
-    private createWorkerExitError;
-    private getStderrTail;
-    private recordWorkerExit;
-    private recordSuppressedWorkerExit;
-    private formatStderrTailForDiagnostics;
-    private waitForWorkerExit;
-    private clearCloseTimer;
-    private cleanupAbortListener;
-    private cleanupLaunchArtifacts;
-    private fireAuthExpired;
 }

package/dist/daemon/daemon-connection.d.ts

@@ -17,12 +17,6 @@ export declare const SESSION_STORE_FORK_BARRIER_CAPABILITY = "session_store_fork
  */
 export declare const DAEMON_HEARTBEAT_TIMEOUT_MS = 120000;
 export declare const DAEMON_KEEP_ALIVE_CAPABILITY = "daemon_keep_alive_v1";
-/**
- * daemon 会话 close 改成「关信道即回包、后台排干 teardown」的能力位（CLI 仓镜像）。
- * 会话 initialize 回包声明它时，QueryRunner.close 不再隐式等 memory / evolution
- * flush；旧 CLI 不声明则保持原有等待语义（版本错配保护）。
- */
-export declare const DAEMON_ASYNC_SESSION_TEARDOWN_CAPABILITY = "daemon_async_session_teardown_v1";
 export interface DaemonConnectionOptions {
     input: Writable;
     output: Readable;
@@ -52,6 +46,9 @@ export interface DaemonConnectionOptions {
     heartbeatTimeoutMs?: number;
 }
 export interface DaemonInitializeOptions {
+    business?: {
+        product: string;
+    };
     /** Advertised in addition to the capability this SDK cannot work without. */
     capabilities?: readonly string[];
     timeoutMs?: number;
@@ -280,6 +277,7 @@ export declare class DaemonConnection {
     private readOutput;
     private acceptFrame;
     private rememberTimedOutRequestId;
+    private abandonSessionFromLateResponse;
     private routeSessionMessage;
     private acceptControlResponse;
     private hasPendingSessionRequest;

package/dist/daemon/daemon-session-transport.d.ts

@@ -4,6 +4,9 @@ import type { DaemonWireSessionMessage } from './protocol.js';
 import type { DaemonConnection, DaemonSessionIdClaim } from './daemon-connection.js';
 import type { DiagnosticsSink } from '../core/sdk-diagnostics.js';
 export type DaemonSessionTransportOptions = {
+    business?: {
+        type: string;
+    };
     workerArgs: string[];
     cwd?: string;
     configDir?: string;

package/dist/daemon/global-daemon.d.ts

@@ -1,6 +1,12 @@
 import type { InternalAuthOptions } from '../types/auth.js';
+import type { QueryTransportProvider } from '../core/transport.js';
+import type { DaemonQueryTransportOptions } from '../core/query-transport.js';
 import { type Daemon } from './start-daemon.js';
 export interface InitDaemonOptions {
+    /** daemon 全局产品身份；初始化后不能由 Query 覆盖。 */
+    business?: {
+        product: string;
+    };
     auth: InternalAuthOptions;
     pathToQoderCLIExecutable?: string;
     /** 语义同 `StartDaemonOptions.executable`。 */
@@ -13,6 +19,10 @@ export interface InitDaemonOptions {
     /** 语义同 `StartDaemonOptions.vpcEndpoint`。 */
     vpcEndpoint?: string;
     env?: Record<string, string | undefined>;
+    /** 宿主形态：process=spawn CLI 二进制；worker=Node 跑 worker runtime。缺省 process。 */
+    launchMode?: 'process' | 'worker';
+    /** worker 形态下覆盖 worker runtime 产物路径。 */
+    pathToQoderWorkerRuntime?: string;
     /** 语义同 `StartDaemonOptions.stderr`：daemon 子进程 stderr 的实时回调。 */
     stderr?: (data: string) => void;
     /** 语义同 `StartDaemonOptions.debug`。 */
@@ -20,16 +30,24 @@ export interface InitDaemonOptions {
     /** 语义同 `StartDaemonOptions.debugFile`。 */
     debugFile?: string;
 }
-export type DaemonFallbackReason = 'protocol_version_mismatch' | 'daemon_unavailable';
-export type DaemonInitResult = {
-    mode: 'daemon';
+export interface GlobalDaemonHandle {
+    /**
+     * A daemon-shaped handle that resolves every call against the initialization
+     * started by `acquireGlobalDaemon`. It is usable before the handshake
+     * completes; asynchronous members wait for readiness instead of failing.
+     */
     daemon: Daemon;
-} | {
-    mode: 'direct';
-    reason: DaemonFallbackReason;
-};
+    transportProvider: QueryTransportProvider<DaemonQueryTransportOptions>;
+}
 export declare class DaemonConfigurationConflictError extends Error {
     constructor();
 }
-export declare function initDaemon(options: InitDaemonOptions): Promise<DaemonInitResult>;
+export declare function initDaemon(options: InitDaemonOptions): Promise<Daemon>;
+/**
+ * Start a query handle backed by the process-wide daemon. The daemon starts
+ * immediately, and each Query's session transport waits for that same
+ * initialization; a failure rejects the Query instead of falling back to a
+ * direct CLI transport.
+ */
+export declare function acquireGlobalDaemon(options: InitDaemonOptions): GlobalDaemonHandle;
 export declare function shutdownDaemon(): Promise<void>;

package/dist/daemon/legacy-transport-compat.d.ts

@@ -0,0 +1,13 @@
+import type { ProcessTransportOptions } from '../core/process-transport.js';
+import type { Transport } from '../core/transport.js';
+/**
+ * Built-in Process/Worker transport selections keep their public surface but
+ * execute through the process-wide daemon. This adapter is used when a caller
+ * invokes the legacy provider's `create()` directly; `query()` routes the same
+ * selections without reaching the provider.
+ */
+export interface LegacyDaemonLaunch {
+    readonly launchMode: 'process' | 'worker';
+    readonly pathToQoderWorkerRuntime?: string;
+}
+export declare function createLegacyDaemonTransport(options: ProcessTransportOptions, launch: LegacyDaemonLaunch): Transport;

package/dist/daemon/protocol.d.ts

@@ -106,6 +106,9 @@ export type DaemonWireSessionMessage = JsonObject & {
 };
 export type DaemonProtocolFrame = DaemonControlRequestFrame | DaemonControlResponseFrame | DaemonSessionUpdatedStatusEventFrame | KeepAliveFrame | DaemonProtocolErrorFrame | DaemonWireSessionMessage;
 export type InitializeDaemonParams = {
+    business?: {
+        product: string;
+    };
     daemon_protocol_version: typeof DAEMON_PROTOCOL_VERSION;
     sdk_version: string;
     capabilities: string[];
@@ -136,6 +139,9 @@ export type InitializeDaemonResult = {
     capabilities: string[];
 };
 export type OpenSessionParams = {
+    business?: {
+        type: string;
+    };
     worker_args: string[];
     cwd?: string;
     config_dir?: string;

package/dist/daemon/start-daemon.d.ts

@@ -1,6 +1,6 @@
 import type { InternalAuthOptions } from '../types/auth.js';
-import type { ProcessTransportOptions } from '../core/process-transport.js';
 import type { QueryTransportProvider } from '../core/transport.js';
+import type { DaemonQueryTransportOptions } from '../core/query-transport.js';
 import type { DaemonGetModelsParams, DaemonValidateByokModelParams } from './protocol.js';
 import type { BYOKProviderInfo, ByokConfigCheckResult, ByokConfigInfo, ByokConfigReference, CheckByokConfigInput, CreateByokConfigInput, DeleteByokConfigInput, UpdateByokConfigInput } from '../protocol/control.js';
 import type { AccountInfo, ModelInfo, UsageInfo } from '../protocol/common.js';
@@ -16,6 +16,10 @@ export interface DaemonSessionInfo {
     updatedAt: string;
 }
 export interface StartDaemonOptions {
+    /** daemon 全局产品身份；不同产品使用不同 daemon。 */
+    business?: {
+        product: string;
+    };
     /**
      * Credentials for the daemon's own account plane and its in-process Sessions.
      *
@@ -46,6 +50,13 @@ export interface StartDaemonOptions {
      */
     heartbeatTimeoutMs?: number;
     pathToQoderCLIExecutable?: string;
+    /**
+     * 宿主形态：`process` spawn CLI 二进制；`worker` 用 Node 跑 worker runtime
+     * （老 Windows 无法运行 Bun 二进制时使用）。缺省 `process`。
+     */
+    launchMode?: 'process' | 'worker';
+    /** worker 形态下覆盖 worker runtime 产物路径；缺省用随包/已安装产物。 */
+    pathToQoderWorkerRuntime?: string;
     /**
      * 运行 CLI 脚本入口的解释器（node/bun/deno 等），语义与 `query()` 的
      * `Options.executable` 一致：只在解析出的 CLI 入口是脚本文件（.js/.mjs/.ts/...）
@@ -234,7 +245,7 @@ interface InternalDaemonRuntime {
      * when unset, or when the CLI does not support bypass updates).
      */
     noProxy: string | null;
-    readonly transportProvider: QueryTransportProvider<ProcessTransportOptions>;
+    readonly transportProvider: QueryTransportProvider<DaemonQueryTransportOptions>;
 }
 export declare function getDaemonRuntime(daemon: Daemon): InternalDaemonRuntime | undefined;
 export declare function startDaemon(options: StartDaemonOptions): Promise<Daemon>;