@bastani/atomic 0.9.16-alpha.2 → 0.9.16-alpha.3

package/dist/builtin/workflows/src/extension/workflow-schema.ts

@@ -1,192 +0,0 @@
-import { type Static, Type } from "typebox";
-
-/**
- * Advertise the JSON value types accepted by workflow-send responses.
- *
- * `Type.Unknown()` emits `{}`, which tells a provider nothing about this
- * property. A retained session shows an assistant tool call that answered a
- * `ctx.ui.confirm` prompt with the string `"true"` rather than a boolean, so
- * naming the accepted types is worth doing. It is not the runtime fix: no
- * inspected host or pi-ai layer converts a boolean to a string, and prompt-kind
- * normalization happens at the pending-prompt boundary, not in provider
- * argument validation.
- *
- * String comes first so validation does not convert text answers to booleans.
- */
-const WorkflowResponseSchema = Type.Union(
-	[
-		Type.String(),
-		Type.Boolean(),
-		Type.Number(),
-		Type.Null(),
-		Type.Array(Type.Unknown()),
-		Type.Record(Type.String(), Type.Unknown()),
-	],
-	{
-		description:
-			"Answer payload for a pending stage prompt. Primitive prompts accept text strings, booleans, or numeric select indexes according to the prompt kind; structured prompts may accept JSON arrays or objects.",
-	},
-);
-
-/** Run-budget declaration accepted by config, authored workflows, and tool runs. */
-export const WorkflowBudgetSchema = Type.Object(
-	{
-		maxDurationMs: Type.Optional(
-			Type.Integer({ minimum: 0, description: "Maximum run duration in milliseconds; 0 disables it." }),
-		),
-		maxTokens: Type.Optional(Type.Integer({ minimum: 0, description: "Maximum charged tokens; 0 disables it." })),
-		maxCost: Type.Optional(Type.Number({ minimum: 0, description: "Maximum cost in USD; 0 disables it." })),
-		warnAtPercent: Type.Optional(
-			Type.Number({ minimum: 0, description: "Usage percentage at which to warn; 0 disables it." }),
-		),
-	},
-	{ additionalProperties: false, description: "Optional workflow run budget." },
-);
-
-export const WorkflowParametersSchema = Type.Object(
-	{
-		workflow: Type.Optional(
-			Type.String({
-				description: "Named workflow ID for named-workflow execution.",
-			}),
-		),
-		inputs: Type.Optional(
-			Type.Record(Type.String(), Type.Unknown(), {
-				default: {},
-				description: "Key/value inputs passed to a named workflow run.",
-			}),
-		),
-		budget: Type.Optional(WorkflowBudgetSchema),
-		action: Type.Optional(
-			Type.Union(
-				[
-					Type.Literal("models"),
-					Type.Literal("run"),
-					Type.Literal("list"),
-					Type.Literal("get"),
-					Type.Literal("inputs"),
-					Type.Literal("status"),
-					Type.Literal("stages"),
-					Type.Literal("stage"),
-					Type.Literal("transcript"),
-					Type.Literal("send"),
-					Type.Literal("pause"),
-					Type.Literal("interrupt"),
-					Type.Literal("quit"),
-					Type.Literal("resume"),
-					Type.Literal("reload"),
-				],
-				{
-					description:
-						"Workflow action: run/list/get/inputs/models/status, inspect stage metadata, send messages or prompt answers, pause/resume/interrupt/quit runs, inspect the configured model catalog, or reload workflow resources. 'status' without runId lists every workflow run in the current session with concise per-run summaries (status, timing, active stages, awaiting-input prompts); filter the listing with statusFilter. 'status' with runId returns one run's full detail. For transcript inspection, prefer status/stages/stage first to get sessionFile/transcriptPath, quote the exact path without rewriting separators (Windows backslashes are valid), then search it with rg/grep and read small ranges; transcript is path-only by default when sessionFile/transcriptPath exists, explicit tail/limit returns bounded previews, and missing transcript paths fall back to a small preview.",
-				},
-			),
-		),
-		runId: Type.Optional(
-			Type.String({
-				description:
-					"Full 36-character run UUID for status/stages/stage/transcript/send/pause/resume/interrupt/quit. Prefixes are not accepted; pass the id exactly as displayed. Omit runId with action 'status' to list all session runs and their statuses. Use '--all' or all:true for supported bulk run-control actions.",
-			}),
-		),
-		all: Type.Optional(
-			Type.Boolean({
-				description:
-					"Apply supported run-control actions (pause/interrupt/quit) to all in-flight runs instead of one run; cannot be combined with stageId.",
-			}),
-		),
-		stageId: Type.Optional(
-			Type.String({
-				description:
-					"Exact stage id or exact stage name for stage-scoped inspection, transcript, send, pause, or resume. Prefixes and partial names are not accepted. A nested stage id is the full 'runId:stageId' composite. For interrupt and quit it may also name an in-flight ctx.tool node by its exact tool:<argsHash> id or tool name, which aborts that single call.",
-			}),
-		),
-		message: Type.Optional(
-			Type.String({
-				description:
-					"Message payload for send/follow-up/prompt/steer/resume, or optional text forwarded when resuming paused work.",
-			}),
-		),
-		statusFilter: Type.Optional(
-			Type.Union(
-				[
-					Type.Literal("pending"),
-					Type.Literal("running"),
-					Type.Literal("awaiting_input"),
-					Type.Literal("paused"),
-					Type.Literal("blocked"),
-					Type.Literal("completed"),
-					Type.Literal("failed"),
-					Type.Literal("skipped"),
-					Type.Literal("cancelled"),
-					Type.Literal("killed"),
-					Type.Literal("all"),
-				],
-				{
-					description:
-						"Filter stages (stages action) or listed runs (status action without runId) by status; 'all' (default) includes everything. For the status listing, run statuses match directly, 'awaiting_input' selects runs with at least one stage awaiting input or pending human prompt, and in-flight runs are listed first.",
-				},
-			),
-		),
-		format: Type.Optional(
-			Type.Union([Type.Literal("text"), Type.Literal("json")], {
-				description:
-					"Agent-visible output format for data-bearing inspection actions (models, status, stages, stage, transcript); 'json' returns the full structured result.",
-			}),
-		),
-		limit: Type.Optional(
-			Type.Integer({
-				minimum: 0,
-				description:
-					"Transcript-only: explicitly inline at most this many recent entries. Omit both limit and tail to use the path-only default when sessionFile/transcriptPath exists; prefer rg/grep on the exact quoted sessionFile/transcriptPath for targeted lookup without rewriting platform path separators.",
-			}),
-		),
-		tail: Type.Optional(
-			Type.Integer({
-				minimum: 0,
-				description:
-					"Transcript-only: explicitly inline the last N entries; overrides limit. Use for quick recent-context checks after status/stages/stage expose the transcript path.",
-			}),
-		),
-		includeToolOutput: Type.Optional(
-			Type.Boolean({
-				description:
-					"Transcript-only: include captured tool output entries when building inlined snapshot previews; this does not bypass the path-only default. Prefer rg/grep on the exact quoted sessionFile/transcriptPath for large outputs. Live session transcripts may not expose tool output.",
-			}),
-		),
-		text: Type.Optional(
-			Type.String({
-				description: "Text to send to a stage for prompt answers, steering, follow-ups, or resume messages.",
-			}),
-		),
-		response: Type.Optional(WorkflowResponseSchema),
-		delivery: Type.Optional(
-			Type.Union(
-				[
-					Type.Literal("auto"),
-					Type.Literal("answer"),
-					Type.Literal("prompt"),
-					Type.Literal("steer"),
-					Type.Literal("followUp"),
-					Type.Literal("resume"),
-				],
-				{
-					description:
-						"Delivery mode for the send action: auto answers pending prompts first, then resumes paused stages, steers streaming stages, or queues a follow-up.",
-				},
-			),
-		),
-		promptId: Type.Optional(
-			Type.String({
-				description: "Pending prompt identifier to answer when using the send action.",
-			}),
-		),
-		reason: Type.Optional(
-			Type.String({
-				description: "Human-readable reason for the reload action, echoed in the reload result.",
-			}),
-		),
-	},
-	{ additionalProperties: false },
-);
-
-export type WorkflowParameters = Static<typeof WorkflowParametersSchema>;

