@anvia/core 0.26.0 → 1.0.0-rc.10

package/dist/pipeline/index.d.ts

@@ -1,44 +1,59 @@
+import { t as AgentSuspendedResult, f as AgentInput, m as AgentRunSettings } from '../types-Sue2hb_L.js';
+import { A as Agent } from '../agent-DWzW9SoH.js';
+import { J as JsonObject, c as CompletionModel } from '../types-DgvozfPc.js';
+import { ExtractOptions } from '../extractor/index.js';
 import { z } from 'zod';
-import { A as Agent } from '../agent-x3YTyv5i.js';
-import { J as JsonObject, C as CompletionModel } from '../types-G12i56s2.js';
-import { Extractor } from '../extractor/index.js';
-import '../guardrails/index.js';
-import '../types-D9JpeAPF.js';
-import '../types-BrLbKnEz.js';
-import '../index-BxSbmOMr.js';
-import '../tool-Cohdv5GC.js';
-import '../middleware-Dp3d_pxi.js';
-import '../types-BCTRUGex.js';
-import '../types-O-abTIin.js';
+import '../agent/interactions/index.js';
+import '../retry-CjvSlKGW.js';
+import '../types-DhkodEft.js';
+import '../type-utils-CtHVDRn_.js';
+import '../types-DKOXVTcq.js';
+import '../tool-BpqpoRSE.js';
+import '../middleware-kcF8AusP.js';
 import '../zod-schema-C7F4clpm.js';
+import '../types-DjqRHeAi.js';
+import '../types-DC1U1XwW.js';
+import '../dynamic-tools-aIZlg5x1.js';
+import '../types-Cr4uiYo5.js';
+import '../model-call-options-CZkSw_xN.js';
+import '../types-CXNE592e.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;
     description?: string | undefined;
     metadata?: JsonObject | undefined;
 };
+type PipelineOptions<Input, Parsed = Input> = {
+    id: string;
+    inputSchema: z.ZodType<Parsed, Input>;
+    name?: string | undefined;
+    description?: string | undefined;
+    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;
@@ -50,8 +65,8 @@ type PipelineGraphNode = {
 };
 type PipelineGraphEdge = {
     id: string;
-    source: string;
-    target: string;
+    source: PipelineNodePath;
+    target: PipelineNodePath;
     label?: string | undefined;
 };
 type PipelineGraph = PipelineMetadata & {
@@ -59,74 +74,97 @@ 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 PipelineRunContext = {
+type PipelineBatchOptions<Input> = {
+    inputs: Iterable<Input>;
+    concurrency: number;
+    metadata?: JsonObject | undefined;
+    abortSignal?: AbortSignal | undefined;
     observer?: PipelineRunObserver | undefined;
+    failOnObserverError?: boolean | undefined;
 };
-type PipelineExecutor<Input, Output> = (input: Input, context: PipelineRunContext) => Output | Promise<Output>;
-type PipelineBuilderState = {
-    graph: PipelineGraph;
-    terminalNodeId: string;
-    terminalNodeIds: string[];
-    nextNodeIndex: number;
-    nextEdgeIndex: number;
+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]>;
 };
 
-/** Runnable pipeline returned by `PipelineBuilder.build()`. */
-declare class Pipeline<Input, Output> implements PipelineOp<Input, Awaited<Output>> {
-    private readonly executor;
-    private readonly pipelineGraph;
+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;
     readonly metadata: JsonObject | undefined;
-    constructor(executor: PipelineExecutor<Input, Output>, pipelineGraph?: PipelineGraph);
-    /** Run one input through the built 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>>>;
-    graph(): PipelineGraph;
-}
-
-/** Builds a typed pipeline from an original input type to an inferred output type. */
-declare class PipelineBuilder<Input, Output = Input> {
     private readonly executor;
     private readonly state;
-    constructor(schema: z.ZodType<Output, Input>);
-    constructor(schema: z.ZodType<Output, Input>, metadata: PipelineMetadata);
-    constructor(executor: (input: Input) => Output | Promise<Output>);
-    constructor(executor: PipelineExecutor<Input, Output>, state: PipelineBuilderState);
-    /** Add a synchronous or asynchronous transform stage. */
-    step<Next>(fn: (input: Awaited<Output>) => Next | Promise<Next>, metadata?: PipelineStageMetadata): PipelineBuilder<Input, Awaited<Next>>;
-    /** Compose another pipeline operation after the current stage. */
-    use<Next>(op: PipelineOp<Awaited<Output>, Next>, metadata?: PipelineStageMetadata): PipelineBuilder<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): PipelineBuilder<Input, ParallelOutput<Branches>>;
-    /** Send the current value to an agent as text and continue with the agent output. */
-    prompt(agent: Agent<CompletionModel>, metadata?: PipelineStageMetadata): PipelineBuilder<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): PipelineBuilder<Input, T>;
-    /** Finish the builder and return a runnable pipeline. */
-    build(): Pipeline<Input, Awaited<Output>>;
-    private runStep;
+    constructor(options: PipelineOptions<Input, Output>);
+    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 execute;
 }
 
-export { Pipeline, type PipelineBatchOptions, PipelineBuilder, type PipelineGraph, type PipelineGraphEdge, type PipelineGraphNode, type PipelineMetadata, type PipelineOp, 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 };