@xopcai/xopc 0.0.409 → 0.0.411

package/dist/src/agent/workflow/step-labels.js

@@ -1,50 +0,0 @@
-//#region src/agent/workflow/step-labels.ts
-/**
-* Human-readable labels for workflow subagent tool steps (server-side snapshot).
-* Mirrors the web `tool-friendly-title` rules so IM/TUI and gateway stay aligned.
-*/
-const MAX_DETAIL_LEN = 120;
-function workflowStepLabel(toolName, args) {
-	const n = toolName.toLowerCase().replace(/-/g, "_").trim();
-	let label = toolName.trim() || "tool";
-	if (n === "exec_command") label = "Run command";
-	else if (n === "update_plan") label = "Update plan";
-	else if (n === "list_dir" || n === "ls") label = "List directory";
-	else if (n === "write_file") label = "Write file";
-	else if (n === "apply_patch") label = "Edit file";
-	else if (n === "web_fetch") label = "Fetch URL";
-	else if (n === "open_url") label = "Open URL";
-	else if (n === "grep" || n === "rg" || n === "file_grep") label = "Search files";
-	else if (n === "web_search" || n === "brave_search" || n.includes("search")) label = "Search web";
-	else if (n === "read_file" || n.includes("read_file") || n.includes("file_read")) label = "Read file";
-	else if (n === "delegate_task" || n === "workflow") label = toolName;
-	const detail = extractStepDetail(n, args);
-	return detail ? {
-		label,
-		detail
-	} : { label };
-}
-function extractStepDetail(toolKey, args) {
-	for (const key of [
-		"path",
-		"file_path",
-		"filePath",
-		"target_file",
-		"targetFile"
-	]) {
-		const v = args[key];
-		if (typeof v === "string" && v.trim()) return truncate(v.trim());
-	}
-	if (toolKey === "exec_command") {
-		const command = typeof args.cmd === "string" ? args.cmd : typeof args.command === "string" ? args.command : "";
-		if (command.trim()) return truncate(command.trim());
-	}
-	if ((toolKey.includes("search") || toolKey === "grep" || toolKey === "rg" || toolKey === "file_grep") && typeof args.query === "string" && args.query.trim()) return truncate(args.query.trim());
-	if (typeof args.url === "string" && args.url.trim()) return truncate(args.url.trim());
-}
-function truncate(text) {
-	if (text.length <= MAX_DETAIL_LEN) return text;
-	return `${text.slice(0, MAX_DETAIL_LEN - 1)}…`;
-}
-//#endregion
-export { workflowStepLabel };

package/dist/src/agent/workflow/structured-output-tool.d.ts

@@ -1,33 +0,0 @@
-/**
- * `structured_output` — terminating tool used to capture a subagent's final result.
- *
- * Injected into a workflow agent node only when its output schema requires
- * structured data. The subagent is instructed
- * to invoke this tool exactly once with its final result; the tool sets
- * `terminate: true` so the agent loop stops without paying for an extra
- * assistant turn.
- *
- * Validation is done with ajv (already a xopc dep). pi-agent-core also validates
- * arguments against `parameters` before calling `execute`, but we re-check here
- * to (1) surface a clear error message back to the model when the schema is
- * non-trivial, and (2) avoid trusting the upstream layer's validator strictness.
- *
- * Note: the file is named `structured-output-tool.ts` to avoid clashing with the
- * existing `src/agent/tools/structured-output.ts` (an XML Element builder — a
- * completely unrelated utility).
- */
-import type { AgentTool } from '@earendil-works/pi-agent-core';
-import type { TSchema } from '@sinclair/typebox';
-import type { JsonSchema } from './types.js';
-export declare const STRUCTURED_OUTPUT_TOOL_NAME = "structured_output";
-export interface StructuredOutputCapture<T = unknown> {
-    called: boolean;
-    value?: T;
-}
-export interface CreateStructuredOutputToolOptions<T = unknown> {
-    schema: JsonSchema;
-    capture: StructuredOutputCapture<T>;
-    /** Override the tool name (rarely needed; default `structured_output`). */
-    name?: string;
-}
-export declare function createStructuredOutputTool<T = unknown>(options: CreateStructuredOutputToolOptions<T>): AgentTool<TSchema, T>;

