@ai-setting/roy-agent-core 1.7.52 → 1.7.55

package/dist/env/workflow/storage/tag-repo.d.ts

@@ -0,0 +1,65 @@
+/**
+ * @fileoverview TagRepository
+ *
+ * Owns the `workflow_tags` table:
+ *   - name TEXT PRIMARY KEY
+ *   - usage_count INTEGER NOT NULL DEFAULT 0
+ *   - created_at TEXT NOT NULL
+ *   - updated_at TEXT NOT NULL
+ *
+ * - `upsertMany(names)` inserts new tags (with count=1) or increments existing ones by 1
+ * - `decrementMany(names)` clamps usage_count at 0 (rows are NOT deleted)
+ * - `list()` returns tags sorted by usage_count DESC, name ASC
+ * - `get(name)` returns single tag info or undefined
+ *
+ * Concurrency: All write methods use prepared statements. Callers may wrap
+ * multiple operations in an outer `db.transaction(...)` to make them atomic.
+ */
+export interface TagInfo {
+    name: string;
+    usage_count: number;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * v3: Extended list options for TagRepository.list().
+ *
+ * - `sortBy`: "usage_count" (default), "name", or "created_at"
+ * - `order`:  "desc" (default) or "asc"
+ * - `limit`:  optional cap on number of rows returned
+ */
+export interface ListTagsOptions {
+    sortBy?: "usage_count" | "name" | "created_at";
+    order?: "asc" | "desc";
+    limit?: number;
+}
+export declare class TagRepository {
+    private db;
+    constructor(db: any);
+    /**
+     * Static helper to create the workflow_tags table (and its usage index).
+     * Safe to call multiple times (idempotent).
+     */
+    static createTable(db: any): void;
+    /**
+     * Insert new tags with count=1, or increment existing tags by 1.
+     * Empty input is a no-op.
+     */
+    upsertMany(names: string[]): void;
+    /**
+     * Decrement usage_count for each given tag by 1, clamped at 0.
+     * Rows are NEVER deleted (preserve history).
+     * Non-existent tags are silently ignored.
+     */
+    decrementMany(names: string[]): void;
+    /**
+     * List all tags with v3 sort/limit options.
+     *
+     * Default: usage_count DESC, name ASC (backward compatible).
+     */
+    list(options?: ListTagsOptions): TagInfo[];
+    /**
+     * Get a single tag by name (returns undefined if not found).
+     */
+    get(name: string): TagInfo | undefined;
+}

package/dist/env/workflow/storage/workflow-repo.d.ts

@@ -0,0 +1,161 @@
+/**
+ * @fileoverview Workflow Repository
+ *
+ * SQLite-based repository for workflow CRUD operations.
+ */
+import type { Workflow, WorkflowDefinition, WorkflowMetadata, WorkflowConfig } from '../types';
+import { getDatabase } from './sqlite';
+export interface WorkflowRow {
+    id: string;
+    name: string;
+    version: string;
+    description: string | null;
+    definition: string;
+    config: string;
+    metadata: string;
+    tags: string;
+    task_id: number | null;
+    created_at: string;
+    updated_at: string;
+}
+export interface ListWorkflowsOptions {
+    limit?: number;
+    offset?: number;
+    orderBy?: 'name' | 'created_at' | 'updated_at';
+    order?: 'asc' | 'desc';
+    tag?: string;
+    taskId?: number;
+    search?: string;
+}
+export interface UpdateWorkflowOptions {
+    name?: string;
+    version?: string;
+    description?: string;
+    definition?: WorkflowDefinition;
+    config?: WorkflowConfig;
+    metadata?: WorkflowMetadata;
+    tags?: string[];
+}
+/**
+ * Row to Workflow conversion helper
+ *
+ * Bug 修复 Task #4037（sibling-risk of Task #4036）：
+ *   原本 4 处裸 `JSON.parse` 没有任何错误处理；损坏的 metadata/definition
+ *   会让整个 `workflow list` 命令挂掉（与 Bug #4033 的 tasks list 同源）。
+ *
+ *   修复策略按字段语义分流：
+ *     - definition / metadata：业务关键，损坏时**抛错**（带 fieldName +
+ *       row.name + row.id 的清晰错误信息），宁可在 ReportError 路径上挂掉
+ *       也别返回 silent-corrupt 数据。
+ *     - config / tags：辅助字段，**graceful fallback**（config → {}，
+ *       tags 复用 task-store 的 parseTagsSafely 模式）。
+ *
+ *   实现细节见 `./safe-json.ts`。
+ */
+export declare function rowToWorkflow(row: WorkflowRow): Workflow;
+/**
+ * WorkflowRepository class
+ *
+ * Provides CRUD operations for workflows in SQLite.
+ */
+export declare class WorkflowRepository {
+    private db;
+    constructor(db?: ReturnType<typeof getDatabase>);
+    /**
+     * Create a new workflow
+     */
+    create(workflow: Omit<Workflow, 'id' | 'createdAt' | 'updatedAt'>): Workflow;
+    /**
+     * Create a workflow from definition only
+     */
+    createFromDefinition(definition: WorkflowDefinition, options?: {
+        config?: WorkflowConfig;
+        metadata?: WorkflowMetadata;
+        tags?: string[];
+    }): Workflow;
+    /**
+     * Get a workflow by ID
+     */
+    getById(id: string): Workflow | undefined;
+    /**
+     * Get a workflow by name (returns latest version)
+     */
+    getByName(name: string): Workflow | undefined;
+    /**
+     * Get a specific version of a workflow by name
+     */
+    getByNameAndVersion(name: string, version: string): Workflow | undefined;
+    /**
+     * List workflows with optional filtering and pagination
+     */
+    list(options?: ListWorkflowsOptions): Workflow[];
+    /**
+     * List all versions of a workflow by name
+     */
+    listVersions(name: string): Workflow[];
+    /**
+     * Update a workflow
+     */
+    update(id: string, updates: UpdateWorkflowOptions): Workflow | undefined;
+    /**
+     * Delete a workflow
+     */
+    delete(id: string): boolean;
+    /**
+     * Check if a workflow exists
+     */
+    exists(id: string): boolean;
+    /**
+     * Check if a workflow with name and version exists
+     */
+    existsByNameAndVersion(name: string, version: string): boolean;
+    /**
+     * Get total count of workflows
+     */
+    count(): number;
+    /**
+     * v4: Get count of workflows matching the given filters.
+     *
+     * Unlike `list()`, this method:
+     * - Returns the **total** count of matching rows (not paginated)
+     * - Ignores `limit` / `offset` options
+     * - Applies SQL filters (tag, taskId) in SQL
+     * - Applies multi-tag AND + search filter in-memory
+     *
+     * Used by `WorkflowService.listWorkflowsWithTags` and `searchWorkflowsWithTags`
+     * to populate the `total` field correctly.
+     *
+     * @param options - Filter options (no limit/offset)
+     * @returns Number of workflows matching the filters
+     */
+    countAll(options?: {
+        tag?: string;
+        tags?: string[];
+        taskId?: number;
+        search?: string;
+    }): number;
+    /**
+     * Search workflows by name (partial match)
+     */
+    search(query: string, limit?: number): Workflow[];
+    /**
+     * Migrate workflows with empty/missing tags to ["default"].
+     *
+     * @returns number of rows updated
+     */
+    migrateEmptyTagsToDefault(): number;
+    /**
+     * v2: 在事务中执行一个函数，回滚任何抛出
+     */
+    transaction<T>(fn: () => T): T;
+}
+/**
+ * Module-level helper — migrate workflows with empty/missing tags to `["default"]`.
+ *
+ * Updates workflows where `tags IS NULL`, `tags = ''`, or `tags = '[]'`.
+ * Other workflows are untouched. Idempotent.
+ *
+ * @param db - SQLite database instance (must have workflows table with tags column)
+ * @returns number of workflows that were updated
+ */
+export declare function migrateEmptyTagsToDefault(db: any): number;

package/dist/env/workflow/tools/ask-user-tool.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @fileoverview AskUserTool - Tool for requesting user input in workflow
+ *
+ * When an AgentNode calls this tool, it throws AskUserError to interrupt
+ * the workflow, allowing the workflow to pause and wait for user response.
+ */
+import { z } from 'zod';
+import type { ToolInfo } from '../../tool/types';
+/**
+ * AskUserTool input schema
+ */
+export declare const AskUserInputSchema: z.ZodObject<{
+    query: z.ZodString;
+    options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    required_confirm: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+    options?: string[] | undefined;
+    required_confirm?: boolean | undefined;
+}, {
+    query: string;
+    options?: string[] | undefined;
+    required_confirm?: boolean | undefined;
+}>;
+export type AskUserInput = z.infer<typeof AskUserInputSchema>;
+/**
+ * AskUserTool
+ *
+ * A special tool that can be called by Agent to request user input.
+ * Calling this tool will throw AskUserError, which the Executor will
+ * catch and convert to a workflow pause event.
+ */
+export type AskUserTool = ToolInfo<typeof AskUserInputSchema>;
+export declare const askUserTool: AskUserTool;
+export declare const askUserToolInstance: AskUserTool;

package/dist/env/workflow/tools/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Workflow Tools - Phase 7
+ *
+ * Export all workflow-related tools
+ */
+export { createRunWorkflowTool, initRunWorkflowTool, getRunWorkflowTool, resetRunWorkflowTool, createLegacyRunWorkflowTool, RunWorkflowInputSchema, type RunWorkflowInput, type RunWorkflowTool, type RunWorkflowToolInterface, } from "./run-workflow";
+export { createWorkflowGetTool, WorkflowGetInputSchema, type WorkflowGetInput, } from "./workflow-get-tool";
+export { createWorkflowListTool, WorkflowListInputSchema, type WorkflowListInput, } from "./workflow-list-tool";
+export { createWorkflowAddTool, WorkflowAddInputSchema, type WorkflowAddInput, } from "./workflow-add-tool";
+export { createWorkflowValidateTool, WorkflowValidateInputSchema, type WorkflowValidateInput, } from "./workflow-validate-tool";
+export { createWorkflowSearchTool, WorkflowSearchInputSchema, type WorkflowSearchInput, } from "./workflow-search-tool";
+export { createWorkflowTagListTool, WorkflowTagListInputSchema, type WorkflowTagListInput, type WorkflowTagListOutput, } from "./workflow-tag-list-tool";
+export { createWorkflowRunStatusTool, WorkflowRunStatusInputSchema, type WorkflowRunStatusInput, } from "./workflow-run-status-tool";
+export { createWorkflowRunStopTool, WorkflowRunStopInputSchema, type WorkflowRunStopInput, } from "./workflow-run-stop-tool";
+export { askUserTool, askUserToolInstance, AskUserInputSchema, type AskUserTool, type AskUserInput, } from "./ask-user-tool";
+export { createSubmitJsonOutputTool, parseWorkflowJsonOutput, WORKFLOW_SUBMIT_OUTPUT_TOOL_NAME, WorkflowJsonOutputMarker, } from "./submit-json-output-tool";

package/dist/env/workflow/tools/index.js

@@ -24,9 +24,9 @@ import {
   getRunWorkflowTool,
   initRunWorkflowTool,
   resetRunWorkflowTool
-} from "../../../shared/@ai-setting/roy-agent-core-vvxb9522.js";
-import"../../../shared/@ai-setting/roy-agent-core-yd21n6c7.js";
-import"../../../shared/@ai-setting/roy-agent-core-h93v6p6y.js";
+} from "../../../shared/@ai-setting/roy-agent-core-6qxh4xrm.js";
+import"../../../shared/@ai-setting/roy-agent-core-zvemdfx5.js";
+import"../../../shared/@ai-setting/roy-agent-core-7qy3nffr.js";
 import"../../../shared/@ai-setting/roy-agent-core-7evvpfwc.js";
 import {
   WORKFLOW_SUBMIT_OUTPUT_TOOL_NAME,
@@ -37,12 +37,12 @@ import {
 } from "../../../shared/@ai-setting/roy-agent-core-1db4vpc6.js";
 import"../../../shared/@ai-setting/roy-agent-core-ze068vc9.js";
 import"../../../shared/@ai-setting/roy-agent-core-7exqwax1.js";
-import"../../../shared/@ai-setting/roy-agent-core-na73mym1.js";
+import"../../../shared/@ai-setting/roy-agent-core-a4vzsn0g.js";
 import"../../../shared/@ai-setting/roy-agent-core-8s9jd2qy.js";
 import"../../../shared/@ai-setting/roy-agent-core-jrj30vq3.js";
 import"../../../shared/@ai-setting/roy-agent-core-rvxg1wps.js";
-import"../../../shared/@ai-setting/roy-agent-core-pk1b3kvf.js";
-import"../../../shared/@ai-setting/roy-agent-core-zy3hqfwg.js";
+import"../../../shared/@ai-setting/roy-agent-core-2b8jtv7m.js";
+import"../../../shared/@ai-setting/roy-agent-core-0hq21px2.js";
 import"../../../shared/@ai-setting/roy-agent-core-c1v263jn.js";
 import"../../../shared/@ai-setting/roy-agent-core-e25xkv53.js";
 import"../../../shared/@ai-setting/roy-agent-core-7hh0brvs.js";

package/dist/env/workflow/tools/run-workflow.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Run Workflow Tool - Phase 7
+ *
+ * A Tool for executing workflows by name from within other workflows or agents.
+ *
+ * Named "workflow_run" for consistency with other workflow tools.
+ * The old name "run-workflow" is available via export alias.
+ */
+import { z } from "zod";
+import type { Tool } from "../../../env/tool/types";
+import type { WorkflowService } from "../service/workflow-service";
+/**
+ * Task #2144 — Lifecycle hooks for sub-session attach/detach.
+ *
+ * Passed to createRunWorkflowTool by WorkflowComponent which has access to
+ * BackgroundTaskManager. The hooks are optional: when omitted (e.g. main
+ * session direct invocation, CLI `roy-agent workflow run`), the tool skips
+ * attach/detach and behaves exactly as before.
+ *
+ * - attachWorkflowRun(bgTaskId, runId) is called BEFORE execute, when a
+ *   bgTaskId is present in the AsyncLocalStorage stack. Even if the run
+ *   later fails, attach is left in place so propagateStopToWorkflowRuns
+ *   can clean up. This is the conservative "leak-prevention" semantics:
+ *   any workflow run we know about deserves a stop attempt when the
+ *   parent task stops.
+ *
+ * - detachWorkflowRun(bgTaskId, runId) is called ONLY on the success
+ *   path (status === "completed" or "paused"). Detaching on success
+ *   avoids redundant stopRun attempts on already-terminal workflows
+ *   (which would otherwise log harmless "Session not found" warnings).
+ */
+export interface RunWorkflowLifecycleHooks {
+    attachWorkflowRun?: (bgTaskId: string, runId: string) => void;
+    detachWorkflowRun?: (bgTaskId: string, runId: string) => void;
+    /**
+     * Task #2190 — fired when the engine reports the real runId via
+     * `onSessionCreated(realRunId)`. Allows the BackgroundTaskManager to
+     * swap the registry entry from the reserved (placeholder) runId to the
+     * real engine runId, so a mid-flight `stop_task` can find the workflow
+     * by its real id (instead of the placeholder).
+     *
+     * Semantics: caller should drop `oldRunId` and add `newRunId`. If
+     * `newRunId` is empty/falsy, the registry entry is simply removed
+     * (engine never produced a real id — likely timeout before persistence).
+     */
+    replaceWorkflowRun?: (bgTaskId: string, oldRunId: string, newRunId: string) => void;
+}
+/**
+ * Task #2100 — synthesize a `workflow_`-prefixed fallback runId.
+ *
+ * Used in `execute()` as the default value for `capturedRunId` when the
+ * engine never fires `onSessionCreated` before the timeout/abort/error
+ * path resolves. The format mirrors Task #1837's runId == sessionId
+ * contract (`workflow_` + timestamp + suffix) so callers can't
+ * distinguish a fallback runId from a real one by shape alone.
+ *
+ * Exported for testability (so tests can assert the format regex without
+ * having to trigger the timeout path each time).
+ *
+ * @internal
+ */
+export declare function synthFallbackRunId(now?: number): string;
+/**
+ * Input schema for workflow_run tool
+ */
+export declare const RunWorkflowInputSchema: z.ZodObject<{
+    workflow_name: z.ZodString;
+    input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    node_config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>>;
+    session: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    workflow_name: string;
+    input?: Record<string, any> | undefined;
+    timeout?: number | undefined;
+    session?: string | undefined;
+    node_config?: Record<string, Record<string, any>> | undefined;
+}, {
+    workflow_name: string;
+    input?: Record<string, any> | undefined;
+    timeout?: number | undefined;
+    session?: string | undefined;
+    node_config?: Record<string, Record<string, any>> | undefined;
+}>;
+export type RunWorkflowInput = z.infer<typeof RunWorkflowInputSchema>;
+/**
+ * Workflow Run Tool interface for type-safe access
+ */
+export interface RunWorkflowToolInterface {
+    name: "workflow_run";
+    description: string;
+    inputSchema: typeof RunWorkflowInputSchema;
+}
+/**
+ * Create a workflow_run tool with the given WorkflowService
+ *
+ * @param workflowService - The WorkflowService instance for executing workflows
+ * @param hooks - Optional Task #2144 lifecycle hooks for sub-session attach/detach.
+ *                When bgTaskId is present in the ALS stack (i.e. invoked from a
+ *                sub-session inside a delegate_task), the tool will register
+ *                its runId via `hooks.attachWorkflowRun` and detach on success
+ *                via `hooks.detachWorkflowRun`. Main-session direct invocation
+ *                (no bgTaskId) skips both.
+ * @returns A Tool instance for running workflows
+ */
+export declare function createRunWorkflowTool(workflowService: WorkflowService, hooks?: RunWorkflowLifecycleHooks): Tool;
+/**
+ * Initialize the workflow_run tool with a WorkflowService
+ *
+ * @param workflowService - The WorkflowService instance
+ */
+export declare function initRunWorkflowTool(workflowService: WorkflowService): void;
+/**
+ * Get the workflow_run tool instance
+ *
+ * @throws Error if the tool has not been initialized
+ */
+export declare function getRunWorkflowTool(): Tool;
+/**
+ * Reset the workflow_run tool (for testing)
+ */
+export declare function resetRunWorkflowTool(): void;
+export type RunWorkflowTool = ReturnType<typeof createRunWorkflowTool>;
+/**
+ * Backward-compatible alias: create a tool named "run-workflow" for existing consumers.
+ * The old tool name "run-workflow" is deprecated in favor of "workflow_run".
+ *
+ * @deprecated Use createRunWorkflowTool() which produces a tool named "workflow_run"
+ */
+export declare function createLegacyRunWorkflowTool(workflowService: WorkflowService): Tool;

package/dist/env/workflow/tools/submit-json-output-tool.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @fileoverview workflow_submit_output - Tool for AgentNode JSON structured output
+ *
+ * Design (tool self-recording pattern):
+ * - This tool receives the `HookContext` from the plugin at construction time.
+ * - When `execute(args)` is called by the json-extract sub-agent, the tool:
+ *   1. Validates `args` against the dynamic zod schema derived from `outputSchema`.
+ *   2. Writes the parsed JSON directly to `hookCtx.structuredOutputExtracted`.
+ *   3. Returns a marker-prefixed string output for compatibility.
+ *
+ * As a result, the plugin no longer needs to inspect `result.toolCalls` and
+ * re-validate; it just reads `hookCtx.structuredOutputExtracted` after the
+ * json-extract sub-agent finishes.
+ */
+import { z } from 'zod';
+import type { ToolInfo } from '../../tool/types';
+import type { HookContext as AgentHookContext } from '../../agent/types';
+import { type JsonSchemaObject } from '../utils/json-schema-to-zod';
+export declare const WORKFLOW_SUBMIT_OUTPUT_TOOL_NAME = "workflow_submit_output";
+export declare const WorkflowJsonOutputMarker = "__WORKFLOW_JSON_OUTPUT__";
+/**
+ * Create a `workflow_submit_output` tool bound to a specific hook context.
+ *
+ * @param schema - The JSON schema describing the expected structured output.
+ * @param hookCtx - The agent hook context. The tool writes the validated
+ *                  structured JSON to `hookCtx.structuredOutputExtracted`
+ *                  so the calling plugin can pick it up without needing to
+ *                  re-inspect tool call history.
+ */
+export declare function createSubmitJsonOutputTool(schema: JsonSchemaObject, hookCtx: AgentHookContext): ToolInfo<z.ZodObject<z.ZodRawShape>>;
+/**
+ * Parse a marker-prefixed output string back into a typed JSON object.
+ *
+ * Kept for callers that still scan session history (e.g.
+ * `utils/extract-agent-json-output.ts`). The new self-recording flow
+ * does not need this, but we keep it as a public utility.
+ */
+export declare function parseWorkflowJsonOutput(output: unknown): Record<string, unknown> | undefined;

package/dist/env/workflow/tools/workflow-add-tool.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @fileoverview Workflow Add Tool
+ *
+ * MCP tool for creating a new workflow.
+ * Tags are required (1-3), validated at multiple levels:
+ *   - Zod schema (count bounds, type)
+ *   - Per-element: empty string / contains comma (post-parse)
+ *   - Name consistency between `name` and `definition.name`
+ *
+ * v2: works with TagRepository via service.createWorkflow (transactional);
+ * returns available_tags from the tag table.
+ *
+ * v3: Soft-prompt description encourages agents to call `workflow_tag_list`
+ * FIRST to discover existing tags, then prefer reusing them for semantic
+ * consistency. New tags are still auto-created (Strategy A: no hard validation).
+ */
+import { z } from "zod";
+import type { Tool } from "../../tool/types";
+import type { WorkflowService } from "../service/workflow-service";
+/**
+ * Input schema for workflow_add tool.
+ * Note: `tags` is required (Zod enforces 1-3 min/max bounds).
+ */
+export declare const WorkflowAddInputSchema: z.ZodObject<{
+    definition: z.ZodOptional<z.ZodAny>;
+    definition_yaml: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    tags: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    tags: string[];
+    name?: string | undefined;
+    description?: string | undefined;
+    definition?: any;
+    definition_yaml?: string | undefined;
+}, {
+    tags: string[];
+    name?: string | undefined;
+    description?: string | undefined;
+    definition?: any;
+    definition_yaml?: string | undefined;
+}>;
+export type WorkflowAddInput = z.infer<typeof WorkflowAddInputSchema>;
+/**
+ * Create a workflow_add tool with the given WorkflowService.
+ */
+export declare function createWorkflowAddTool(workflowService: WorkflowService): Tool;

package/dist/env/workflow/tools/workflow-get-tool.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @fileoverview Workflow Get Tool
+ *
+ * Get workflow definition details or run status by name or run_id.
+ */
+import { z } from "zod";
+import type { Tool } from "../../tool/types";
+import type { WorkflowService } from "../service/workflow-service";
+/**
+ * Input schema for workflow_get tool
+ */
+export declare const WorkflowGetInputSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    run_id: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name?: string | undefined;
+    run_id?: string | undefined;
+}, {
+    name?: string | undefined;
+    run_id?: string | undefined;
+}>;
+export type WorkflowGetInput = z.infer<typeof WorkflowGetInputSchema>;
+/**
+ * Create a workflow_get tool with the given WorkflowService
+ *
+ * @param workflowService - The WorkflowService instance for querying workflows
+ * @returns A Tool instance for getting workflow details
+ */
+export declare function createWorkflowGetTool(workflowService: WorkflowService): Tool;

