qlogicagent 2.24.1 → 2.24.2

package/dist/types/orchestration/workflow/expression.d.ts

@@ -1,60 +0,0 @@
-/**
- * Restricted workflow expression evaluator used to bind node params to upstream data.
- *
- * HARD SECURITY LINE: NO arbitrary JS eval. This is a tiny recursive-descent interpreter over a
- * fixed grammar — property/index path access + a whitelist of pure functions only. Unattended
- * triggers make eval an injection surface, so arbitrary script is explicitly out of v1.
- *
- * Supported:
- *   - context roots: $input · $json · $node("name") · $now · $vars · $trigger
- *   - accessors: `.prop` and `[index]` / `["key"]`
- *   - literals: string ('..' / ".."), number, true/false/null
- *   - whitelist functions: len, upper, lower, default, jsonpath, date,
- *     eq, ne, gt, gte, lt, lte, not, and, or, contains
- *
- * fail-loud: unknown roots/functions, reads through null/undefined, and prototype-escape keys
- * all throw. Absent *leaf* keys evaluate to undefined (so `default(x, fb)` works).
- */
-import type { PortMap } from "./data-item.js";
-export interface ExpressionContext {
-    /** $input — this node's input ports. */
-    input?: PortMap;
-    /** $json — shorthand for the current item's json (typically input.default[0].json). */
-    json?: Record<string, unknown>;
-    /** $node("X") — completed upstream node outputs, keyed by node id/name. */
-    nodes?: Record<string, {
-        output: PortMap;
-    }>;
-    /** $now — injectable clock for determinism; defaults to real time. */
-    now?: () => Date;
-    /** $vars — workflow-level variables. */
-    vars?: Record<string, unknown>;
-    /** $trigger — trigger payload. */
-    trigger?: Record<string, unknown>;
-}
-/**
- * Evaluate a single expression body (the text inside `{{ }}`, braces stripped).
- * Returns the raw value (object/array/number/string/boolean/null/undefined).
- */
-export declare function evaluateExpression(body: string, ctx: ExpressionContext): unknown;
-/**
- * Static syntax+semantics gate: is `body` a valid expression of THIS language (no evaluation)?
- * Beyond the grammar, it statically enforces what evalNode would reject at run time anyway:
- * known context roots, whitelist function names, and "$node(...) is the only callable".
- * Returns null when valid, else the error message. The n8n expression converter uses this as
- * its single-track output gate — anything it emits must pass here.
- */
-export declare function validateExpressionSyntax(body: string): string | null;
-/**
- * Resolve a binding template:
- *   - exactly `{{ expr }}` (whole string) → returns the raw evaluated value (keeps type)
- *   - text with embedded `{{ }}` → string interpolation (each sub-expression stringified;
- *     a sub-expression resolving to null/undefined throws — fail-loud)
- *   - no `{{ }}` → returned unchanged
- */
-export declare function resolveBinding(template: string, ctx: ExpressionContext): unknown;
-/**
- * Recursively resolve every string value in a params object against the context.
- * Non-string leaves are returned untouched. Arrays and nested objects are walked.
- */
-export declare function resolveParams(params: Record<string, unknown>, ctx: ExpressionContext): Record<string, unknown>;

package/dist/types/orchestration/workflow/host-executors.d.ts

@@ -1,15 +0,0 @@
-/**
- * Host-backed NodeExecutors (M3 bridge contract; plan D12/D13, spec §B).
- *
- * The engine is a pure executor: kinds that need real-world capabilities (agent / http / channel)
- * are fulfilled by an injected `ExecutorHost`. Canonical Action execution is injected by Runtime.
- * (or the qlogicagent CLI host) provides a real host; the engine never imports those subsystems.
- *
- * These executors are REAL (not mocks): they read the node's resolved params + inputs and delegate
- * to the host. fail-loud — invoking a host-backed kind with no host throws (no silent fallback).
- */
-import type { NodeExecutor } from "./node-schema.js";
-/** Host-backed canonical and imported node kinds. Runtime injects the canonical Action executor. */
-export declare const hostExecutors: Record<string, NodeExecutor>;
-/** Host-backed kind names (used by callers to know which kinds need a host). */
-export declare const HOST_BACKED_KINDS: string[];