package/dist/src/agent/workflow/structured-output-tool.js

@@ -1,56 +0,0 @@
-import Ajv from "ajv";
-//#region src/agent/workflow/structured-output-tool.ts
-/**
-* `structured_output` — terminating tool used to capture a subagent's final result.
-*
-* Injected into a workflow agent node only when its output schema requires
-* structured data. The subagent is instructed
-* to invoke this tool exactly once with its final result; the tool sets
-* `terminate: true` so the agent loop stops without paying for an extra
-* assistant turn.
-*
-* Validation is done with ajv (already a xopc dep). pi-agent-core also validates
-* arguments against `parameters` before calling `execute`, but we re-check here
-* to (1) surface a clear error message back to the model when the schema is
-* non-trivial, and (2) avoid trusting the upstream layer's validator strictness.
-*
-* Note: the file is named `structured-output-tool.ts` to avoid clashing with the
-* existing `src/agent/tools/structured-output.ts` (an XML Element builder — a
-* completely unrelated utility).
-*/
-const STRUCTURED_OUTPUT_TOOL_NAME = "structured_output";
-const ajv = new Ajv({
-	allErrors: true,
-	strict: false
-});
-function createStructuredOutputTool(options) {
-	const name = options.name ?? "structured_output";
-	const validator = ajv.compile(options.schema);
-	return {
-		name,
-		label: "Structured Output",
-		description: "Return the final machine-readable result for this subagent task. Call this tool exactly once when finished. Do not emit a prose final answer afterwards.",
-		parameters: options.schema,
-		async execute(_toolCallId, params) {
-			if (!validator(params)) return {
-				content: [{
-					type: "text",
-					text: `structured_output: invalid arguments — ${ajv.errorsText(validator.errors, { separator: "; " })}. Adjust and call structured_output again.`
-				}],
-				details: params
-			};
-			options.capture.called = true;
-			options.capture.value = params;
-			return {
-				content: [{
-					type: "text",
-					text: "Structured output received."
-				}],
-				details: params,
-				terminate: true
-			};
-		}
-	};
-}
-//#endregion
-export { STRUCTURED_OUTPUT_TOOL_NAME, createStructuredOutputTool };

package/dist/src/agent/workflow/subagent-runner.d.ts

@@ -1,46 +0,0 @@
-/**
- * Adapter: spawns one isolated child agent per `agent()` call from a workflow.
- *
- * Wraps the existing `createDelegateChildHandle` so the workflow runtime stays
- * decoupled from the LLM stack (it sees only the `SubagentRunner` interface).
- *
- * Key behaviour:
- * - When `opts.schema` is provided, we inject `structured_output` into the child
- *   tool set and unwrap the captured value on success. If the subagent finishes
- *   without ever calling `structured_output`, we treat it as failure (`null`).
- * - Failures and aborts resolve to `null`. The workflow runtime continues — this
- *   matches the pi-dynamic-workflows contract and keeps fan-out pipelines robust.
- */
-import type { AgentTool } from '@earendil-works/pi-agent-core';
-import type { Api, Model } from '@earendil-works/pi-ai';
-import type { Config } from '../../config/schema.js';
-import type { MessageBus } from '../../infra/bus/index.js';
-import type { SessionStore } from '../../session/store.js';
-import { type BuildChildToolsOptions } from '../child-agent-factory.js';
-import type { ToolExecutorConfig } from '../tools/executor.js';
-import type { SubagentRunOptions, SubagentRunner } from './types.js';
-export interface DelegateSubagentRunnerDeps {
-    isWorkspaceTrusted?: (workspaceDir: string) => boolean | null | undefined;
-    workspace: string;
-    bus: MessageBus;
-    agentId?: string;
-    /** Resolves the default subagent model (typically the parent agent's primary model). */
-    getDefaultModel: () => Model<Api>;
-    getConfig: () => Config | undefined;
-    toolExecutorConfig?: Partial<ToolExecutorConfig>;
-    sessionStore?: SessionStore;
-    /**
-     * Provided by the workflow tool from `AgentToolsFactory` — mirrors how
-     * `delegate-tool` is wired (avoids importing `tools/factory.ts` here and
-     * breaking the existing factory ↔ delegate-tool ↔ child-agent-factory
-     * dependency contract).
-     */
-    buildChildTools: (opts: BuildChildToolsOptions) => AgentTool<any, any>[];
-}
-export declare class DelegateSubagentRunner implements SubagentRunner {
-    private readonly deps;
-    constructor(deps: DelegateSubagentRunnerDeps);
-    run<T = string>(prompt: string, opts: SubagentRunOptions<T>): Promise<T | null>;
-    private preparePersistentSubagentSession;
-}
-export declare function resolveAllowedToolNames(requested: string[] | undefined, wantStructured: boolean): string[];