package/dist/env/workflow/tools/workflow-list-tool.d.ts

@@ -0,0 +1,55 @@
+/**
+ * @fileoverview Workflow List Tool
+ *
+ * List all registered workflows with optional filtering.
+ * v2: 返回 available_tags（按 usage_count DESC, name ASC）
+ *
+ * JSON output shape (Code Review #1479 follow-up — aligned with CLI path):
+ *
+ *   {
+ *     "total":          <number>,         // FIRST so it survives tail-truncation
+ *     "count":          <number>,
+ *     "truncated":      <boolean>,        // total > count
+ *     "limit":          <number>,         // requested page size
+ *     "offset":         <number>,
+ *     "page":           <number>,         // 1-based page number (passthrough or default 1)
+ *     "available_tags": [...],            // metadata block tail
+ *     "workflows":      [...]             // LAST so the array is the truncation target
+ *   }
+ *
+ * Keep this shape in sync with:
+ *   - packages/cli/src/commands/workflow/commands/list.ts (CLI path: buildListWorkflowsJson)
+ */
+import { z } from "zod";
+import type { Tool } from "../../tool/types";
+import type { WorkflowService } from "../service/workflow-service";
+/**
+ * Input schema for workflow_list tool
+ */
+export declare const WorkflowListInputSchema: z.ZodObject<{
+    tag: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    search: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    page: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    tags?: string[] | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+    tag?: string | undefined;
+    search?: string | undefined;
+    page?: number | undefined;
+}, {
+    tags?: string[] | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+    tag?: string | undefined;
+    search?: string | undefined;
+    page?: number | undefined;
+}>;
+export type WorkflowListInput = z.infer<typeof WorkflowListInputSchema>;
+/**
+ * Create a workflow_list tool with the given WorkflowService
+ */
+export declare function createWorkflowListTool(workflowService: WorkflowService): Tool;