package/dist/types/orchestration/workflow/n8n-expression.d.ts

@@ -1,48 +0,0 @@
-/**
- * n8n expression → restricted-language converter (IT-11, spec D35).
- *
- * n8n expressions are arbitrary JS inside `={{ }}`; our language is a fixed grammar
- * (path access + literal + whitelist functions — see expression.ts, D6 hard line: NO eval).
- * So conversion is a CURATED rewrite of the safe overlap, gated by our own parser:
- * every rewritten body must pass `validateExpressionSyntax` or the whole parameter is
- * flagged "manual" — we never emit anything our language can't parse, and we never
- * approximate semantics silently.
- *
- * Convertible subset (n8n → ours):
- *   $json.path / $json["k"]                     → unchanged
- *   $node["X"].json.y                           → $node("X").output.default[0].json.y
- *   $('X').item.json.y / $('X').first().json.y  → $node("X").output.default[0].json.y
- *   $items("X")[i].json.y                       → $node("X").output.default[i].json.y
- *   $input.item.json / $input.first().json      → $json
- *   $now                                        → $now (note: n8n is Luxon, ours is Date)
- * Anything else ($today, $binary, $workflow, .method() calls, operators, …) → manual.
- */
-export type ExpressionConversion = {
-    ok: true;
-    converted: string;
-    notes: string[];
-} | {
-    ok: false;
-    reason: string;
-};
-/**
- * Convert one n8n parameter STRING. n8n marks expression strings with a leading `=`;
- * inside, `{{ }}` segments are evaluated and the rest is literal text. Strings without
- * the `=` prefix are plain literals (returned unchanged, not counted as conversions).
- */
-export declare function convertN8nExpression(raw: string): ExpressionConversion | null;
-export interface ParamConversionStats {
-    converted: number;
-    manual: Array<{
-        path: string;
-        raw: string;
-        reason: string;
-    }>;
-    notes: string[];
-}
-/**
- * Deep-walk a params object converting every n8n expression string in place (returns a new
- * object). Unconvertible expressions KEEP their raw n8n text (visible, greppable) and are
- * reported in `stats.manual` — explicit degradation, never silent loss.
- */
-export declare function convertN8nParams(params: Record<string, unknown>, stats: ParamConversionStats, basePath?: string): Record<string, unknown>;

package/dist/types/orchestration/workflow/n8n-import.d.ts

@@ -1,64 +0,0 @@
-import type { WorkflowDef } from "./node-schema.js";
-import type { WorkflowTemplateSetupManifest } from "./workflow-template-setup.js";
-export interface N8nImportOptions {
-    strictTemplates?: boolean;
-}
-export interface N8nNodeReport {
-    id: string;
-    n8nType: string;
-    outcome: "converted" | "partial" | "manual" | "skipped" | "unsupported";
-    notes: string[];
-}
-export interface N8nCredentialRequirement {
-    nodeId: string;
-    n8nCredentialType: string;
-    label?: string;
-}
-export interface N8nBindingRequirement {
-    models: Array<{
-        nodeId: string;
-        n8nCredentialType: string;
-        modelPurpose: string;
-        label?: string;
-    }>;
-    agents: Array<{
-        nodeId: string;
-        agentId?: string;
-        fallback: boolean;
-        label?: string;
-    }>;
-    connections: Array<{
-        nodeId: string;
-        n8nCredentialType: string;
-        connectionType: string;
-        label?: string;
-    }>;
-}
-export interface N8nConversionReport {
-    status: "full" | "partial" | "manual";
-    nodes: N8nNodeReport[];
-    expressions: {
-        converted: number;
-        manual: Array<{
-            nodeId: string;
-            path: string;
-            raw: string;
-            reason: string;
-        }>;
-    };
-    credentials: N8nCredentialRequirement[];
-    bindings: N8nBindingRequirement;
-    notes: string[];
-}
-export interface N8nImportResult {
-    name: string;
-    def: WorkflowDef;
-    report: N8nConversionReport;
-}
-/** Turn imported n8n credential references into one centralized Host-owned connection form. */
-export declare function n8nConnectionSetupManifest(report: N8nConversionReport): WorkflowTemplateSetupManifest | undefined;
-export declare class N8nImportError extends Error {
-    readonly errors: string[];
-    constructor(errors: string[]);
-}
-export declare function convertN8nWorkflow(input: string | unknown, workflowId: string, opts?: N8nImportOptions): N8nImportResult;

