toolcraft 0.0.103 → 0.0.105

package/composition.json

@@ -46,9 +46,14 @@
       "version": "0.1.0",
       "license": "MIT"
     },
+    {
+      "name": "tiny-stdio-mcp-server",
+      "version": "0.1.0",
+      "license": "MIT"
+    },
     {
       "name": "toolcraft",
-      "version": "0.0.103",
+      "version": "0.0.105",
       "license": "MIT"
     },
     {
@@ -58,7 +63,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.103",
+      "version": "0.0.105",
       "license": "MIT"
     }
   ]

package/dist/cli.js

@@ -18,6 +18,7 @@ import { enableSourceMaps, formatDebugStack } from "./stack-trim.js";
 import { suggest } from "./suggest.js";
 import { throwValidationErrors } from "./validation-errors.js";
 import { RESERVED_SERVICE_NAMES, createEnv, createFs, validateServices } from "./runtime/io.js";
+import { createManagedStream } from "./stream.js";
 export { renderErrorReport } from "./error-report.js";
 configureTheme({ brand: "blue", label: "Toolcraft" });
 export { configureTheme };
@@ -3050,6 +3051,58 @@ async function executeCommand(state, services, requirementOptions, runtimeFetch,
                 ...preflightContext,
                 params
             };
+            if (state.command.stream !== undefined) {
+                const stream = createManagedStream({
+                    eventSchema: state.command.stream.event,
+                    onStatus(event) {
+                        diagnostics.emit({
+                            level: "info",
+                            message: event.message ?? event.type,
+                            category: "runtime"
+                        });
+                        if (output === "rich" && event.message !== undefined) {
+                            logger.info(event.message);
+                        }
+                    },
+                    async create(signal, status) {
+                        return await state.command.handler({
+                            ...context,
+                            signal,
+                            status,
+                            async refreshSecrets() {
+                                return resolveCommandSecrets(state.command, runtimeEnv);
+                            }
+                        });
+                    }
+                });
+                const interrupt = () => {
+                    void stream.cancel(new UserError("Operation cancelled."));
+                };
+                process.once("SIGINT", interrupt);
+                try {
+                    for await (const event of stream) {
+                        if (output === "json") {
+                            const line = JSON.stringify(event);
+                            if (outputEmitter === undefined) {
+                                process.stdout.write(`${line}\n`);
+                            }
+                            else {
+                                outputEmitter(line);
+                            }
+                        }
+                        else {
+                            renderResult(state.command, event, output, primitives, outputEmitter === undefined
+                                ? undefined
+                                : (chunk) => outputEmitter(chunk.endsWith("\n") ? chunk.slice(0, -1) : chunk));
+                        }
+                    }
+                }
+                finally {
+                    process.removeListener("SIGINT", interrupt);
+                    await stream.cancel();
+                }
+                return;
+            }
             if (state.command.confirm &&
                 !state.command.humanInLoop &&
                 !resolvedFlags.yes &&

package/dist/composition.json

@@ -46,9 +46,14 @@
       "version": "0.1.0",
       "license": "MIT"
     },
+    {
+      "name": "tiny-stdio-mcp-server",
+      "version": "0.1.0",
+      "license": "MIT"
+    },
     {
       "name": "toolcraft",
-      "version": "0.0.103",
+      "version": "0.0.105",
       "license": "MIT"
     },
     {
@@ -58,7 +63,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.103",
+      "version": "0.0.105",
       "license": "MIT"
     }
   ]

package/dist/index.d.ts

@@ -1,10 +1,13 @@
 import type { McpServerConfig } from "@poe-code/agent-mcp-config";
-import type { ObjectSchema, Static } from "toolcraft-schema";
+import type { AnySchema, ObjectSchema, Static } from "toolcraft-schema";
 import type { LoggerOutput, RenderTableOptions, ThemePalette } from "toolcraft-design";
 import { ApprovalDeclinedError } from "./human-in-loop/types.js";
 import type { HumanInLoopConfig, HumanInLoopPending, HumanInLoopRuntimeOptions } from "./human-in-loop/types.js";
 import { ToolcraftBugError, UserError } from "./user-error.js";
 import type { RuntimeLogger } from "./runtime-logging.js";
+import type { StreamStatusEvent, ToolcraftStream } from "./stream.js";
+export { createManagedStream } from "./stream.js";
+export type { StreamConsumerOptions, StreamStatusEvent, StreamStatusType, ToolcraftStream } from "./stream.js";
 type ScopeValue = "cli" | "mcp" | "sdk";
 type AnyObjectSchema = ObjectSchema<Record<string, never>>;
 type EmptyServices = Record<string, never>;