package/dist/src/agent/workflow/subagent-runner.js

@@ -1,221 +0,0 @@
-import { createLogger } from "../../utils/logger/index.js";
-import { init_logger } from "../../utils/logger.js";
-import { createSqliteTranscriptRuntime } from "../embedded/transcript-runtime.js";
-import { createDelegateChildHandle } from "../child-agent-factory.js";
-import { DELEGATION_TOOL_CAPABILITIES, protectDelegatedTool, resolveDelegationTools } from "../tools/delegation-policy.js";
-import { DELEGATE_BLOCKED_TOOLS } from "../tools/delegate-tool.js";
-import { createNoninteractiveToolPolicy } from "../tools/noninteractive-tool-policy.js";
-import { STRUCTURED_OUTPUT_TOOL_NAME, createStructuredOutputTool } from "./structured-output-tool.js";
-//#region src/agent/workflow/subagent-runner.ts
-init_logger();
-const log = createLogger("Agent:WorkflowSubagent");
-const DEFAULT_MAX_ITERATIONS = 30;
-var DelegateSubagentRunner = class {
-	constructor(deps) {
-		this.deps = deps;
-	}
-	async run(prompt, opts) {
-		if (opts.signal?.aborted) return null;
-		const capture = {
-			called: false,
-			value: void 0
-		};
-		const wantStructured = Boolean(opts.schema);
-		const allowed = resolveAllowedToolNames(opts.allowedToolNames, wantStructured);
-		const model = opts.model ?? safeResolveDefaultModel(this.deps.getDefaultModel);
-		if (!model) {
-			log.warn({ label: opts.label }, "subagent run skipped: no primary model resolved");
-			return null;
-		}
-		const fullPrompt = buildPrompt(prompt, opts, wantStructured);
-		const streamMode = resolveSubagentStreamMode(this.deps.getConfig);
-		const childOptions = {
-			isWorkspaceTrusted: this.deps.isWorkspaceTrusted,
-			workspace: this.deps.workspace,
-			goal: fullPrompt,
-			requesterConversationId: opts.sessionMetadata?.parentConversationId,
-			allowedToolNames: allowed,
-			isComplete: wantStructured ? () => capture.called : void 0,
-			maxIterations: opts.maxIterations ?? DEFAULT_MAX_ITERATIONS,
-			model,
-			bus: this.deps.bus,
-			agentId: this.deps.agentId,
-			getConfig: this.deps.getConfig,
-			toolExecutorConfig: this.deps.toolExecutorConfig,
-			authorizeToolCall: createNoninteractiveToolPolicy({
-				getConfig: this.deps.getConfig,
-				agentId: this.deps.agentId
-			}).beforeToolCall,
-			buildChildTools: (childOpts) => {
-				const candidates = this.deps.buildChildTools({
-					...childOpts,
-					agentId: this.deps.agentId ?? childOpts.agentId
-				});
-				const access = resolveDelegationTools(candidates.map((tool) => tool.name), "custom", opts.allowedToolNames, [
-					"local_read",
-					"web_read",
-					"knowledge_read",
-					"skills_read",
-					"external_read",
-					...opts.allowedToolNames?.includes("browser_use") ? ["browser"] : []
-				]);
-				if (access.rejected.length) throw new Error(`Workflow delegation rejected tools: ${JSON.stringify(access.rejected)}. Use delegate_task implement for isolated writes and commands.`);
-				const granted = new Set(access.granted);
-				const base = candidates.filter((tool) => granted.has(tool.name)).map(protectDelegatedTool);
-				if (!wantStructured || !opts.schema) return base;
-				return [...base.filter((t) => t.name !== STRUCTURED_OUTPUT_TOOL_NAME), createStructuredOutputTool({
-					schema: opts.schema,
-					capture
-				})];
-			},
-			progressHooks: opts.onProgress && streamMode !== "off" ? {
-				mode: streamMode === "full" ? "full" : "steps",
-				onProgress: (event) => {
-					opts.onProgress?.(mapChildProgressEvent(event));
-				}
-			} : void 0
-		};
-		if (opts.conversationId && opts.sessionMetadata && this.deps.sessionStore) {
-			await this.preparePersistentSubagentSession(opts.conversationId, opts.sessionMetadata);
-			childOptions.conversationId = opts.conversationId;
-			childOptions.transcriptRuntime = await createSqliteTranscriptRuntime({
-				conversationId: opts.conversationId,
-				sessionStore: this.deps.sessionStore
-			});
-		}
-		const handle = createDelegateChildHandle(childOptions);
-		const onAbort = () => handle.abort();
-		opts.signal?.addEventListener("abort", onAbort, { once: true });
-		try {
-			const { summary, status } = await handle.run();
-			if (status !== "success") return null;
-			if (opts.signal?.aborted) return null;
-			if (wantStructured) {
-				if (!capture.called) {
-					log.warn({ label: opts.label }, "subagent finished without calling structured_output");
-					return null;
-				}
-				return capture.value;
-			}
-			return summary;
-		} catch (e) {
-			if (opts.rethrow) throw e;
-			const msg = e instanceof Error ? e.message : String(e);
-			log.warn({
-				err: e,
-				label: opts.label,
-				errorMessage: msg
-			}, `subagent run failed: ${msg}`);
-			return null;
-		} finally {
-			opts.signal?.removeEventListener("abort", onAbort);
-		}
-	}
-	async preparePersistentSubagentSession(conversationId, metadata) {
-		const store = this.deps.sessionStore;
-		if (!store) return;
-		await store.resolveTranscriptPath(conversationId, { metadata: {
-			sessionType: "workflow-subagent",
-			hiddenFromSessionList: true,
-			parentConversationId: metadata.parentConversationId,
-			projectId: metadata.projectId,
-			workflowRunId: metadata.workflowRunId,
-			workflowDefinitionId: metadata.workflowDefinitionId,
-			workflowAgentId: metadata.workflowAgentId,
-			workflowAgentLabel: metadata.workflowAgentLabel,
-			sourceChannel: "workflow",
-			sourceChatId: metadata.workflowRunId,
-			routing: {
-				agentId: metadata.workflowAgentId || "main",
-				source: "workflow",
-				accountId: "default",
-				peerKind: "subagent",
-				peerId: metadata.workflowRunId
-			}
-		} });
-		await store.updateMetadata(conversationId, {
-			sessionType: "workflow-subagent",
-			hiddenFromSessionList: true,
-			parentConversationId: metadata.parentConversationId,
-			projectId: metadata.projectId,
-			workflowRunId: metadata.workflowRunId,
-			workflowDefinitionId: metadata.workflowDefinitionId,
-			workflowAgentId: metadata.workflowAgentId,
-			workflowAgentLabel: metadata.workflowAgentLabel,
-			name: metadata.workflowAgentLabel,
-			tags: ["workflow-subagent", metadata.workflowDefinitionId]
-		});
-	}
-};
-function resolveAllowedToolNames(requested, wantStructured) {
-	const filtered = (requested ?? Object.keys(DELEGATION_TOOL_CAPABILITIES).filter((name) => ![
-		"local_write",
-		"command",
-		"browser"
-	].includes(DELEGATION_TOOL_CAPABILITIES[name]))).map((s) => String(s).trim()).filter((s) => s.length > 0).filter((s) => !DELEGATE_BLOCKED_TOOLS.has(s));
-	if (wantStructured && !filtered.includes("structured_output")) filtered.push(STRUCTURED_OUTPUT_TOOL_NAME);
-	return [...new Set(filtered)];
-}
-function buildPrompt(prompt, opts, structured) {
-	const parts = [];
-	if (opts.instructions?.trim()) parts.push(opts.instructions.trim());
-	if (opts.label) parts.push(`Task label: ${opts.label}`);
-	if (opts.phase) parts.push(`Workflow phase: ${opts.phase}`);
-	parts.push(prompt);
-	if (structured) parts.push([
-		"Final output contract:",
-		"- Your final action MUST be a structured_output tool call.",
-		"- The structured_output arguments are the return value of this subagent.",
-		"- Do not emit a prose final answer instead of structured_output.",
-		"- If you need to inspect files or run commands first, do so, then call structured_output exactly once."
-	].join("\n"));
-	return parts.join("\n\n");
-}
-function safeResolveDefaultModel(get) {
-	try {
-		return get();
-	} catch (e) {
-		log.warn({ err: e }, "failed to resolve default subagent model");
-		return null;
-	}
-}
-function resolveSubagentStreamMode(_getConfig) {
-	return "steps";
-}
-function mapChildProgressEvent(event) {
-	switch (event.type) {
-		case "tool_start": return {
-			type: "tool_start",
-			toolCallId: event.toolCallId ?? "",
-			toolName: event.toolName ?? "tool",
-			args: event.args ?? {}
-		};
-		case "tool_end": return {
-			type: "tool_end",
-			toolCallId: event.toolCallId ?? "",
-			toolName: event.toolName ?? "tool",
-			isError: Boolean(event.isError),
-			resultPreview: event.resultPreview,
-			error: event.error
-		};
-		case "iteration": return {
-			type: "iteration",
-			count: event.count ?? 0,
-			max: event.max ?? 0
-		};
-		case "text_delta": return {
-			type: "text_delta",
-			delta: event.delta ?? ""
-		};
-		case "thinking_delta": return {
-			type: "thinking_delta",
-			delta: event.delta ?? ""
-		};
-		default: return {
-			type: "text_delta",
-			delta: ""
-		};
-	}
-}
-//#endregion
-export { DelegateSubagentRunner, resolveAllowedToolNames };