package/dist/types/orchestration/workflow/n8n-template-compat.d.ts

@@ -1,5 +0,0 @@
-export declare const N8N_TEMPLATE_TYPE_MAP: Record<string, string>;
-export declare function isModelCredentialType(type: string): boolean;
-export declare function isAgentKind(kind: string): boolean;
-export declare function modelPurposeForCredential(type: string): string;
-export declare function suggestConnectionType(n8nType: string, credentialType: string): string;

package/dist/types/orchestration/workflow/node-registry.d.ts

@@ -1,32 +0,0 @@
-/**
- * NodeExecutor registry (M2; plan §M2 "NodeExecutor 注册表").
- *
- * Single source of truth mapping node `kind` → executor. fail-loud on unknown kinds and
- * duplicate registration. Built-in deterministic executors (set / if / merge) register here;
- * host-backed executors (agent / tool / http / mcp / channel) are injected by the host so the
- * engine stays a pure executor (plan D12/D13).
- */
-import type { NodeExecutor } from "./node-schema.js";
-/**
- * Node kinds whose builtin executor is a Host-binding placeholder.
- * installHostExecutors overrides ONLY these when already present; any other
- * pre-registered kind is kept. Single source of the "rebindable kind" rule.
- */
-export declare const REBINDABLE_NODE_KINDS: Set<string>;
-export declare class NodeRegistry {
-    private executors;
-    constructor(includeBuiltins?: boolean);
-    register(kind: string, executor: NodeExecutor): void;
-    /** Replace an existing executor (e.g. host overrides a built-in). Must already exist. */
-    override(kind: string, executor: NodeExecutor): void;
-    /**
-     * Wire host-backed executors — the single source of the host-wiring rule used by the
-     * runtime, the gateway handler, and tests. Absent kinds are registered; an already-present
-     * rebindable kind (whose builtin is a Host-binding placeholder) is
-     * overridden; any other already-present kind is kept (caller's pre-registration wins).
-     */
-    installHostExecutors(executors: Record<string, NodeExecutor>): void;
-    has(kind: string): boolean;
-    get(kind: string): NodeExecutor;
-    kinds(): string[];
-}

package/dist/types/orchestration/workflow/node-schema.d.ts

