qlogicagent 2.10.26 → 2.10.28

package/dist/types/cli/handlers/workflow-handler.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Workflow mode handlers — ACP surface for the automation workflow engine (plan M2 接入).
+ * Exposes workflow.create/get/describe/patch/run/setActive/list/delete over the same RPC host
+ * as product/solo. The engine (WorkflowController) lives in qlogicagent (D12); triggers live in
+ * the gateway (D7/B) and drive `workflow.run` over ACP.
+ *
+ * fail-loud throughout (plan §1.5): unknown id / illegal patch / missing capability all throw.
+ */
+import { AgentProcessManager } from "../../runtime/infra/agent-process.js";
+import type { AcpDetector } from "../../runtime/infra/acp-detector.js";
+import { type AgentRpcError, type AgentRpcRequest } from "../../protocol/wire/index.js";
+import { WorkflowController } from "../../orchestration/workflow/workflow-controller.js";
+import { WorkflowStore } from "../../orchestration/workflow/workflow-store.js";
+import { WorkflowScheduler } from "../../orchestration/workflow/workflow-scheduler.js";
+export interface WorkflowCoordinatorHost {
+    acpDetector: AcpDetector;
+    getActiveProjectRoot(): string;
+    handleMcpToolCall(memberId: string, tool: string, args: Record<string, unknown>): Promise<unknown>;
+    sendNotification(method: string, params: Record<string, unknown>): void;
+    workflowController: WorkflowController | null;
+    workflowStore: WorkflowStore | null;
+    workflowProcessManager: AgentProcessManager | null;
+    workflowScheduler: WorkflowScheduler | null;
+}
+export interface WorkflowHandlerHost extends WorkflowCoordinatorHost {
+    sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
+}
+/** Build (once) the WorkflowController wired to real qlogicagent capabilities (no mocks, §1.5). */
+export declare function ensureWorkflowController(this: WorkflowCoordinatorHost): WorkflowController;
+export declare function handleWorkflowCreate(this: WorkflowHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleWorkflowGet(this: WorkflowHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleWorkflowDescribe(this: WorkflowHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleWorkflowPatch(this: WorkflowHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleWorkflowRun(this: WorkflowHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleWorkflowSetActive(this: WorkflowHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleWorkflowList(this: WorkflowHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleWorkflowDelete(this: WorkflowHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleWorkflowOnImMessage(this: WorkflowHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleWorkflowOnWebhook(this: WorkflowHandlerHost, msg: AgentRpcRequest): Promise<void>;

package/dist/types/orchestration/workflow/workflow-service.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Process-level WorkflowController singleton (single-track, D17 "one store / one engine").
+ *
+ * The ACP workflow-handler builds the fully-wired controller (real ExecutorHost: agent/tool/mcp)
+ * and publishes it here. The agent-facing `workflow` tool resolves the same instance so authoring
+ * (create/patch) and running share one engine + one store. When the engine has not been
+ * initialized (e.g. a bare CLI tool turn before any ACP workflow call), callers that only need
+ * authoring can fall back to a store-only controller; `run` fail-louds (no silent no-op).
+ */
+import type { WorkflowController } from "./workflow-controller.js";
+/** Publish the fully-wired controller (called by ensureWorkflowController). */
+export declare function setWorkflowController(ctrl: WorkflowController): void;
+/** The live, run-capable controller, or null if the engine has not been initialized yet. */
+export declare function getWorkflowController(): WorkflowController | null;

package/dist/types/skills/tools/workflow-tool.d.ts

@@ -1,44 +1,45 @@
 import type { PortableTool } from "../portable-tool.js";
-export type WorkflowAction = "list" | "run" | "describe";
-export interface WorkflowStep {
-    /** Step identifier */
+export type WorkflowAction = "list" | "get" | "describe" | "create" | "patch" | "setActive" | "run" | "delete";
+export interface WorkflowToolParams {
+    action: WorkflowAction;
+    workflowId?: string;
+    name?: string;
+    def?: Record<string, unknown>;
+    patch?: unknown[];
+    baseRev?: number;
+    scope?: string[];
+    active?: boolean;
+}
+export interface WorkflowToolRecord {
     id: string;
-    /** Tool name to invoke */
-    tool: string;
-    /** Tool arguments (supports ${prev.result} interpolation) */
-    args: Record<string, unknown>;
-    /** Step IDs this step depends on (for DAG ordering) */
-    dependsOn?: string[];
-    /** Condition expression: "always" | "on_success" | "on_failure" (default: "on_success") */
-    condition?: "always" | "on_success" | "on_failure";
-    /** Human-readable label */
-    label?: string;
+    name?: string;
+    rev?: number;
+    active?: boolean;
 }
-export interface WorkflowDefinition {
-    /** Workflow name */
-    name: string;
-    /** Description */
-    description?: string;
-    /** Ordered steps (executed in dependency order) */
-    steps: WorkflowStep[];
-    /** Variables that can be overridden at runtime */
-    variables?: Record<string, string>;
+export interface WorkflowRunOutcome {
+    status?: string;
 }
-export interface WorkflowToolParams {
-    /** Action to perform */
-    action: WorkflowAction;
-    /** Workflow name (for run/describe) */
-    workflow?: string;
-    /** Variable overrides (for run) */
-    variables?: Record<string, string>;
+export interface WorkflowToolService {
+    list(): Promise<WorkflowToolRecord[]>;
+    get(id: string): Promise<unknown>;
+    describe(id: string): Promise<string>;
+    create(input: {
+        id: string;
+        name: string;
+        def: Record<string, unknown>;
+        active: boolean;
+    }): Promise<WorkflowToolRecord>;
+    patch(id: string, envelope: {
+        patch: unknown[];
+        baseRev?: number;
+        scope?: string[];
+    }): Promise<unknown>;
+    setActive(id: string, active: boolean): Promise<WorkflowToolRecord>;
+    run(id: string): Promise<WorkflowRunOutcome>;
+    delete(id: string): Promise<void>;
 }
 export interface WorkflowToolDeps {
-    /** Execute a tool by name and return its text result */
-    invokeTool(toolName: string, args: Record<string, unknown>, signal?: AbortSignal): Promise<{
-        result: string;
-        error?: string;
-    }>;
-    /** Get current working directory */
-    getCwd(): string;
+    /** Resolve the host-owned workflow service port. Keeps skills independent from orchestration internals. */
+    getService(): WorkflowToolService;
 }
 export declare function createWorkflowTool(deps: WorkflowToolDeps): PortableTool<WorkflowToolParams>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qlogicagent",
-  "version": "2.10.26",
+  "version": "2.10.28",
   "description": "XiaozhiClaw Agent CLI — subprocess architecture (JSON-RPC over stdio)",
   "type": "module",
   "main": "dist/index.js",