qlogicagent 1.1.1 → 1.2.1

package/dist/types/llm/transports/qwen-media.d.ts

@@ -1,25 +1,50 @@
 /**
- * Qwen (DashScope) Media Transport — TTS via CosyVoice.
+ * Qwen (DashScope) Media Transport — TTS + Video Generation.
  *
- * DashScope TTS uses the async task API:
- *   Submit: POST /api/v1/services/aigc/text2audio/generation
+ * DashScope async task API pattern:
+ *   Submit: POST /api/v1/services/aigc/<service>/generation  (X-DashScope-Async: enable)
  *   Poll:   GET  /api/v1/tasks/{taskId}
  *
  * Auth: Authorization: Bearer $DASHSCOPE_API_KEY
- * Docs: https://help.aliyun.com/zh/model-studio/developer-reference/cosyvoice-large-speech-synthesis
+ * Docs: https://help.aliyun.com/zh/model-studio/developer-reference/
+ *
+ * Video models: wan2.7-t2v (text-to-video), wan2.7-i2v (image-to-video)
+ * TTS models: qwen3-tts-voicedesign, cosyvoice-v2
  */
-import type { MediaTransport, MediaRequest, MediaResult, MediaType } from "../media-transport.js";
+import type { AsyncMediaTransport, MediaRequest, MediaResult, MediaType } from "../media-transport.js";
 export interface QwenMediaConfig {
     /** Base URL, e.g. "https://dashscope.aliyuncs.com" */
     baseUrl: string;
     timeoutMs?: number;
 }