@@ -1,249 +0,0 @@
-/**
- * Workflow node schema + NodeExecutor contract (M2; plan D10, spec §A1/§A6).
- *
- * One declarative schema, three consumers: inline UI (M4) / execution (here) / NL generation (M5).
- * Control/data separation (spec §A1): the DagScheduler owns control; executors are pure data
- * transforms `(inputs, params, ctx) → { outputs, firedPorts }`.
- */
-import type { DataItem, PortMap } from "./data-item.js";
-/** Port type for connection validation (spec §A6). "any" connects to anything. */
-export type PortType = "any" | "string" | "number" | "boolean" | "json" | "image" | "video" | "audio" | "binary";
-export interface PortDef {
-    name: string;
-    type?: PortType;
-}
-/**
- * Port-type compatibility — the SINGLE truth for connection validation (R5 手动连线)。
- * add_edge 拿它兜底;画布的即时拒绝只是这条规则的前端镜像。
- * 规则:any 通配两侧;同型相通;媒体(image/video/audio)可入 binary(媒体 ⊆ 二进制,
- * 例如"存文件"节点收任意二进制)。其余不通。
- */
-export declare function portTypesCompatible(src: PortType | undefined, dst: PortType | undefined): boolean;
-/** Declarative workflow node (persisted; may carry `{{ }}` expressions in params). */
-export interface WorkflowNodeDef {
-    id: string;
-    kind: string;
-    /** Optional human-friendly display name (rename_node patch op; spec D17 §C). */
-    name?: string;
-    params?: Record<string, unknown>;
-    /** Output ports; default ["default"]. if→["true","false"], loop→["loop","done"]. */
-    outPorts?: string[];
-    /**
-     * Out-port data types(端口名 → 类型;缺省 "any")。与 outPorts(名字,控制流)刻意分离:
-     * DagScheduler 只关心端口名,类型只参与连线校验(add_edge)与画布 Handle 配色 —— 改
-     * outPorts 为混合型会波及全部调度消费方,不值得。
-     */
-    outPortTypes?: Record<string, PortType>;
-    /** Input ports (for type-checked routing); default ["default"]. */
-    inPorts?: PortDef[];
-    joinPolicy?: "all" | "any";
-    maxIterations?: number;
-    /** Retry the executor on failure: total attempts = maxTries (≥1); exponential backoff from backoffMs (default 1000). */
-    retry?: {
-        maxTries: number;
-        backoffMs?: number;
-    };
-    /** Per-attempt deadline; the executor's signal aborts when exceeded (counts as a failure → retry applies). */
-    timeoutMs?: number;
-    /**
-     * What a FINAL failure (after retries) does to the run:
-     *   "stop"(default)= run fails loud; "continue" = node marked failed, fires no ports
-     *   (downstream skips), other branches keep running; "errorPort" = a DataItem with the
-     *   error routes out the "error" port (wire an error-handler/notify subgraph to it).
-     */
-    onError?: "stop" | "continue" | "errorPort";
-    /**
-     * Canvas position pinned by a manual drag (set_node_ui patch op). Layout-only — the
-     * engine never reads it; absent ⇒ the canvas auto-layouts the node. Travels with the
-     * def (Bundle/export/Hub/n8n-import) so a hand-arranged graph stays arranged.
-     */
-    ui?: {
-        x: number;
-        y: number;
-    };
-}
-/** A data edge (carries DataItem[]). fromPort/toPort default "default". */
-export interface DataEdge {
-    from: string;
-    to: string;
-    fromPort?: string;
-    toPort?: string;
-    loopBack?: boolean;
-}
-export interface WorkflowDef {
-    id: string;
-    nodes: WorkflowNodeDef[];
-    edges: DataEdge[];
-    /** Workflow-level variables exposed to expressions as $vars. */
-    vars?: Record<string, unknown>;
-}
-/**
- * SINGLE source of the attended/unattended split. Attended = a person is present right now:
- * manual (pressed 运行), intent (just SAID it, confirmed by default D22), form (just SUBMITTED
- * it, D34). Everything else (schedule / im-message / webhook) fires with nobody watching.
- * Lives here (leaf module) so both the gate and host-executors can import it cycle-free.
- */
-export declare function isUnattendedTrigger(kind: string): boolean;
-export interface ExecutorContext {
-    nodeId: string;
-    kind: string;
-    /** Owning workflow id (def.id) — lets host-backed nodes (approval) tag outbound notifications. */
-    workflowId?: string;
-    /** Durable run identity used by Host-backed observability and recovery projections. */
-    runId?: string;
-    /** This run's trigger kind (manual/schedule/…) — drives fine-grained unattended audits (IT-7b). */
-    triggerKind?: string;
-    /** 0-based; increments per loop iteration (drives the cache key, spec §A5). */
-    runIndex: number;
-    vars: Record<string, unknown>;
-    trigger?: Record<string, unknown>;
-    /** Injected clock for determinism. */
-    now: () => Date;
-    log?: {
-        info(m: string): void;
-        warn(m: string): void;
-    };
-    /** Host capabilities for host-backed and Runtime-injected node kinds. */
-    host?: ExecutorHost;
-    /** Cooperative cancellation for long-running host calls. */
-    signal?: AbortSignal;
-}
-/**
- * Capabilities the embedding HOST provides for node kinds the engine cannot fulfil on its own.
- * Production composition belongs to the xiaozhiclaw Gateway Host; qlogicagent exports the inert
- * executor contract and test/CLI adapters. A host-backed kind with no host fails loud.
- */
-export interface ExecutorHost {
-    /** Run an agent turn. Returns the agent's structured output as DataItem(s). */
-    runAgent(req: AgentHostRequest): Promise<DataItem[]>;
-    /** Run the currently configured workflow/text model. The host resolves provider/API key/model. */
-    runModel?(req: ModelHostRequest): Promise<DataItem[]>;
-    /** Perform an HTTP request (credentials resolved host-side). */
-    httpRequest(req: HttpHostRequest): Promise<DataItem[]>;
-    /** Invoke an MCP server tool. */
-    invokeMcp(req: McpHostRequest): Promise<DataItem[]>;
-    /** Execute an installed n8n ecosystem node in the Host-owned compatibility worker. */
-    runN8nNode?(req: N8nNodeHostRequest): Promise<Record<string, DataItem[]>>;
-    /** Send a message out through a channel (飞书/微信/…) via the xiaozhiclaw channel layer. */
-    sendChannel(req: ChannelHostRequest): Promise<DataItem[]>;
-    /** Project-scoped memory (memdir) read/write/search for the `memory` kind (spec D25). */
-    memory?(req: MemoryHostRequest): Promise<DataItem[]>;
-    /** Run another workflow as a step (D34); the host enforces cycle guards. */
-    runSubworkflow?(req: SubworkflowHostRequest): Promise<DataItem[]>;
-    /**
-     * Human-in-the-loop approval (D34): notify the owner and AWAIT the decision in-memory
-     * (the run stays "running"; the node shows pending). The Runtime Host persists suspended-run
-     * state and reconstructs the approval wait after restart.
-     */
-    approval?(req: ApprovalHostRequest): Promise<{
-        approved: boolean;
-        decidedAt: string;
-        note?: string;
-    }>;
-    /**
-     * D34 wait-until-webhook: suspend the branch until the given webhook path is called
-     * (same posture as approval). The Runtime Host persists the checkpoint and re-registers the
-     * webhook wait after restart.
-     */
-    waitWebhook?(req: WebhookWaitHostRequest): Promise<Record<string, unknown>>;
-}
-export interface AgentHostRequest {
-    agentId: string;
-    prompt: string;
-    input: DataItem[];
-    signal?: AbortSignal;
-}
-export declare function requireWorkflowAgentId(value: unknown): string;
-export interface ModelHostRequest {
-    prompt: string;
-    modelHint?: string;
-    temperature?: number;
-    maxTokens?: number;
-    input: DataItem[];
-    signal?: AbortSignal;
-}
-export interface HttpHostRequest {
-    method: string;
-    url: string;
-    headers?: Record<string, string>;
-    body?: unknown;
-    /** Stable across retries/recovery for downstream de-duplication. */
-    idempotencyKey?: string;
-    signal?: AbortSignal;
-}
-export interface McpHostRequest {
-    server: string;
-    tool: string;
-    args: Record<string, unknown>;
-    signal?: AbortSignal;
-}
-export interface N8nNodeHostRequest {
-    n8nType: string;
-    version?: number;
-    parameters: Record<string, unknown>;
-    connectionIds?: Record<string, string>;
-    input: DataItem[];
-    idempotencyKey?: string;
-    signal?: AbortSignal;
-}
-export interface ChannelHostRequest {
-    channel: string;
-    target?: string;
-    payload: unknown;
-    input: DataItem[];
-    idempotencyKey?: string;
-    signal?: AbortSignal;
-}
-export interface SubworkflowHostRequest {
-    workflowId: string;
-    /** The calling workflow's id — joins the cycle-guard chain so top-level runs count too. */
-    callerWorkflowId?: string;
-    /** Cross-project call target; absent = the calling workflow's own project root. */
-    projectId?: string;
-    /** Becomes the sub-run's $trigger payload (falls back to the upstream item's json). */
-    payload?: Record<string, unknown>;
-    input: DataItem[];
-    signal?: AbortSignal;
-}
-export interface ApprovalHostRequest {
-    nodeId: string;
-    /** Owning workflow id so the approval surface can name/locate the workflow. */
-    workflowId?: string;
-    /** Plain-language question shown to the owner (默认 "继续执行?"). */
-    prompt?: string;
-    /** Deadline for a decision; default 24h. What happens at the deadline is timeoutAction (default reject). */
-    timeoutMs?: number;
-    /** Timeout policy (default "reject"): "reject" fails the node but ANNOUNCES it (not a silent auto-deny);
-     *  "approve" auto-continues; "keepPending" stays suspended in the current Gateway process only. */
-    timeoutAction?: "approve" | "reject" | "keepPending";
-    input: DataItem[];
-    signal?: AbortSignal;
-}
-export interface WebhookWaitHostRequest {
-    /** Webhook path to wait for (normalized with a leading "/"). */
-    path: string;
-    nodeId: string;
-    workflowId?: string;
-    /** Auto-fail deadline; default 24h (a forever-pending branch is a leak, not patience). */
-    timeoutMs?: number;
-    signal?: AbortSignal;
-}
-export interface MemoryHostRequest {
-    op: "read" | "write" | "search";
-    /** Topic-file name; absent → operate on the always-visible index. */
-    key?: string;
-    /** Content for `write` (falls back to the upstream item's json when omitted). */
-    value?: unknown;
-    /** Query for `search`. */
-    query?: string;
-    input: DataItem[];
-    signal?: AbortSignal;
-}
-export interface NodeExecResult {
-    /** outPort → DataItem[]. */
-    outputs: PortMap;
-    /** Control nodes (if/loop) set this; data nodes omit → all outPorts fire. */
-    firedPorts?: string[];
-}
-/** A node executor: pure with respect to (inputs, params, ctx). NO hidden global state. */
-export type NodeExecutor = (inputs: PortMap, params: Record<string, unknown>, ctx: ExecutorContext) => Promise<NodeExecResult> | NodeExecResult;

