@anvia/core 1.0.0-rc.1 → 1.0.0-rc.3

package/dist/pipeline/index.d.ts

@@ -1,36 +1,32 @@
-import { A as Agent } from '../agent-DGYY_onS.js';
-import { J as JsonObject, C as CompletionModel } from '../types-B3A4YxaA.js';
-import { Extractor } from '../extractor/index.js';
+import { t as AgentSuspendedResult, f as AgentInput, m as AgentRunSettings } from '../types-CElwurHZ.js';
+import { A as Agent } from '../agent-CXScUOpX.js';
+import { J as JsonObject, C as CompletionModel } from '../types-D9rKQ_as.js';
+import { ExtractOptions } from '../extractor/index.js';
 import { z } from 'zod';
-import '../guardrails/index.js';
+import '../interactions-csssHYcN.js';
 import '../type-utils-CtHVDRn_.js';
-import '../types-BBEGKB9m.js';
-import '../index-DxB74ybJ.js';
-import '../retry-D3Ruy-ba.js';
-import '../middleware-KynLg_RW.js';
-import '../tool-C_8GudXn.js';
+import '../retry-CjvSlKGW.js';
+import '../types-CIPaIbZo.js';
+import '../types-DbolvLtZ.js';
+import '../tool-r62gf3QY.js';
 import '../zod-schema-C7F4clpm.js';
-import '../types-DulRCYdB.js';
-import '@modelcontextprotocol/sdk/client/sse.js';
-import '@modelcontextprotocol/sdk/client/stdio.js';
+import '../client-DvUatElp.js';
+import 'node:child_process';
+import 'node:stream';
+import '@modelcontextprotocol/sdk/client/auth.js';
 import '@modelcontextprotocol/sdk/client/streamableHttp.js';
-import '../types-DhQfwiZn.js';
-import '../dynamic-tools-i9woysFa.js';
-import '../types-p55Jc-sr.js';
-import '../types-DT3nEemY.js';
+import '@modelcontextprotocol/sdk/shared/transport.js';
+import '../types-RT3cuyRk.js';
+import '../dynamic-tools-AEBOTgu1.js';
+import '../types-Cr4uiYo5.js';
+import '../model-call-options-CZkSw_xN.js';
+import '../types-C3gv9EX6.js';
 