-export declare class QwenMediaTransport implements MediaTransport {
+export declare class QwenMediaTransport implements AsyncMediaTransport {
     readonly supportedTypes: readonly MediaType[];
     private baseUrl;
     private timeoutMs;
     constructor(config: QwenMediaConfig);
     generate(request: MediaRequest, apiKey: string, signal?: AbortSignal): Promise<MediaResult>;
     private pollTask;
-    private extractAudioUrl;
+    private generateVideo;
+    /**
+     * Query a single task by ID using DashScope unified task endpoint.
+     * GET /api/v1/tasks/{taskId}
+     */
+    getTaskStatus(taskId: string, apiKey: string, signal?: AbortSignal): Promise<{
+        status: string;
+        task: Record<string, unknown>;
+    }>;
+    /**
+     * List tasks — DashScope has a task list API.
+     * GET /api/v1/tasks?page_no=1&page_size=20&status=RUNNING
+     */
+    listVideoTasks(apiKey: string, options?: {
+        after?: string;
+        limit?: number;
+        status?: string;
+    }, signal?: AbortSignal): Promise<Record<string, unknown>>;
+    /**
+     * Cancel/delete — DashScope does not have a public task cancellation API.
+     */
+    deleteVideoTask(_taskId: string, _apiKey: string, _signal?: AbortSignal): Promise<void>;
+    private extractMediaUrl;
 }

package/dist/types/llm/transports/realtime-transport.d.ts

@@ -41,7 +41,7 @@
 export interface RealtimeConfig {
     /** WebSocket endpoint (e.g. "wss://api.openai.com/v1/realtime") */
     baseUrl: string;
-    /** Model to use (e.g. "gpt-4o-realtime-preview", "glm-realtime") */
+    /** Model to use (e.g. "gpt-realtime-2", "glm-realtime") */
     model: string;
     /** API key */
     apiKey: string;

package/dist/types/llm/transports/volcengine-media.d.ts

@@ -9,13 +9,13 @@
  * Auth: Authorization: Bearer $ARK_API_KEY
  * Docs: https://www.volcengine.com/docs/82379/1330310
  */
-import type { MediaTransport, MediaRequest, MediaResult, MediaType } from "../media-transport.js";
+import type { AsyncMediaTransport, MediaRequest, MediaResult, MediaType } from "../media-transport.js";
 export interface VolcengineMediaConfig {
     /** Base URL, e.g. "https://ark.cn-beijing.volces.com/api" */
     baseUrl: string;
     timeoutMs?: number;
 }
-export declare class VolcengineMediaTransport implements MediaTransport {
+export declare class VolcengineMediaTransport implements AsyncMediaTransport {
     readonly supportedTypes: readonly MediaType[];
     private baseUrl;
     private timeoutMs;
@@ -34,6 +34,14 @@ export declare class VolcengineMediaTransport implements MediaTransport {
     private parseStreamingImage;
     private generateVideo;
     private generate3D;
+    /**
+     * Query a single video generation task by ID.
+     * GET /v3/contents/generations/tasks/{taskId}
+     */
+    getTaskStatus(taskId: string, apiKey: string, signal?: AbortSignal): Promise<{
+        status: string;
+        task: Record<string, unknown>;
+    }>;
     /**
      * List video generation tasks with optional filters.
      * GET /v3/contents/generations/tasks

package/dist/types/llm/transports/zhipu-media.d.ts

@@ -13,13 +13,13 @@
  * Base URL: https://open.bigmodel.cn/api/paas/v4
  * Auth: Authorization: Bearer $ZHIPU_API_KEY
  */
-import type { MediaTransport, MediaRequest, MediaResult, MediaType } from "../media-transport.js";
+import type { AsyncMediaTransport, MediaRequest, MediaResult, MediaType } from "../media-transport.js";
 export interface ZhipuMediaConfig {
     /** Base URL, e.g. "https://open.bigmodel.cn/api/paas/v4" */
     baseUrl: string;
     timeoutMs?: number;
 }
-export declare class ZhipuMediaTransport implements MediaTransport {
+export declare class ZhipuMediaTransport implements AsyncMediaTransport {
     readonly supportedTypes: readonly MediaType[];
     private baseUrl;
     private timeoutMs;
@@ -44,6 +44,28 @@ export declare class ZhipuMediaTransport implements MediaTransport {
      * Throws on "FAIL" or timeout.
      */
     private pollAsyncResult;
+    /**
+     * Query a single task status — GET /async-result/{id}
+     * Zhipu uses a unified async result endpoint for all task types.
+     */
+    getTaskStatus(taskId: string, apiKey: string, signal?: AbortSignal): Promise<{
+        status: string;
+        task: Record<string, unknown>;
+    }>;
+    /**
+     * List recent tasks — Zhipu does not have a native list endpoint.
+     * Returns empty since individual task query via getTaskStatus() is the primary API.
+     */
+    listVideoTasks(_apiKey: string, _options?: {
+        after?: string;
+        limit?: number;
+        status?: string;
+    }, _signal?: AbortSignal): Promise<Record<string, unknown>>;
+    /**
+     * Cancel/delete is not supported by Zhipu's async API — throws informative error.
+     * The /async-result/{id} endpoint is read-only.
+     */
+    deleteVideoTask(_taskId: string, _apiKey: string, _signal?: AbortSignal): Promise<void>;
     /**
      * List cloned voices — GET /voice/
      * Returns all voice clones for the current user.

package/dist/types/orchestration/agent-instance.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Agent Instance — Product Mode orchestrator.
+ *
+ * Manages the lifecycle of a Product: creating instances (agents),
+ * scheduling tasks via DAG, enforcing budget, checkpointing state.
+ *
+ * Flow:
+ *   1. product.create → validate DAG, create instances, start scheduling
+ *   2. DAG readyTasks → spawn agent → sendTask → on complete → markCompleted → checkpoint
+ *   3. product.pause → pause all, checkpoint
+ *   4. product.resume → load state, resume scheduling
+ *   5. product.checkpoint → manual checkpoint
+ */
+import type { AgentProcessManager } from "../runtime/infra/agent-process.js";
+import type { AcpDetector } from "../runtime/infra/acp-detector.js";
+import type { AgentConfigStore } from "../runtime/infra/agent-config-store.js";
+import type { ProductCreateParams, ProductStatus, ProductSummary } from "../runtime/infra/acp-types.js";
+export interface ProductCallbacks {
+    log?: {
+        info(msg: string): void;
+        warn(msg: string): void;
+    };
+    onTaskStarted?: (productId: string, taskId: string, assignee: string) => void;
+    onTaskCompleted?: (productId: string, taskId: string, result: string) => void;
+    onTaskFailed?: (productId: string, taskId: string, error: string) => void;
+    onCheckpointed?: (productId: string, timestamp: string) => void;
+    onBudgetWarning?: (productId: string, usedTokens: number, maxTotalTokens: number, percentage: number) => void;
+    onCompleted?: (productId: string, summary: string) => void;
+}
+export declare class ProductOrchestrator {
+    private processManager;
+    private acpDetector;
+    private configStore;
+    private callbacks;
+    private sessions;
+    constructor(processManager: AgentProcessManager, acpDetector: AcpDetector, configStore: AgentConfigStore | null, callbacks?: ProductCallbacks);
+    /**
+     * Create a new Product Mode session.
+     */
+    create(params: ProductCreateParams): Promise<string>;
+    /** Resume a product from persisted state. */
+    resume(productId: string, cwd?: string): Promise<void>;
+    /** Pause a running product. */
+    pause(productId: string): Promise<void>;
+    /** Manual checkpoint. */
+    checkpoint(productId: string): Promise<void>;
+    /** Delete a product session, pausing first if active. */
+    delete(productId: string): Promise<void>;
+    /** Get product status. */
+    getStatus(productId: string): ProductStatus | null;
+    /** List all products (in-memory + on-disk). */
+    list(cwd?: string): Promise<ProductSummary[]>;
+    private scheduleNext;
+    private dispatchTask;
+    private runTask;
+    private finishProduct;
+    private buildPersistedState;
+}

package/dist/types/orchestration/dag-scheduler.d.ts

@@ -0,0 +1,72 @@
+/**
+ * DAG Scheduler — topological task scheduling for Product Mode.
+ *
+ * Manages a directed acyclic graph of tasks with dependencies.
+ * Ensures tasks only execute when all prerequisites are satisfied.
+ */
+import type { ProductTaskDef, ProductTaskStatus } from "../runtime/infra/acp-types.js";
+export interface TaskNode {
+    taskId: string;
+    assignee: string;
+    prompt: string;
+    dependsOn: string[];
+    status: ProductTaskStatus;
+    result?: string;
+    error?: string;
+    startedAt?: number;
+    completedAt?: number;
+}
+export declare class DagScheduler {
+    private nodes;
+    constructor(tasks: ProductTaskDef[]);
+    /** Get all task nodes. */
+    getAllTasks(): TaskNode[];
+    /** Get a single task node by ID. */
+    getTask(taskId: string): TaskNode | undefined;
+    /**
+     * Get tasks ready to run: status=pending and all dependencies completed.
+     */
+    getReadyTasks(): TaskNode[];
+    /** Mark a task as running. */
+    markRunning(taskId: string): void;
+    /** Mark a task as completed with result. */
+    markCompleted(taskId: string, result: string): void;
+    /** Mark a task as failed with error. */
+    markFailed(taskId: string, error: string): void;
+    /** Mark a task as paused. */
+    markPaused(taskId: string): void;
+    /** Resume a paused task back to pending. */
+    resumePaused(taskId: string): void;
+    /** Check if all tasks are terminal (completed, failed, or blocked by failed deps). */
+    isFinished(): boolean;
+    /** Check if the product completed successfully (all tasks completed). */
+    isAllCompleted(): boolean;
+    /** Get tasks that are blocked by failed dependencies. */
+    getBlockedTasks(): TaskNode[];
+    /** Pause all running tasks. */
+    pauseAll(): void;
+    /** Resume all paused tasks back to pending. */
+    resumeAll(): void;
+    /** Serialize for persistence. */
+    serialize(): Array<{
+        taskId: string;
+        assignee: string;
+        prompt: string;
+        dependsOn: string[];
+        status: ProductTaskStatus;
+        result?: string;
+        error?: string;
+        startedAt?: number;
+        completedAt?: number;
+    }>;
+    /** Restore from persisted data. */
+    restore(data: Array<{
+        taskId: string;
+        status: ProductTaskStatus;
+        result?: string;
+        error?: string;
+        startedAt?: number;
+        completedAt?: number;
+    }>): void;
+    private validateDag;
+}

package/dist/types/orchestration/product-budget.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Product Budget — token/time budget enforcement for Product Mode.
+ *
+ * Tracks cumulative token usage and elapsed time across all agent instances.
+ * Emits 80% warning and enforces 100% hard limit.
+ */
+import type { ProductBudget } from "../runtime/infra/acp-types.js";
+import type { AcpUsageTracker } from "../runtime/infra/acp-usage-tracker.js";
+/** Budget state and enforcement result. */
+export type BudgetAction = "ok" | "warning" | "exceeded";
+export interface BudgetCheck {
+    action: BudgetAction;
+    percentage: number;
+    usedTokens: number;
+    maxTotalTokens?: number;
+    elapsed: number;
+    maxDuration?: number;
+}
+export declare class ProductBudgetTracker {
+    private maxTotalTokens?;
+    private maxDuration?;
+    private usedTokens;
+    private startedAt;
+    private warningEmitted;
+    constructor(budget?: {
+        maxTotalTokens?: number;
+        maxDuration?: number;
+    });
+    /** Add tokens from a usage tracker snapshot. */
+    addUsage(inputTokens: number, outputTokens: number): void;
+    /** Add tokens from an ACP usage tracker. */
+    addFromTracker(tracker: AcpUsageTracker): void;
+    /** Get current elapsed time in ms. */
+    getElapsed(): number;
+    /** Get the budget snapshot. */
+    getBudget(): ProductBudget;
+    /**
+     * Check budget status. Returns:
+     * - "ok": within budget
+     * - "warning": 80%+ but not exceeded
+     * - "exceeded": over 100%, should pause
+     */
+    check(): BudgetCheck;
+    /** Restore from persisted budget data. */
+    restore(data: {
+        usedTokens: number;
+        startedAt: number;
+        warningEmitted: boolean;
+    }): void;
+    /** Serialize for persistence. */
+    serialize(): {
+        usedTokens: number;
+        startedAt: number;
+        warningEmitted: boolean;
+    };
+}

package/dist/types/orchestration/product-checkpoint.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Product Checkpoint — automatic and manual checkpoint triggers.
+ *
+ * Rules:
+ *  - Auto-checkpoint on task completion
+ *  - 5 min fallback timer for active products
+ *  - 30 min timer for long-running products (>48h)
+ *  - Manual checkpoint via product.checkpoint RPC
+ */
+import type { PersistedProductState } from "./product-persistence.js";
+export interface CheckpointCallbacks {
+    /** Called after each checkpoint save. */
+    onCheckpoint?: (productId: string, timestamp: string) => void;
+    /** Return current state snapshot for periodic auto-saves. */
+    getState?: () => PersistedProductState | null;
+    log?: {
+        info(msg: string): void;
+        warn(msg: string): void;
+    };
+}
+export declare class ProductCheckpointManager {
+    private callbacks;
+    /** Fallback interval (5 min default, 30 min for >48h long-running). */
+    private static readonly DEFAULT_INTERVAL;
+    private static readonly LONG_RUNNING_INTERVAL;
+    private static readonly LONG_RUNNING_THRESHOLD;
+    private timer;
+    private lastCheckpointAt;
+    private cwd?;
+    constructor(callbacks?: CheckpointCallbacks);
+    /** Start periodic checkpointing for a product. */
+    start(cwd?: string): void;
+    /** Stop periodic checkpointing. */
+    stop(): void;
+    /** Get the appropriate checkpoint interval based on elapsed time. */
+    getInterval(elapsedMs: number): number;
+    /** Check if a checkpoint is due based on elapsed time since last checkpoint. */
+    isDue(elapsedMs: number): boolean;
+    /**
+     * Perform a checkpoint: save state to disk and notify.
+     * Called on task completion or by periodic timer.
+     */
+    checkpoint(state: PersistedProductState): Promise<void>;
+    /** Get the time of last checkpoint. */
+    getLastCheckpointAt(): number;
+}

package/dist/types/orchestration/product-persistence.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Product Persistence — read/write Product Mode state to disk.
+ *
+ * State is stored at `<project>/.qlogicagent/products/<productId>/product-state.json`.
+ * Product listing is done by enumerating subdirectories.
+ */
+import type { ProductPhase, ProductTaskStatus, ProductInstanceDef } from "../runtime/infra/acp-types.js";
+export interface PersistedProductState {
+    productId: string;
+    name: string;
+    phase: ProductPhase;
+    cwd: string;
+    instances: ProductInstanceDef[];
+    tasks: Array<{
+        taskId: string;
+        assignee: string;
+        prompt: string;
+        dependsOn: string[];
+        status: ProductTaskStatus;
+        result?: string;
+        error?: string;
+        startedAt?: number;
+        completedAt?: number;
+    }>;
+    budget: {
+        maxTotalTokens?: number;
+        maxDuration?: number;
+        usedTokens: number;
+        startedAt: number;
+        warningEmitted: boolean;
+    };
+    createdAt: string;
+    lastCheckpointAt: string;
+}
+/** Save product state to disk. */
+export declare function saveProductState(state: PersistedProductState, cwd?: string): Promise<void>;
+/** Load product state from disk. Returns undefined if not found. */
+export declare function loadProductState(productId: string, cwd?: string): Promise<PersistedProductState | undefined>;
+/** List all product IDs with their persisted state. */
+export declare function listProducts(cwd?: string): Promise<PersistedProductState[]>;

package/dist/types/orchestration/product-worktree.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Product Worktree — shared git worktree helpers for Solo and Product Mode.
+ */
+/** Find the git repository root from a working directory. */
+export declare function findGitRoot(cwd: string): Promise<string | null>;
+/** Create an isolated git worktree. Returns the worktree path. */
+export declare function createWorktree(gitRoot: string, name: string, baseBranch?: string): Promise<string>;
+/** Get a git diff stat from a worktree. */
+export declare function getWorktreeDiff(worktreePath: string): Promise<string>;
+/** Remove a git worktree. */
+export declare function removeWorktree(gitRoot: string, path: string): Promise<void>;
+/** Merge a worktree branch into the current branch. */
+export declare function mergeWorktree(gitRoot: string, worktreeBranch: string): Promise<string>;

package/dist/types/orchestration/solo-evaluator.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Solo Mode Evaluator — parallel N-agent PK with leader evaluation.
+ *
+ * Flow:
+ *   1. solo.start → create N isolated git worktrees, spawn N agents in parallel
+ *   2. Each agent receives the same task prompt in its own worktree
+ *   3. On completion, collect each agent's resultText + git diff
+ *   4. Leader agent evaluates all results → picks winner
+ *   5. solo.select → merge winning worktree, clean up others
+ *
+ * Degradation: if K agents fail but ≥1 succeeds, evaluation still proceeds.
+ */
+import type { AgentProcessManager } from "../runtime/infra/agent-process.js";
+import type { AcpDetector } from "../runtime/infra/acp-detector.js";
+import type { AgentConfigStore } from "../runtime/infra/agent-config-store.js";
+import type { SoloAgentState, SoloEvaluation, SoloStatus, SoloStartParams, SoloSelectParams } from "../runtime/infra/acp-types.js";
+export interface SoloCallbacks {
+    log?: {
+        info(msg: string): void;
+        warn(msg: string): void;
+        debug?(msg: string): void;
+    };
+    onProgress?: (soloId: string, agentId: string, state: SoloAgentState, progress?: string) => void;
+    onEvaluation?: (soloId: string, evaluation: SoloEvaluation) => void;
+    /** Streaming text delta from a competing agent (forwarded from child process). */
+    onAgentDelta?: (soloId: string, agentId: string, text: string) => void;
+}
+export declare class SoloEvaluator {
+    private processManager;
+    private acpDetector;
+    private configStore;
+    private callbacks;
+    private sessions;
+    constructor(processManager: AgentProcessManager, acpDetector: AcpDetector, configStore: AgentConfigStore | null, callbacks?: SoloCallbacks);
+    /**
+     * Start a Solo Mode PK session.
+     * Creates worktrees, spawns agents in parallel, waits for completion, then evaluates.
+     */
+    start(params: SoloStartParams): Promise<string>;
+    /** Get the current status of a solo session. */
+    getStatus(soloId: string): SoloStatus | null;
+    /** Cancel a running solo session. Kill all agents and clean up worktrees. */
+    cancel(soloId: string): Promise<void>;
+    /**
+     * Select a winner and merge their worktree into the main branch.
+     */
+    select(params: SoloSelectParams): Promise<string>;
+    /** List all solo sessions. */
+    listSessions(): SoloStatus[];
+    /** Delete a solo session, killing agents and cleaning up worktrees if still active. */
+    delete(soloId: string): Promise<void>;
+    /**
+     * Build an evaluation prompt and send to the leader agent (first successful).
+     * Returns evaluation result.
+     */
+    private evaluate;
+    private parseEvaluationResponse;
+    private cleanupWorktrees;
+}

package/dist/types/orchestration/subagent/fork-subagent.d.ts

@@ -28,6 +28,8 @@ export interface ForkContext {
     abortSignal?: AbortSignal;
     /** Parent's agent ID for lineage tracking. */
     parentAgentId: string;
+    /** Isolated worktree path for this fork child (CC team worktree parity). */
+    worktreePath?: string;
 }
 export interface ForkChildConfig {
     /** The agent definition to run. */

package/dist/types/orchestration/subagent/task-types.d.ts

@@ -101,6 +101,10 @@ export interface InProcessTeammateTaskState extends TaskStateBase {
     permissionMode: string;
     /** Async mailbox for coordinator ↔ worker communication. */
     mailboxId?: string;
+    /** Isolated git worktree path for this teammate (CC team worktree parity). */
+    worktreePath?: string;
+    /** Worktree branch name (for cleanup). */
+    worktreeBranch?: string;
 }
 /** A single dream agent turn — text output + tool use count. */
 export interface DreamTurn {

package/dist/types/orchestration/tool-cascade.d.ts

@@ -10,9 +10,9 @@
  * Two levels of provider tool integration:
  *
  * 1. **D-level (builtin tools)**: Injected directly into chat completion request
- *    via `builtinWebSearch` / `builtinCodeInterpreter` quirks.
+ *    via `builtinWebSearch` / `builtinCodeInterpreter` / `builtinUrlContext` / `builtinMapsGrounding` / `builtinFileSearch` quirks.
  *    The LLM decides to use these inline during generation — no agent intervention.
- *    → Handled by openai-chat.ts transport layer.
+ *    → Handled by openai-chat.ts (GLM/Kimi) and gemini-generatecontent.ts (Google) transport layers.
  *
  * 2. **C-level (independent APIs)**: Discrete API endpoints the agent calls explicitly
  *    as tool steps (web_search, reader, tokenizer, moderations).

package/dist/types/protocol/methods.d.ts

@@ -8,6 +8,7 @@
  */
 import type { ChatMessage, ToolDefinition } from "../agent/types.js";
 import type { TodoItem } from "../contracts/todo.js";
+import type { AgentDescriptor, AgentConfig, AgentsScanParams, AgentsConfigParams, AgentsSetConfigParams, AgentsGetConfigParams, AgentsRemoveConfigParams, AgentsSetGatewayParams, SoloStatus, SoloStartParams, SoloIdParams, SoloSelectParams, ProductCreateParams, ProductIdParams, ProductStatus, ProductSummary } from "../runtime/infra/acp-types.js";
 export interface InitializeParams {
     protocolVersion: string;
     host?: {
@@ -392,6 +393,97 @@ export interface RpcMethodMap {
             received: boolean;
         };
     };
+    "agents.scan": {
+        params: AgentsScanParams;
+        result: AgentDescriptor[];
+    };
+    "agents.list": {
+        params: undefined;
+        result: AgentDescriptor[];
+    };
+    "agents.config": {
+        params: AgentsConfigParams;
+        result: {
+            ok: true;
+        };
+    };
+    "agents.setConfig": {
+        params: AgentsSetConfigParams;
+        result: {
+            ok: true;
+        };
+    };
+    "agents.getConfig": {
+        params: AgentsGetConfigParams;
+        result: AgentConfig | null;
+    };
+    "agents.removeConfig": {
+        params: AgentsRemoveConfigParams;
+        result: {
+            ok: true;
+        };
+    };
+    "agents.setGateway": {
+        params: AgentsSetGatewayParams;
+        result: {
+            ok: true;
+        };
+    };
+    "solo.start": {
+        params: SoloStartParams;
+        result: {
+            soloId: string;
+        };
+    };
+    "solo.status": {
+        params: SoloIdParams;
+        result: SoloStatus | null;
+    };
+    "solo.cancel": {
+        params: SoloIdParams;
+        result: {
+            ok: true;
+        };
+    };
+    "solo.select": {
+        params: SoloSelectParams;
+        result: {
+            ok: true;
+            mergedBranch: string;
+        };
+    };
+    "product.create": {
+        params: ProductCreateParams;
+        result: {
+            productId: string;
+        };
+    };
+    "product.resume": {
+        params: ProductIdParams;
+        result: {
+            ok: true;
+        };
+    };
+    "product.pause": {
+        params: ProductIdParams;
+        result: {
+            ok: true;
+        };
+    };
+    "product.checkpoint": {
+        params: ProductIdParams;
+        result: {
+            ok: true;
+        };
+    };
+    "product.status": {
+        params: ProductIdParams;
+        result: ProductStatus | null;
+    };
+    "product.list": {
+        params: undefined;
+        result: ProductSummary[];
+    };
 }
 /** All known RPC method names. */
 export type RpcMethod = keyof RpcMethodMap;