package/dist/types/orchestration/workflow/params-schema.d.ts

@@ -1,69 +0,0 @@
-/**
- * Node params schema — single source for "what params does each node kind take" (spec R6 / D45).
- *
- * Each canonical node kind has one schema in KIND_PARAM_SCHEMAS. MCP tool argument schemas are
- * attached to Agent plugins or canonical Action choices by Runtime's Host-owned catalog.
- *
- * The schemas are a JSON-Schema subset aligned with the canvas SchemaArgsForm consumer
- * (type/enum/default/minimum/maximum/multipleOf/format/x-widget). `required` mirrors what the REAL
- * executors throw on (host-executors.ts / builtin-executors.ts) — not a wishlist.
- *
- * fail-loud posture: `validateParamsAgainstSchema` flags missing-required / wrong-enum / wrong-type
- * so the AI generation gate (AI-2) can reject and self-correct. Two deliberate exemptions:
- *   - a value that is a `{{ }}` template is skipped for type checks (resolved at runtime).
- *   - an `__ASK__: 问题` sentinel (brace-less ON PURPOSE so it bypasses the {{ }} expression gate in
- *     validateDefExpressions) counts as "present but pending" (the agent honestly marking an unknown,
- *     not a hallucination) — surfaced by collectClarifications for the pending-field badge and
- *     execution-readiness validation.
- */
-import type { CapabilityEntry } from "./capability-catalog.js";
-/** Per-kind params schemas. `trigger` (workflow-level trigger def) and
- *  `manual` (n8n import placeholder that always fails) are intentionally excluded. */
-export declare const KIND_PARAM_SCHEMAS: Record<string, Record<string, unknown>>;
-/** An `__ASK__: 问题` sentinel — the agent honestly marking an unknown required value (AI-2).
- *  Brace-less by design so it doesn't enter the {{ }} restricted-expression gate. */
-export declare function isAskPlaceholder(v: unknown): boolean;
-type NodeLike = {
-    id: string;
-    kind: string;
-    params?: Record<string, unknown>;
-};
-/**
- * Resolve the schema governing a canonical node's params.
- */
-export declare function resolveNodeParamsSchema(node: NodeLike, entries: CapabilityEntry[]): Record<string, unknown> | undefined;
-/**
- * Validate every node's params against its resolved schema. Returns human-readable Chinese errors
- * (empty = clean). Skips `trigger` (trigger def is validated elsewhere) and `manual` (placeholder).
- * Unknown kinds with no schema are skipped here (validateCapabilityRefs / validateGraph cover refs).
- */
-export declare function validateParamsAgainstSchema(def: {
-    nodes: NodeLike[];
-}, entries: CapabilityEntry[]): string[];
-/**
- * Collect every brace-less `__ASK__` placeholder in a def (top-level params + one level into
- * `args`). Drives the canvas pending-field badge and execution-readiness validation. Empty =
- * nothing pending.
- */
-export declare function collectAskPlaceholders(def: {
-    nodes: NodeLike[];
-}): {
-    nodeId: string;
-    field: string;
-}[];
-/**
- * Like collectAskPlaceholders but carries the question text — drives the workflow.chat `clarify`
- * bubble (AI-2). Empty = nothing to ask.
- */
-export declare function collectClarifications(def: {
-    nodes: NodeLike[];
-}): {
-    nodeId: string;
-    field: string;
-    question: string;
-}[];
-/**
- * Compact per-kind params hint for the AI graph-builder prompt, derived from KIND_PARAM_SCHEMAS.
- */
-export declare function renderKindParamsForPrompt(): string;
-export {};