package/dist/src/agent/workflow/types.d.ts

@@ -1,252 +0,0 @@
-/**
- * Shared types for the workflow runtime.
- *
- * The runtime depends only on `SubagentRunner` — the adapter that wraps the
- * concrete child-agent factory lives in `subagent-runner.ts`. This keeps
- * `runtime.ts` free of any LLM-stack imports and makes alternate runners
- * (remote agents, test doubles) drop-in replacements.
- */
-import type { Model, Api } from '@earendil-works/pi-ai';
-/** Plain JSON Schema (no TypeBox brand). Mirrors the shape models emit verbatim. */
-export interface JsonSchema {
-    type?: string | string[];
-    properties?: Record<string, JsonSchema>;
-    items?: JsonSchema | JsonSchema[];
-    required?: string[];
-    additionalProperties?: boolean | JsonSchema;
-    enum?: unknown[];
-    const?: unknown;
-    description?: string;
-    [key: string]: unknown;
-}
-export interface WorkflowSnapshotPhase {
-    title: string;
-    detail?: string;
-    /** Default model for this phase: `provider/model` or configured typed id. */
-    model?: string;
-}
-export interface WorkflowEstimatedAgents {
-    min: number;
-    max: number;
-}
-/** One-click starter text in the gateway start dialog; `field` is `goal` or an `args` key. */
-export interface WorkflowExamplePrompt {
-    field: string;
-    text: string;
-}
-/** Locale-specific display copy overrides; top-level fields provide the default copy. */
-export interface WorkflowLocaleCopy {
-    title?: string;
-    description?: string;
-    whenToUse?: string;
-    examplePrompts?: WorkflowExamplePrompt[];
-}
-export interface WorkflowSnapshotDefinition {
-    name: string;
-    description: string;
-    whenToUse?: string;
-    phases?: WorkflowSnapshotPhase[];
-    /** Discovery tags, e.g. `['code-review', 'planning']`. */
-    tags?: string[];
-    /** Rough subagent count range for UX / cost hints. */
-    estimatedAgents?: WorkflowEstimatedAgents;
-    /** English-default example prompts for the gateway start dialog. */
-    examplePrompts?: WorkflowExamplePrompt[];
-    /** Locale bundles keyed by BCP-47 language tag (e.g. `zh`). */
-    i18n?: Record<string, WorkflowLocaleCopy>;
-}
-export type WorkflowAgentStatus = 'queued' | 'running' | 'done' | 'error' | 'skipped';
-export type WorkflowAgentStepStatus = 'running' | 'done' | 'error';
-export interface WorkflowAgentStep {
-    id: string;
-    kind: 'tool' | 'llm' | 'thinking';
-    /** Original tool name when `kind === 'tool'` (for chat UI reuse). */
-    toolName?: string;
-    label: string;
-    detail?: string;
-    status: WorkflowAgentStepStatus;
-    resultPreview?: string;
-    error?: string;
-    startedAtMs?: number;
-    durationMs?: number;
-}
-export interface WorkflowAgentSnapshot {
-    id: number;
-    label: string;
-    phase?: string;
-    prompt: string;
-    status: WorkflowAgentStatus;
-    resultPreview?: string;
-    error?: string;
-    startedAtMs?: number;
-    durationMs?: number;
-    steps?: WorkflowAgentStep[];
-    /** One-line summary for inline agent rows. */
-    currentStep?: string;
-    iteration?: number;
-    maxIterations?: number;
-    /** Accumulated assistant/thinking text when subagentStream is `full`. */
-    streamText?: string;
-}
-export interface WorkflowAgentInvocationSnapshot {
-    nodeId?: string;
-    prompt: string;
-    label: string;
-    phase?: string;
-    modelRef?: string;
-    resolvedModelRef?: string;
-    schema?: JsonSchema;
-    toolset?: string[];
-    maxIterations?: number;
-}
-export interface WorkflowSnapshot {
-    runId?: string;
-    name: string;
-    description?: string;
-    phases: string[];
-    currentPhase?: string;
-    logs: string[];
-    agents: WorkflowAgentSnapshot[];
-    agentCount: number;
-    runningCount: number;
-    doneCount: number;
-    errorCount: number;
-    skippedCount: number;
-    durationMs?: number;
-    result?: unknown;
-}
-export interface SubagentRunOptions<T = unknown> {
-    label: string;
-    /** When set, the subagent must return a value matching the schema (validated via ajv). */
-    schema?: JsonSchema;
-    /** Per-agent overrides; defaults filled by the runner adapter. */
-    allowedToolNames?: string[];
-    maxIterations?: number;
-    /** Resolved model. When omitted the adapter falls back to the workflow-level default. */
-    model?: Model<Api>;
-    signal?: AbortSignal;
-    /** Extra guidance prepended to the subagent prompt. */
-    instructions?: string;
-    /** When false (default), failures resolve to `null`; when true, errors propagate. */
-    rethrow?: boolean;
-    /** Hint about which phase this agent belongs to (passed through for logging). */
-    phase?: string;
-    /** Persistent hidden session for this workflow subagent. */
-    conversationId?: string;
-    sessionMetadata?: {
-        parentConversationId?: string;
-        projectId?: string;
-        workflowRunId: string;
-        workflowDefinitionId: string;
-        workflowAgentId: string;
-        workflowNodeId?: string;
-        workflowAgentLabel: string;
-    };
-    /** Live progress from the child agent loop (workflow tool binds per agent id). */
-    onProgress?: (event: SubagentProgressEvent) => void;
-    /** Pre-bound capture for structured output (internal: created by the adapter when schema present). */
-    __capture?: {
-        called: boolean;
-        value?: T;
-    };
-}
-export type SubagentProgressEvent = {
-    type: 'tool_start';
-    toolCallId: string;
-    toolName: string;
-    args: Record<string, unknown>;
-} | {
-    type: 'tool_end';
-    toolCallId: string;
-    toolName: string;
-    isError: boolean;
-    resultPreview?: string;
-    error?: string;
-} | {
-    type: 'iteration';
-    count: number;
-    max: number;
-} | {
-    type: 'text_delta';
-    delta: string;
-} | {
-    type: 'thinking_delta';
-    delta: string;
-};
-/**
- * Spawns a single fresh subagent and returns its result.
- *
- * - Without `schema`: returns the final assistant text (`string`).
- * - With `schema`: returns the value the subagent passed to the injected
- *   `structured_output` tool (validated, typed as `T`).
- *
- * Returns `null` when the subagent fails or aborts — runtime keeps going.
- */
-export interface SubagentRunner {
-    run<T = string>(prompt: string, opts: SubagentRunOptions<T>): Promise<T | null>;
-}
-export interface WorkflowRunOptions {
-    args?: unknown;
-    goal?: string;
-    cwd: string;
-    signal?: AbortSignal;
-    /** Hard upper bound on concurrent subagents (default min(16, cpu-2)). */
-    concurrency?: number;
-    /** Optional total token budget for the run. `null` means unlimited. */
-    tokenBudget?: number | null;
-    /** Hard cap on total subagent count for one workflow run (default 1000). */
-    maxSubagents?: number;
-    onLog?: (message: string) => void;
-    onPhase?: (title: string) => void;
-    onNodeStart?: (event: {
-        nodeId: string;
-        kind: string;
-        title: string;
-    }) => void;
-    onNodeEnd?: (event: {
-        nodeId: string;
-        kind: string;
-        title: string;
-        status: 'done' | 'error' | 'skipped';
-        result?: unknown;
-        error?: string;
-    }) => void;
-    onAgentQueued?: (event: {
-        id: number;
-        nodeId: string;
-        label: string;
-        phase?: string;
-        prompt: string;
-        invocation: WorkflowAgentInvocationSnapshot;
-    }) => void;
-    onAgentStart?: (event: {
-        id: number;
-        nodeId: string;
-        label: string;
-        phase?: string;
-        prompt: string;
-    }) => void;
-    onAgentEnd?: (event: {
-        id: number;
-        nodeId: string;
-        label: string;
-        phase?: string;
-        result: unknown;
-        status: WorkflowAgentStatus;
-    }) => void;
-    /** Merge extra subagent run options (e.g. progress callbacks) per agent id. */
-    enhanceSubagentRun?: (ctx: {
-        id: number;
-        nodeId: string;
-        label: string;
-        phase?: string;
-        prompt: string;
-    }) => Partial<SubagentRunOptions<unknown>>;
-}
-export interface WorkflowRunResult<T = unknown> {
-    result: T;
-    logs: string[];
-    phases: string[];
-    agentCount: number;
-    durationMs: number;
-}

package/dist/src/agent/workflow/types.js

@@ -1 +0,0 @@
-export {};

package/dist/src/agent/workflow/workflow-child-tools.d.ts

@@ -1,4 +0,0 @@
-import type { AgentTool } from '@earendil-works/pi-agent-core';
-import type { BuildChildToolsOptions } from '../child-agent-factory.js';
-/** Builds the tool set for workflow child agents (wired from gateway to avoid cycles). */
-export declare function buildWorkflowChildTools(childOptions: BuildChildToolsOptions): AgentTool<any, any>[];