package/dist/builtin/workflows/src/extension/workflow-stage-results.ts

@@ -1,252 +0,0 @@
-import type { StageSnapshot, StageStatus, ToolEvent } from "../shared/store-types.js";
-import type { WorkflowToolArgs } from "./public-types.js";
-import type { WorkflowToolResult } from "./render-result.js";
-
-export type WorkflowStageSummary = {
-	id: string;
-	name: string;
-	status: StageStatus;
-	sessionId?: string;
-	sessionFile?: string;
-	transcriptPath?: string;
-	error?: string;
-	skippedReason?: string;
-	awaitingInputSince?: number;
-	pendingPrompt?: StageSnapshot["pendingPrompt"];
-	inputRequest?: StageSnapshot["inputRequest"];
-	promptFootprint?: StageSnapshot["promptFootprint"];
-};
-
-export type WorkflowTranscriptEntry = {
-	role: string;
-	text?: string;
-	toolName?: string;
-	output?: string;
-	timestamp?: number;
-};
-
-type MessageContentBlock = { readonly type?: string; readonly text?: string };
-
-export type MessageLike = {
-	readonly role?: string;
-	readonly content?: string | readonly MessageContentBlock[];
-	readonly name?: string;
-	readonly toolName?: string;
-	readonly timestamp?: number;
-	readonly createdAt?: number;
-};
-
-export function cloneStage(stage: StageSnapshot): StageSnapshot & { transcriptPath?: string } {
-	const cloned = structuredClone(stage) as StageSnapshot & { transcriptPath?: string };
-	if (cloned.sessionFile !== undefined) cloned.transcriptPath = cloned.sessionFile;
-	return cloned;
-}
-
-export function summarizeStage(stage: StageSnapshot): WorkflowStageSummary {
-	return {
-		id: stage.id,
-		name: stage.name,
-		status: stage.status,
-		sessionId: stage.sessionId,
-		sessionFile: stage.sessionFile,
-		transcriptPath: stage.sessionFile,
-		error: stage.error,
-		skippedReason: stage.skippedReason,
-		awaitingInputSince: stage.awaitingInputSince,
-		pendingPrompt: stage.pendingPrompt === undefined ? undefined : structuredClone(stage.pendingPrompt),
-		inputRequest: stage.inputRequest === undefined ? undefined : structuredClone(stage.inputRequest),
-		promptFootprint: stage.promptFootprint === undefined ? undefined : structuredClone(stage.promptFootprint),
-	};
-}
-
-const DEFAULT_TRANSCRIPT_LIMIT = 5;
-
-type TranscriptEntrySelection = {
-	entries: WorkflowTranscriptEntry[];
-	truncated: boolean;
-	entryCount: number;
-	entryLimit?: number;
-};
-
-type WorkflowTranscriptResult = Extract<WorkflowToolResult, { action: "transcript" }>;
-
-function isTranscriptPreviewExplicit(args: WorkflowToolArgs): boolean {
-	return args.tail !== undefined || args.limit !== undefined;
-}
-
-export function shouldIncludeSnapshotToolOutput(args: WorkflowToolArgs, sessionFile?: string): boolean {
-	return args.includeToolOutput === true && (isTranscriptPreviewExplicit(args) || sessionFile === undefined);
-}
-
-function requestedTranscriptEntryLimit(args: WorkflowToolArgs): number {
-	const raw = args.tail ?? args.limit;
-	if (raw === undefined) return DEFAULT_TRANSCRIPT_LIMIT;
-	if (!Number.isFinite(raw) || raw <= 0) return 0;
-	return Math.floor(raw);
-}
-
-function selectTranscriptEntries(
-	entries: readonly WorkflowTranscriptEntry[],
-	args: WorkflowToolArgs,
-): TranscriptEntrySelection {
-	const count = requestedTranscriptEntryLimit(args);
-	const entryCount = entries.length;
-	if (count === 0) return { entries: [], truncated: false, entryCount, entryLimit: count };
-	if (entries.length <= count) {
-		return { entries: [...entries], truncated: false, entryCount, entryLimit: count };
-	}
-	return {
-		entries: entries.slice(entries.length - count),
-		truncated: true,
-		entryCount,
-		entryLimit: count,
-	};
-}
-
-function transcriptLazyReadPrompt(path: string): string {
-	return `Transcript not inlined to protect context. Read it lazily from ${path} with your file read tools (read small ranges; rg/grep for targeted lookups).`;
-}
-
-function transcriptFallbackNote(limit: number): string {
-	return `No transcript file path is available for this stage; falling back to a bounded inline preview of up to ${limit} recent ${limit === 1 ? "entry" : "entries"}.`;
-}
-
-export function shapeTranscriptResult(input: {
-	runId: string;
-	stageId: string;
-	source: "live" | "snapshot";
-	entryCount: number;
-	buildEntries: () => readonly WorkflowTranscriptEntry[];
-	args: WorkflowToolArgs;
-	sessionId?: string | undefined;
-	sessionFile?: string | undefined;
-	transcriptPath?: string | undefined;
-}): WorkflowTranscriptResult {
-	const transcriptPath = input.transcriptPath ?? input.sessionFile;
-	if (transcriptPath !== undefined && !isTranscriptPreviewExplicit(input.args)) {
-		const result: WorkflowTranscriptResult = {
-			action: "transcript",
-			runId: input.runId,
-			stageId: input.stageId,
-			source: input.source,
-			entries: [],
-			truncated: input.entryCount > 0,
-			entryCount: input.entryCount,
-			entryLimit: 0,
-			lazyReadPrompt: transcriptLazyReadPrompt(transcriptPath),
-			inlineMode: "path_only",
-		};
-		if (input.sessionId !== undefined) result.sessionId = input.sessionId;
-		if (input.sessionFile !== undefined) result.sessionFile = input.sessionFile;
-		result.transcriptPath = transcriptPath;
-		return result;
-	}
-
-	const limited = selectTranscriptEntries(input.buildEntries(), input.args);
-	const result: WorkflowTranscriptResult = {
-		action: "transcript",
-		runId: input.runId,
-		stageId: input.stageId,
-		source: input.source,
-		entries: limited.entries,
-		truncated: limited.truncated,
-		entryCount: limited.entryCount,
-		entryLimit: limited.entryLimit,
-		inlineMode: transcriptPath === undefined ? "fallback_preview" : "preview",
-	};
-	if (input.sessionId !== undefined) result.sessionId = input.sessionId;
-	if (input.sessionFile !== undefined) result.sessionFile = input.sessionFile;
-	if (transcriptPath !== undefined) result.transcriptPath = transcriptPath;
-	if (transcriptPath === undefined) {
-		result.fallbackNote = transcriptFallbackNote(limited.entryLimit ?? DEFAULT_TRANSCRIPT_LIMIT);
-	}
-	return result;
-}
-
-function messageText(content: MessageLike["content"]): string | undefined {
-	if (typeof content === "string") return content;
-	if (!Array.isArray(content)) return undefined;
-	let sawTextBlock = false;
-	const text = content
-		.map((block) => {
-			if (block.type === "text" && typeof block.text === "string") {
-				sawTextBlock = true;
-				return block.text;
-			}
-			return "";
-		})
-		.join("");
-	return sawTextBlock ? text : undefined;
-}
-
-export function transcriptEntryFromMessage(message: MessageLike): WorkflowTranscriptEntry {
-	const entry: WorkflowTranscriptEntry = { role: message.role ?? "unknown" };
-	const text = messageText(message.content);
-	if (text !== undefined) entry.text = text;
-	const toolName = message.toolName ?? message.name;
-	if (toolName !== undefined) entry.toolName = toolName;
-	const timestamp = message.timestamp ?? message.createdAt;
-	if (timestamp !== undefined) entry.timestamp = timestamp;
-	return entry;
-}
-
-function transcriptEntriesFromToolEvents(
-	events: readonly ToolEvent[],
-	includeOutput: boolean,
-): WorkflowTranscriptEntry[] {
-	return events.map((event) => ({
-		role: "tool",
-		toolName: event.name,
-		output: includeOutput ? event.output : undefined,
-		timestamp: event.endedAt ?? event.startedAt,
-	}));
-}
-
-function sortTranscriptEntriesChronologically(entries: readonly WorkflowTranscriptEntry[]): WorkflowTranscriptEntry[] {
-	return entries
-		.map((entry, index) => ({ entry, index }))
-		.sort((a, b) => {
-			const aTimestamp = a.entry.timestamp;
-			const bTimestamp = b.entry.timestamp;
-			if (typeof aTimestamp === "number" && typeof bTimestamp === "number" && aTimestamp !== bTimestamp) {
-				return aTimestamp - bTimestamp;
-			}
-			return a.index - b.index;
-		})
-		.map(({ entry }) => entry);
-}
-
-function terminalTranscriptEntry(
-	role: "assistant" | "notice",
-	text: string,
-	endedAt: number | undefined,
-): WorkflowTranscriptEntry {
-	const entry: WorkflowTranscriptEntry = { role, text };
-	if (endedAt !== undefined) entry.timestamp = endedAt;
-	return entry;
-}
-
-export function snapshotTranscriptEntries(
-	snapshot: StageSnapshot | undefined,
-	includeOutput: boolean,
-): WorkflowTranscriptEntry[] {
-	if (snapshot === undefined) return [];
-	const entries: WorkflowTranscriptEntry[] = [
-		...transcriptEntriesFromToolEvents(snapshot.toolEvents ?? [], includeOutput),
-	];
-	if (snapshot.result !== undefined) {
-		entries.push(terminalTranscriptEntry("assistant", snapshot.result, snapshot.endedAt));
-	}
-	if (snapshot.error !== undefined) {
-		entries.push(terminalTranscriptEntry("notice", snapshot.error, snapshot.endedAt));
-	}
-	return sortTranscriptEntriesChronologically(entries);
-}
-
-export function snapshotTranscriptEntryCount(snapshot: StageSnapshot | undefined): number {
-	return (
-		(snapshot?.toolEvents?.length ?? 0) +
-		(snapshot?.result !== undefined ? 1 : 0) +
-		(snapshot?.error !== undefined ? 1 : 0)
-	);
-}