package/dist/types/orchestration/workflow/qla-executor-host.d.ts

@@ -1,63 +0,0 @@
-/**
- * QlogicagentExecutorHost backing canonical host executors and Runtime-injected Action nodes
- * with qlogicagent's actual capabilities. No mocks, no stubs (plan §1.5).
- *
- * Boundary capabilities (runAgent / invokeMcp / sendChannel) are injected so this file stays
- * decoupled from the Gateway Host. Missing capabilities and downstream rejections fail loudly.
- */
-import type { LLMTransport } from "../../runtime/ports/index.js";
-import { type DataItem } from "./data-item.js";
-import type { ExecutorHost, N8nNodeHostRequest, MemoryHostRequest, SubworkflowHostRequest, ApprovalHostRequest, WebhookWaitHostRequest } from "./node-schema.js";
-/** Injected boundary capabilities — supplied by the handler host that owns the real runners. */
-export interface QlaExecutorHostDeps {
-    /** Run one agent turn (spawn external ACP agent + sendTask). Returns the agent's text output. */
-    runAgent: (req: {
-        agentId: string;
-        prompt: string;
-        signal?: AbortSignal;
-    }) => Promise<string>;
-    /** Resolve the owner's configured Settings -> Model text model. */
-    resolveClientForPurpose?: (purpose: "textGeneration") => {
-        transport: LLMTransport;
-        apiKey: string;
-        model: string;
-    } | null;
-    /** Invoke an MCP server tool through the real MCP bridge. */
-    invokeMcp: (req: {
-        server: string;
-        tool: string;
-        args: Record<string, unknown>;
-        signal?: AbortSignal;
-    }) => Promise<unknown>;
-    /** Execute an installed n8n ecosystem node through the embedding Host. */
-    runN8nNode?: (req: N8nNodeHostRequest) => Promise<Record<string, DataItem[]>>;
-    /**
-     * Send a message out through a channel via the xiaozhiclaw channel layer.
-     * Undefined in standalone qlogicagent (no gateway) → channel nodes fail-loud (D12/D13).
-     */
-    sendChannel?: (req: {
-        channel: string;
-        target?: string;
-        payload: unknown;
-        idempotencyKey?: string;
-        signal?: AbortSignal;
-    }) => Promise<unknown>;
-    /**
-     * Project-scoped memory backend for the `memory` kind (spec D25). The handler host wires
-     * the owning project root's memdir; absent → memory nodes fail-loud.
-     */
-    memory?: (req: MemoryHostRequest) => Promise<DataItem[]>;
-    /** Run another workflow as a step (D34); the handler enforces cycle guards. */
-    runSubworkflow?: (req: SubworkflowHostRequest) => Promise<DataItem[]>;
-    /** Human-in-the-loop approval (D34): notify + await the owner's decision. */
-    approval?: (req: ApprovalHostRequest) => Promise<{
-        approved: boolean;
-        decidedAt: string;
-        note?: string;
-    }>;
-    /** D34 wait-until-webhook: suspend until the path is hit (handler owns the wake registry). */
-    waitWebhook?: (req: WebhookWaitHostRequest) => Promise<Record<string, unknown>>;
-    /** fetch impl; defaults to global fetch. Injectable for tests. */
-    fetchImpl?: typeof fetch;
-}
-export declare function createQlaExecutorHost(deps: QlaExecutorHostDeps): ExecutorHost;