package/dist/env/workflow/tools/workflow-run-status-tool.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @fileoverview Workflow Run Status Tool
+ *
+ * Query the status of a workflow run by run/session ID.
+ */
+import { z } from "zod";
+import type { Tool } from "../../tool/types";
+import type { WorkflowService } from "../service/workflow-service";
+/**
+ * Input schema for workflow_run_status tool
+ */
+export declare const WorkflowRunStatusInputSchema: z.ZodObject<{
+    run_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    run_id: string;
+}, {
+    run_id: string;
+}>;
+export type WorkflowRunStatusInput = z.infer<typeof WorkflowRunStatusInputSchema>;
+/**
+ * Create a workflow_run_status tool with the given WorkflowService
+ *
+ * @param workflowService - The WorkflowService instance for querying run status
+ * @returns A Tool instance for checking workflow run status
+ */
+export declare function createWorkflowRunStatusTool(workflowService: WorkflowService): Tool;

package/dist/env/workflow/tools/workflow-run-stop-tool.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @fileoverview Workflow Run Stop Tool
+ *
+ * Stop a running workflow by run/session ID.
+ */
+import { z } from "zod";
+import type { Tool } from "../../tool/types";
+import type { WorkflowService } from "../service/workflow-service";
+/**
+ * Input schema for workflow_run_stop tool
+ */
+export declare const WorkflowRunStopInputSchema: z.ZodObject<{
+    run_id: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    run_id: string;
+    reason?: string | undefined;
+}, {
+    run_id: string;
+    reason?: string | undefined;
+}>;
+export type WorkflowRunStopInput = z.infer<typeof WorkflowRunStopInputSchema>;
+/**
+ * Create a workflow_run_stop tool with the given WorkflowService
+ *
+ * @param workflowService - The WorkflowService instance for stopping workflow runs
+ * @returns A Tool instance for stopping workflow runs
+ */
+export declare function createWorkflowRunStopTool(workflowService: WorkflowService): Tool;