@@ -114,9 +117,23 @@ export interface CommandConfig<TServices extends object, TParamsSchema extends O
     confirm?: boolean;
     humanInLoop?: HumanInLoopConfig<TParamsSchema> | null;
     requires?: Requires<CommandCheckContext<TParamsSchema, TSecrets, TServices>>;
-    handler: (ctx: HandlerContext<TParamsSchema, TSecrets, TServices>) => Promise<TResult>;
+    handler: (ctx: HandlerContext<TParamsSchema, TSecrets, TServices>) => Promise<TResult> | TResult;
     render?: Renderers<TResult>;
 }
+export interface StreamDefinition<TEventSchema extends AnySchema = AnySchema> {
+    event: TEventSchema;
+    bufferSize: number;
+}
+export type StreamHandlerContext<TParamsSchema extends ObjectSchema<any>, TSecrets extends SecretDeclarations | undefined, TServices extends object> = HandlerContext<TParamsSchema, TSecrets, TServices> & {
+    signal: AbortSignal;
+    status(event: StreamStatusEvent): void;
+    refreshSecrets(): Promise<InferSecrets<TSecrets>>;
+};
+export interface StreamCommandConfig<TServices extends object, TParamsSchema extends ObjectSchema<any>, TSecrets extends SecretDeclarations | undefined, TEventSchema extends AnySchema> extends Omit<CommandConfig<TServices, TParamsSchema, TSecrets, AsyncIterable<Static<TEventSchema>>>, "handler" | "render" | "result" | "humanInLoop" | "confirm"> {
+    event: TEventSchema;
+    handler: (ctx: StreamHandlerContext<TParamsSchema, TSecrets, TServices>) => AsyncIterable<Static<TEventSchema>> | Promise<AsyncIterable<Static<TEventSchema>>>;
+    render?: Renderers<Static<TEventSchema>>;
+}
 export interface Command<TServices extends object = EmptyServices, TParamsSchema extends ObjectSchema<any> = AnyObjectSchema, TSecrets extends SecretDeclarations | undefined = undefined, TResult = unknown> {
     kind: "command";
     name: string;
@@ -127,12 +144,13 @@ export interface Command<TServices extends object = EmptyServices, TParamsSchema
     positional: string[];
     params: TParamsSchema;
     result?: ObjectSchema<any>;
+    stream?: StreamDefinition<any>;
     secrets: SecretDeclarations;
     scope: Scope[];
     confirm: boolean;
     humanInLoop?: HumanInLoopConfig<TParamsSchema> | null;
     requires?: Requires<any>;
-    handler: (ctx: HandlerContext<TParamsSchema, TSecrets, TServices>) => Promise<TResult>;
+    handler: (ctx: HandlerContext<TParamsSchema, TSecrets, TServices>) => Promise<TResult> | TResult;
     render?: Renderers<TResult>;
 }
 export interface GroupConfig<TServices extends object> {
@@ -193,6 +211,10 @@ export declare function defineCommand<TServices extends object = EmptyServices,
     scope?: TOwnScope;
     humanInLoop?: TOwnHumanInLoop;
 }): Command<TServices, TParamsSchema, TSecrets, TResult> & TypedCommandMetadata<TName, TParamsSchema, TResult, TOwnScope, ResolveOwnHumanInLoopMode<TOwnHumanInLoop>>;