package/dist/types/orchestration/workflow/run-checkpoint-store.d.ts

@@ -1,53 +0,0 @@
-/**
- * Run Checkpoint Store — durable crash-restart recovery for in-flight workflow runs (plan §M3).
- *
- * The runtime's output cache is content-addressed (key = hash(kind + params + input signature +
- * runIndex), spec §A5). Persisting that cache to disk turns run-from-node into crash recovery:
- * after a qlogicagent restart, a FRESH WorkflowRuntime replays the same DAG, recomputes the same
- * cache keys, and hits the persisted entries for every node that already completed — so those
- * executors are NOT re-invoked (no duplicate agent turns / channel sends), and only the
- * not-yet-run remainder executes. This is exactly the M3 acceptance:
- * "qlogicagent 崩溃重启从 checkpoint 恢复在跑工作流".
- *
- * Stored at `<project>/.qlogicagent/workflows/<workflowId>/runs/<runId>/cache.json`.
- * NodeExecResult is JSON (PortMap of DataItems + firedPorts), so the snapshot round-trips losslessly.
- *
- * fail-loud: a corrupt/unreadable snapshot is treated as absent (a fresh run), never silently
- * partially applied.
- */
-import type { NodeExecResult } from "./node-schema.js";
-/** One persisted cache entry: a content key and the executor result it produced. */
-export interface CheckpointEntry {
-    key: string;
-    result: NodeExecResult;
-}
-/** A point-in-time snapshot of a run's content-addressed output cache. */
-export interface CheckpointSnapshot {
-    workflowId: string;
-    runId: string;
-    entries: CheckpointEntry[];
-    updatedAt: string;
-}
-/**
- * Durable run state the runtime loads on (re)start and persists after each computed node.
- * Implementations may be file-backed (production) or in-memory (tests).
- */
-export interface RunCheckpoint {
-    /** Load the prior snapshot, or undefined for a never-started / absent run. */
-    load(): Promise<CheckpointSnapshot | undefined>;
-    /** Persist the full set of computed cache entries (idempotent overwrite). */
-    persist(entries: CheckpointEntry[]): Promise<void>;
-    /** Remove the snapshot once the run has completed successfully. */
-    clear(): Promise<void>;
-}
-/** File-backed checkpoint under `.qlogicagent/workflows/<id>/runs/<runId>/cache.json`. */
-export declare class FileRunCheckpoint implements RunCheckpoint {
-    private readonly workflowId;
-    private readonly runId;
-    private readonly dir;
-    private readonly file;
-    constructor(cwd: string, workflowId: string, runId: string);
-    load(): Promise<CheckpointSnapshot | undefined>;
-    persist(entries: CheckpointEntry[]): Promise<void>;
-    clear(): Promise<void>;
-}