-/** Minimal interface for anything that can run as a pipeline stage. */
-interface PipelineOp<Input = unknown, Output = unknown> {
-    run(input: Input): Output | Promise<Output>;
+declare class PipelineAgentSuspensionError extends Error {
+    readonly result: AgentSuspendedResult;
+    constructor(result: AgentSuspendedResult);
 }
-interface PipelineBatchOptions {
-    /** Maximum number of inputs processed at the same time. */
-    concurrency: number;
-}
-type AwaitedOutput<Op> = Op extends PipelineOp<unknown, infer Output> ? Awaited<Output> : never;
-type ParallelOutput<Branches extends Record<string, PipelineOp<unknown, unknown>>> = {
-    [Key in keyof Branches]: AwaitedOutput<Branches[Key]>;
-};
+
 type PipelineMetadata = {
     id?: string | undefined;
     name?: string | undefined;
@@ -45,14 +41,23 @@ type PipelineOptions<Input, Parsed = Input> = {
     metadata?: JsonObject | undefined;
 };
 type PipelineStageMetadata = {
-    id?: string | undefined;
+    id: string;
     name?: string | undefined;
     description?: string | undefined;
     metadata?: JsonObject | undefined;
 };
+type PipelineStageContext<Input> = {
+    input: Input;
+    runId: string;
+    pipelineId: string;
+    runMetadata?: JsonObject | undefined;
+    abortSignal?: AbortSignal | undefined;
+};
 type PipelineStageKind = "input" | "step" | "pipeline" | "parallel" | "branch" | "agent" | "extractor" | "output";
+type PipelineNodePath = readonly string[];
 type PipelineGraphNode = {
     id: string;
+    path: PipelineNodePath;
     kind: PipelineStageKind;
     label: string;
     description?: string | undefined;
@@ -64,8 +69,8 @@ type PipelineGraphNode = {
 };
 type PipelineGraphEdge = {
     id: string;
-    source: string;
-    target: string;
+    source: PipelineNodePath;
+    target: PipelineNodePath;
     label?: string | undefined;
 };
 type PipelineGraph = PipelineMetadata & {
@@ -73,28 +78,80 @@ type PipelineGraph = PipelineMetadata & {
     nodes: PipelineGraphNode[];
     edges: PipelineGraphEdge[];
 };
-type PipelineRunEvent = {
-    type: "stage_started";
+type PipelineRunEventBase = {
+    runId: string;
+    pipelineId: string;
+    path: PipelineNodePath;
     node: PipelineGraphNode;
-} | {
+};
+type PipelineRunEvent = (PipelineRunEventBase & {
+    type: "stage_started";
+}) | (PipelineRunEventBase & {
     type: "stage_completed";
-    node: PipelineGraphNode;
     durationMs: number;
-} | {
+}) | (PipelineRunEventBase & {
     type: "stage_failed";
-    node: PipelineGraphNode;
     durationMs: number;
     error: unknown;
-};
+});
 type PipelineRunObserver = {
     onEvent(event: PipelineRunEvent): void | Promise<void>;
 };
-type PipelineRunOptions = {
+type PipelineRunOptions<Input> = {
+    input: Input;
+    runId?: string | undefined;
+    metadata?: JsonObject | undefined;
+    abortSignal?: AbortSignal | undefined;
+    observer?: PipelineRunObserver | undefined;
+    failOnObserverError?: boolean | undefined;
+};
+type PipelineRunResult<Output> = {
+    runId: string;
+    output: Awaited<Output>;
+};
+type PipelineBatchOptions<Input> = {
+    inputs: Iterable<Input>;
+    concurrency: number;
+    metadata?: JsonObject | undefined;
+    abortSignal?: AbortSignal | undefined;
     observer?: PipelineRunObserver | undefined;
+    failOnObserverError?: boolean | undefined;
+};
+type PipelineBatchItem<Output> = {
+    status: "completed";
+    runId: string;
+    output: Awaited<Output>;
+} | {
+    status: "failed";
+    runId: string;
+    error: unknown;
+};
+type PipelineOutput<Value> = Value extends Pipeline<infer _Input, infer Output> ? Awaited<Output> : never;
+type ParallelOutput<Branches extends Record<string, unknown>> = {
+    [Key in keyof Branches]: PipelineOutput<Branches[Key]>;
 };
 
-/** Immutable, typed pipeline that can be composed and run directly. */
-declare class Pipeline<Input, Output = Input> implements PipelineOp<Input, Awaited<Output>> {
+type RawResponseOf<Model> = Model extends CompletionModel<infer RawResponse> ? RawResponse : unknown;
+type PipelineAgentRequest<Output, Model extends CompletionModel> = AgentInput & Omit<AgentRunSettings<Output, RawResponseOf<Model>>, "abortSignal">;
+type PipelineStepOptions<Input, Output> = PipelineStageMetadata & {
+    run(context: PipelineStageContext<Input>): Output | Promise<Output>;
+};
+type PipelineComposeOptions<Input, Output> = PipelineStageMetadata & {
+    pipeline: Pipeline<Input, Output>;
+};
+type PipelineParallelOptions<Input, Branches extends Record<string, Pipeline<Input, unknown>>> = PipelineStageMetadata & {
+    branches: Branches;
+};
+type PipelineAgentOptions<Input, AgentOutput, Model extends CompletionModel> = PipelineStageMetadata & {
+    agent: Agent<AgentOutput, Model>;
+    request(context: PipelineStageContext<Input>): PipelineAgentRequest<AgentOutput, Model> | Promise<PipelineAgentRequest<AgentOutput, Model>>;
+    suspension: "reject";
+};
+type PipelineExtractOptions<Input, Extracted, Model extends CompletionModel> = PipelineStageMetadata & Omit<ExtractOptions<Extracted, Model>, "text" | "abortSignal"> & {
+    text(context: PipelineStageContext<Input>): string | Promise<string>;
+};
+/** Immutable, typed Pipeline with explicit stage and execution boundaries. */
+declare class Pipeline<Input, Output = Input> {
     readonly id: string;
     readonly name: string | undefined;
     readonly description: string | undefined;
@@ -102,24 +159,16 @@ declare class Pipeline<Input, Output = Input> implements PipelineOp<Input, Await
     private readonly executor;
     private readonly state;
     constructor(options: PipelineOptions<Input, Output>);
-    /** Add a synchronous or asynchronous transform stage. */
-    step<Next>(fn: (input: Awaited<Output>) => Next | Promise<Next>, metadata?: PipelineStageMetadata): Pipeline<Input, Awaited<Next>>;
-    /** Compose another pipeline operation after the current stage. */
-    use<Next>(op: PipelineOp<Awaited<Output>, Next>, metadata?: PipelineStageMetadata): Pipeline<Input, Awaited<Next>>;
-    /** Run named branch operations concurrently from the current value. */
-    parallel<Branches extends Record<string, PipelineOp<Awaited<Output>, unknown>>>(branches: Branches, metadata?: PipelineStageMetadata): Pipeline<Input, ParallelOutput<Branches>>;
-    /** Send the current value to an agent as text and continue with the agent output. */
-    agent(agent: Agent<CompletionModel>, metadata?: PipelineStageMetadata): Pipeline<Input, string>;
-    /** Send the current value to an extractor as text and continue with typed schema data. */
-    extract<T>(extractor: Extractor<T, CompletionModel>, metadata?: PipelineStageMetadata): Pipeline<Input, T>;
-    /** Run one input through the pipeline and return the final stage output. */
-    run(input: Input, options?: PipelineRunOptions): Promise<Awaited<Output>>;
-    /** Run many inputs through the same pipeline with bounded concurrency. */
-    batch<I extends Iterable<Input>>(inputs: I, options: PipelineBatchOptions): Promise<Array<Awaited<Output>>>;
-    /** Return an isolated graph snapshot for the current pipeline stages. */
+    step<Next>(options: PipelineStepOptions<Awaited<Output>, Next>): Pipeline<Input, Awaited<Next>>;
+    compose<Next>(options: PipelineComposeOptions<Awaited<Output>, Next>): Pipeline<Input, Awaited<Next>>;
+    parallel<Branches extends Record<string, Pipeline<Awaited<Output>, unknown>>>(options: PipelineParallelOptions<Awaited<Output>, Branches>): Pipeline<Input, ParallelOutput<Branches>>;
+    agent<AgentOutput, Model extends CompletionModel>(options: PipelineAgentOptions<Awaited<Output>, AgentOutput, Model>): Pipeline<Input, AgentOutput>;
+    extract<Extracted, Model extends CompletionModel>(options: PipelineExtractOptions<Awaited<Output>, Extracted, Model>): Pipeline<Input, Extracted>;
+    run(options: PipelineRunOptions<Input>): Promise<PipelineRunResult<Output>>;
+    runBatch(options: PipelineBatchOptions<Input>): Promise<Array<PipelineBatchItem<Output>>>;
     graph(): PipelineGraph;
     private derive;
-    private runStep;
+    private execute;
 }
 
-export { Pipeline, type PipelineBatchOptions, type PipelineGraph, type PipelineGraphEdge, type PipelineGraphNode, type PipelineMetadata, type PipelineOp, type PipelineOptions, type PipelineRunEvent, type PipelineRunObserver, type PipelineRunOptions, type PipelineStageKind, type PipelineStageMetadata };
+export { type ParallelOutput, Pipeline, type PipelineAgentOptions, PipelineAgentSuspensionError, type PipelineBatchItem, type PipelineBatchOptions, type PipelineComposeOptions, type PipelineExtractOptions, type PipelineGraph, type PipelineGraphEdge, type PipelineGraphNode, type PipelineMetadata, type PipelineNodePath, type PipelineOptions, type PipelineParallelOptions, type PipelineRunEvent, type PipelineRunObserver, type PipelineRunOptions, type PipelineRunResult, type PipelineStageContext, type PipelineStageKind, type PipelineStageMetadata, type PipelineStepOptions };