+export declare function defineStreamCommand<TServices extends object = EmptyServices, TName extends string = string, TParamsSchema extends ObjectSchema<any> = AnyObjectSchema, TSecrets extends SecretDeclarations | undefined = undefined, TEventSchema extends AnySchema = AnySchema, TOwnScope extends ScopeInput = undefined>(config: Omit<StreamCommandConfig<TServices, TParamsSchema, TSecrets, TEventSchema>, "name" | "scope"> & {
+    name: TName;
+    scope?: TOwnScope;
+}): Command<TServices, TParamsSchema, TSecrets, AsyncIterable<Static<TEventSchema>>> & TypedCommandMetadata<TName, TParamsSchema, ToolcraftStream<Static<TEventSchema>>, TOwnScope, undefined>;
 export declare function defineGroup<TServices extends object = EmptyServices, TName extends string = string, TChildren extends readonly unknown[] = readonly CommandNode<TServices>[], TOwnScope extends ScopeInput = undefined, TOwnHumanInLoop extends HumanInLoopConfig<AnyObjectSchema> | null | undefined = undefined>(config: Omit<GroupConfig<TServices>, "name" | "children" | "scope" | "humanInLoop"> & {
     name: TName;
     children: TChildren & readonly CommandNode<TServices>[];

package/dist/index.js

@@ -3,6 +3,7 @@ import { ApprovalDeclinedError } from "./human-in-loop/types.js";
 import { mergeHumanInLoopFromGroup, validateHumanInLoopOnDefine } from "./human-in-loop/config.js";
 import { ToolcraftBugError, UserError } from "./user-error.js";
 import { suggest } from "./suggest.js";
+export { createManagedStream } from "./stream.js";
 const commandConfigSymbol = Symbol("toolcraft.command.config");
 const groupConfigSymbol = Symbol("toolcraft.group.config");
 const commandSourcePathSymbol = Symbol("toolcraft.command.sourcePath");
@@ -297,6 +298,7 @@ function createBaseCommand(config) {
         positional: [...(config.positional ?? [])],
         params: config.params,
         result: config.result,
+        stream: undefined,
         secrets: cloneSecrets(config.secrets),
         scope: resolveCommandScope(config.scope, undefined),
         confirm: config.confirm ?? false,
@@ -365,6 +367,7 @@ function materializeCommand(command, inherited) {
         positional: [...command.positional],
         params: command.params,
         result: internal.result,
+        stream: command.stream,
         secrets: mergeSecrets(inherited.secrets, internal.secrets),
         scope: resolveCommandScope(internal.scope, inherited.scope),
         confirm: command.confirm,
@@ -456,6 +459,21 @@ export function defineCommand(config) {
         requires: undefined
     });
 }
+export function defineStreamCommand(config) {
+    const command = defineCommand({
+        ...config,
+        confirm: false,
+        humanInLoop: null,
+        handler: config.handler,
+        render: undefined
+    });
+    command.stream = {
+        event: config.event,
+        bufferSize: 1
+    };
+    command.render = config.render;
+    return command;
+}
 export function defineGroup(config) {
     validateRenameMap(config.rename);
     validateHumanInLoopOnDefine(config);

package/dist/mcp.d.ts

@@ -6,6 +6,12 @@ type Casing = "snake" | "camel";
 type CmdkitServer = Omit<TinyServer, "connect"> & {
     connect(transport: SDKTransport): Promise<void>;
 };
+export declare const MCP_STREAM_METHODS: {
+    readonly list: "toolcraft/streams/list";
+    readonly subscribe: "toolcraft/streams/subscribe";
+    readonly unsubscribe: "toolcraft/streams/unsubscribe";
+    readonly notification: "notifications/toolcraft/stream";
+};
 export interface RunMCPOptions<TServices extends object = Record<string, unknown>> {
     apiVersion?: string;
     approvals?: boolean;

package/dist/mcp.js

@@ -14,6 +14,13 @@ import { suggest } from "./suggest.js";
 import { throwValidationErrors } from "./validation-errors.js";
 import { createRuntimeLogger } from "./runtime-logging.js";
 import { createEnv, createFs, validateServices } from "./runtime/io.js";
+import { createManagedStream } from "./stream.js";
+export const MCP_STREAM_METHODS = {
+    list: "toolcraft/streams/list",
+    subscribe: "toolcraft/streams/subscribe",
+    unsubscribe: "toolcraft/streams/unsubscribe",
+    notification: "notifications/toolcraft/stream"
+};
 function normalizeRoots(roots) {
     if (!Array.isArray(roots)) {
         return roots;
@@ -728,7 +735,120 @@ function createResolvedMCPServer(root, options) {
         version,
         validateToolArguments: false
     });
-    for (const tool of tools) {
+    const streamTools = tools.filter((tool) => tool.command.stream !== undefined);
+    const subscriptions = new Map();
+    let nextSubscriptionId = 0;
+    server.method(MCP_STREAM_METHODS.list, () => ({
+        streams: streamTools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: tool.inputSchema,
+            eventSchema: applySchemaCasing(toJsonSchema(tool.command.stream.event), casing),
+            bufferSize: tool.command.stream.bufferSize
+        }))
+    }));
+    server.method(MCP_STREAM_METHODS.subscribe, async (request, session) => {
+        const name = typeof request?.name === "string" ? request.name : undefined;
+        const tool = streamTools.find((candidate) => candidate.name === name);
+        if (tool === undefined) {
+            throw new UserError(`Stream not found: ${name ?? ""}`);
+        }
+        const streamDefinition = tool.command.stream;
+        if (streamDefinition === undefined) {
+            throw new ToolcraftBugError(`Command "${tool.commandPath}" is not a stream.`);
+        }
+        const argumentsValue = isPlainObject(request?.arguments) ? request.arguments : {};
+        const secrets = resolveCommandSecrets(tool.command, options.env);
+        const baseContext = {
+            ...servicesWithBuiltIns,
+            secrets,
+            fetch: runtimeFetch,
+            fs: createFs(options.fs),
+            env: createEnv(options.env),
+            diagnostics,
+            progress(message) {
+                diagnostics.emit({ level: "info", message, category: "progress" });
+            }
+        };
+        await assertCommandRequirements(tool.command, { ...baseContext, params: undefined }, { apiVersion: options.apiVersion, env: options.env });
+        const params = validateToolArguments(tool.command.params, argumentsValue, casing);
+        const subscriptionId = `stream-${++nextSubscriptionId}`;
+        let notificationQueue = Promise.resolve();
+        const notify = (params) => {
+            notificationQueue = notificationQueue.then(() => session.notify(MCP_STREAM_METHODS.notification, params));
+            return notificationQueue;
+        };
+        const stream = createManagedStream({
+            eventSchema: streamDefinition.event,
+            signal: session.signal,
+            onStatus(event) {
+                void notify({
+                    subscriptionId,
+                    type: "status",
+                    status: event
+                });
+            },
+            async create(signal, status) {
+                return await tool.command.handler({
+                    ...baseContext,
+                    params,
+                    signal,
+                    status,
+                    async refreshSecrets() {
+                        return resolveCommandSecrets(tool.command, options.env);
+                    }
+                });
+            }
+        });
+        subscriptions.set(subscriptionId, { signal: session.signal, stream });
+        void (async () => {
+            try {
+                for await (const event of stream) {
+                    await notify({
+                        subscriptionId,
+                        type: "data",
+                        event
+                    });
+                }
+                if (!session.signal.aborted) {
+                    await notify({
+                        subscriptionId,
+                        type: "end"
+                    });
+                }
+            }
+            catch (error) {
+                if (!session.signal.aborted) {
+                    await notify({
+                        subscriptionId,
+                        type: "error",
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                }
+            }
+            finally {
+                subscriptions.delete(subscriptionId);
+                await stream.cancel();
+            }
+        })();
+        return {
+            subscriptionId,
+            eventSchema: applySchemaCasing(toJsonSchema(streamDefinition.event), casing)
+        };
+    });
+    server.method(MCP_STREAM_METHODS.unsubscribe, async (request, session) => {
+        const subscriptionId = typeof request?.subscriptionId === "string" ? request.subscriptionId : undefined;
+        const subscription = subscriptionId === undefined ? undefined : subscriptions.get(subscriptionId);
+        if (subscriptionId === undefined ||
+            subscription === undefined ||
+            subscription.signal !== session.signal) {
+            return { unsubscribed: false };
+        }
+        await subscription.stream.cancel();
+        subscriptions.delete(subscriptionId);
+        return { unsubscribed: true };
+    });
+    for (const tool of tools.filter((candidate) => candidate.command.stream === undefined)) {
         const handler = async (argumentsValue) => {
             let params;
             let secrets;

package/dist/sdk.d.ts

@@ -3,6 +3,7 @@ import type { Group, HandlerFs, LogLevel, RuntimeLoggerInput, Scope } from "./in
 import { type ErrorReportsOption } from "./error-report.js";
 import type { HumanInLoopPending, HumanInLoopRuntimeOptions } from "./human-in-loop/index.js";
 import { type ValidationError } from "./validation-errors.js";
+import type { StreamConsumerOptions, ToolcraftStream } from "./stream.js";
 type ScopeInput = readonly Scope[] | undefined;
 type HumanInLoopMode = "sync" | "async";
 type HumanInLoopModeInput = HumanInLoopMode | null | undefined;
@@ -32,7 +33,7 @@ type Camelize<TValue> = TValue extends Primitive ? TValue : TValue extends reado
     [TKey in keyof TValue as TKey extends string ? CamelCase<TKey> : TKey]: Camelize<TValue[TKey]>;
 } : TValue;
 type SDKResult<TResult, THumanInLoopMode extends HumanInLoopMode | undefined> = [THumanInLoopMode] extends ["async"] ? ["async"] extends [THumanInLoopMode] ? HumanInLoopPending : TResult : TResult;
-type SDKMethod<TParamsSchema extends ObjectSchema<any>, TResult> = (params: Camelize<Static<TParamsSchema>>) => Promise<TResult>;
+type SDKMethod<TParamsSchema extends ObjectSchema<any>, TResult> = TResult extends ToolcraftStream<infer TEvent> ? (params: Camelize<Static<TParamsSchema>>, options?: StreamConsumerOptions) => ToolcraftStream<TEvent> : (params: Camelize<Static<TParamsSchema>>) => Promise<TResult>;
 type UnionToIntersection<TValue> = (TValue extends unknown ? (value: TValue) => void : never) extends (value: infer TResult) => void ? TResult : never;
 type Simplify<TValue> = {
     [TKey in keyof TValue]: TValue[TKey];

package/dist/sdk.js

@@ -10,6 +10,7 @@ import { suggest } from "./suggest.js";
 import { throwValidationErrors } from "./validation-errors.js";
 import { createRuntimeLogger } from "./runtime-logging.js";
 import { createEnv, createFs, validateServices } from "./runtime/io.js";
+import { createManagedStream } from "./stream.js";
 function splitWords(value) {
     const words = [];
     let current = "";
@@ -330,6 +331,61 @@ function createResolvedSDK(root, options = {}) {
             if (sdkParamsSchema?.kind === "object") {
                 validateUniqueSDKParameterMembers(sdkParamsSchema);
             }
+            if (node.stream !== undefined) {
+                return (params, streamOptions = {}) => createManagedStream({
+                    eventSchema: node.stream.event,
+                    ...streamOptions,
+                    async create(signal, status) {
+                        const commandPath = [...path, node.name].join(".");
+                        let secrets;
+                        let validatedParams;
+                        try {
+                            secrets = resolveCommandSecrets(node, options.env);
+                            const baseContext = {
+                                ...services,
+                                runtimeOptions,
+                                root,
+                                secrets,
+                                fetch: runtimeFetch,
+                                fs: createFs(options.fs),
+                                env: createEnv(options.env),
+                                diagnostics,
+                                progress(message) {
+                                    diagnostics.emit({ level: "info", message, category: "progress" });
+                                }
+                            };
+                            await assertCommandRequirements(node, { ...baseContext, params: undefined }, { apiVersion: options.apiVersion, env: options.env });
+                            const paramsSchema = filterSchemaForScope(node.params, "sdk");
+                            if (paramsSchema === undefined || paramsSchema.kind !== "object") {
+                                throw new ToolcraftBugError(`command "${node.name}" must define an object params schema for SDK.`);
+                            }
+                            validatedParams = validateSDKArguments(paramsSchema, params);
+                            return await node.handler({
+                                ...baseContext,
+                                params: validatedParams,
+                                signal,
+                                status,
+                                async refreshSecrets() {
+                                    return resolveCommandSecrets(node, options.env);
+                                }
+                            });
+                        }
+                        catch (error) {
+                            await writeErrorReport({
+                                command: node,
+                                commandPath,
+                                env: process.env,
+                                error,
+                                errorReports: options.errorReports,
+                                params: validatedParams,
+                                projectRoot: options.projectRoot,
+                                secrets
+                            });
+                            throw error;
+                        }
+                    }
+                });
+            }
             return async (params) => {
                 const commandPath = [...path, node.name].join(".");
                 let secrets;

package/dist/stream.d.ts

@@ -0,0 +1,19 @@
+import { type AnySchema, type Static } from "toolcraft-schema";
+export type StreamStatusType = "connected" | "progress" | "reconnecting";
+export interface StreamStatusEvent {
+    type: StreamStatusType;
+    message?: string;
+}
+export interface StreamConsumerOptions {
+    signal?: AbortSignal;
+    onStatus?: (event: StreamStatusEvent) => void;
+}
+export interface ToolcraftStream<TEvent> extends AsyncIterable<TEvent> {
+    readonly signal: AbortSignal;
+    cancel(reason?: unknown): Promise<void>;
+}
+export interface ManagedStreamOptions<TSchema extends AnySchema> extends StreamConsumerOptions {
+    eventSchema: TSchema;
+    create(signal: AbortSignal, status: (event: StreamStatusEvent) => void): Promise<AsyncIterable<Static<TSchema>>>;
+}
+export declare function createManagedStream<TSchema extends AnySchema>(options: ManagedStreamOptions<TSchema>): ToolcraftStream<Static<TSchema>>;

package/dist/stream.js

@@ -0,0 +1,92 @@
+import { validate } from "toolcraft-schema";
+import { UserError } from "./user-error.js";
+function validationMessage(schema, value) {
+    const result = validate(schema, value);
+    return result.ok ? undefined : result.issues.map((issue) => issue.message).join("; ");
+}
+export function createManagedStream(options) {
+    const controller = new AbortController();
+    let iterator;
+    let iteratorPromise;
+    let closePromise;
+    let done = false;
+    const getIterator = async () => {
+        if (iterator !== undefined) {
+            return iterator;
+        }
+        iteratorPromise ??= options
+            .create(controller.signal, (event) => options.onStatus?.(event))
+            .then((iterable) => iterable[Symbol.asyncIterator]());
+        iterator = await iteratorPromise;
+        return iterator;
+    };
+    const close = async (reason) => {
+        if (closePromise !== undefined) {
+            return closePromise;
+        }
+        closePromise = (async () => {
+            controller.abort(reason);
+            options.signal?.removeEventListener("abort", abortFromConsumer);
+            if (done || (iterator === undefined && iteratorPromise === undefined)) {
+                done = true;
+                return;
+            }
+            const activeIterator = await getIterator();
+            done = true;
+            await activeIterator.return?.();
+        })();
+        return closePromise;
+    };
+    const abortFromConsumer = () => {
+        void close(options.signal?.reason);
+    };
+    if (options.signal?.aborted === true) {
+        abortFromConsumer();
+    }
+    else {
+        options.signal?.addEventListener("abort", abortFromConsumer, { once: true });
+    }
+    const stream = {
+        signal: controller.signal,
+        cancel: close,
+        [Symbol.asyncIterator]() {
+            return {
+                async next() {
+                    if (done || controller.signal.aborted) {
+                        await close(controller.signal.reason);
+                        return { done: true, value: undefined };
+                    }
+                    const activeIterator = await getIterator();
+                    let result;
+                    try {
+                        result = await activeIterator.next();
+                    }
+                    catch (error) {
+                        await close(error);
+                        throw error;
+                    }
+                    if (result.done === true) {
+                        done = true;
+                        options.signal?.removeEventListener("abort", abortFromConsumer);
+                        return { done: true, value: undefined };
+                    }
+                    const message = validationMessage(options.eventSchema, result.value);
+                    if (message !== undefined) {
+                        await close(new UserError(message));
+                        throw new UserError(message);
+                    }
+                    return { done: false, value: result.value };
+                },
+                async return() {
+                    await close();
+                    return { done: true, value: undefined };
+                },
+                async throw(error) {
+                    await close(error);
+                    throw error;
+                }
+            };
+        }
+    };
+    return stream;
+}

package/dist/testing/harness.d.ts

@@ -3,6 +3,7 @@ import { type DiagnosticLogEvent, type LogLevel } from "../runtime-logging.js";
 import { type FetchRoute } from "./fakes.js";
 import { type FsChange, type MemoryFs } from "./memory-fs.js";
 import { type ParityResult } from "./parity.js";
+import { type StreamStatusEvent } from "../stream.js";
 export type PipelineStage = "resolve" | "secrets" | "requirements" | "params" | "confirm" | "handler" | "render";
 export type EffectEvent = {
     seq: number;
@@ -67,10 +68,20 @@ export interface RunResult<T> {
 }
 export interface CommandTestHarness {
     run<T>(path: string[], params?: Record<string, unknown>): Promise<RunResult<T>>;
+    stream<T>(path: string[], params?: Record<string, unknown>, options?: {
+        limit?: number;
+        signal?: AbortSignal;
+    }): Promise<StreamRunResult<T>>;
     parity(path: string[], params?: Record<string, unknown>): Promise<ParityResult>;
     fs: MemoryFs;
     timeline: EffectEvent[];
 }
+export interface StreamRunResult<T> {
+    ok: boolean;
+    events: T[];
+    statuses: StreamStatusEvent[];
+    error?: unknown;
+}
 type EmptyHarnessServices = Record<string, never>;
 export declare function createCommandTestHarness<TServices extends object = EmptyHarnessServices>(root: Group, options?: HarnessOptions<TServices>): CommandTestHarness;
 export {};