gauss-ai 4.0.0

package/dist/tracing-XA3TEWP4.js

@@ -0,0 +1,48 @@
+// src/adapters/tracing/in-memory-tracing.adapter.ts
+var InMemorySpan = class {
+  traceId;
+  spanId;
+  name;
+  attributes = /* @__PURE__ */ new Map();
+  status = "unset";
+  statusMessage;
+  ended = false;
+  constructor(name, traceId, spanId) {
+    this.name = name;
+    this.traceId = traceId;
+    this.spanId = spanId;
+  }
+  setAttribute(key, value) {
+    this.attributes.set(key, value);
+  }
+  setStatus(status, message) {
+    this.status = status;
+    this.statusMessage = message;
+  }
+  end() {
+    this.ended = true;
+  }
+};
+var InMemoryTracingAdapter = class {
+  spans = [];
+  counter = 0;
+  startSpan(name, parentSpan) {
+    const traceId = parentSpan?.traceId ?? `trace-${++this.counter}`;
+    const spanId = `span-${++this.counter}`;
+    const span = new InMemorySpan(name, traceId, spanId);
+    this.spans.push(span);
+    return span;
+  }
+  /** Get all recorded spans */
+  getSpans() {
+    return this.spans;
+  }
+  /** Clear all recorded spans */
+  clear() {
+    this.spans.length = 0;
+  }
+};
+export {
+  InMemoryTracingAdapter
+};
+//# sourceMappingURL=tracing-XA3TEWP4.js.map

package/dist/tracing-XA3TEWP4.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/adapters/tracing/in-memory-tracing.adapter.ts"],"sourcesContent":["// =============================================================================\n// InMemoryTracingAdapter — In-memory implementation of TracingPort for testing\n// =============================================================================\n\nimport type { TracingPort, Span } from \"../../ports/tracing.port.js\";\n\nclass InMemorySpan implements Span {\n  readonly traceId: string;\n  readonly spanId: string;\n  readonly name: string;\n  readonly attributes = new Map<string, string | number | boolean>();\n  status: \"ok\" | \"error\" | \"unset\" = \"unset\";\n  statusMessage?: string;\n  ended = false;\n\n  constructor(name: string, traceId: string, spanId: string) {\n    this.name = name;\n    this.traceId = traceId;\n    this.spanId = spanId;\n  }\n\n  setAttribute(key: string, value: string | number | boolean): void {\n    this.attributes.set(key, value);\n  }\n\n  setStatus(status: \"ok\" | \"error\", message?: string): void {\n    this.status = status;\n    this.statusMessage = message;\n  }\n\n  end(): void {\n    this.ended = true;\n  }\n}\n\nexport class InMemoryTracingAdapter implements TracingPort {\n  private readonly spans: InMemorySpan[] = [];\n  private counter = 0;\n\n  startSpan(name: string, parentSpan?: Span): InMemorySpan {\n    const traceId = parentSpan?.traceId ?? `trace-${++this.counter}`;\n    const spanId = `span-${++this.counter}`;\n    const span = new InMemorySpan(name, traceId, spanId);\n    this.spans.push(span);\n    return span;\n  }\n\n  /** Get all recorded spans */\n  getSpans(): readonly InMemorySpan[] {\n    return this.spans;\n  }\n\n  /** Clear all recorded spans */\n  clear(): void {\n    this.spans.length = 0;\n  }\n}\n"],"mappings":";AAMA,IAAM,eAAN,MAAmC;AAAA,EACxB;AAAA,EACA;AAAA,EACA;AAAA,EACA,aAAa,oBAAI,IAAuC;AAAA,EACjE,SAAmC;AAAA,EACnC;AAAA,EACA,QAAQ;AAAA,EAER,YAAY,MAAc,SAAiB,QAAgB;AACzD,SAAK,OAAO;AACZ,SAAK,UAAU;AACf,SAAK,SAAS;AAAA,EAChB;AAAA,EAEA,aAAa,KAAa,OAAwC;AAChE,SAAK,WAAW,IAAI,KAAK,KAAK;AAAA,EAChC;AAAA,EAEA,UAAU,QAAwB,SAAwB;AACxD,SAAK,SAAS;AACd,SAAK,gBAAgB;AAAA,EACvB;AAAA,EAEA,MAAY;AACV,SAAK,QAAQ;AAAA,EACf;AACF;AAEO,IAAM,yBAAN,MAAoD;AAAA,EACxC,QAAwB,CAAC;AAAA,EAClC,UAAU;AAAA,EAElB,UAAU,MAAc,YAAiC;AACvD,UAAM,UAAU,YAAY,WAAW,SAAS,EAAE,KAAK,OAAO;AAC9D,UAAM,SAAS,QAAQ,EAAE,KAAK,OAAO;AACrC,UAAM,OAAO,IAAI,aAAa,MAAM,SAAS,MAAM;AACnD,SAAK,MAAM,KAAK,IAAI;AACpB,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,WAAoC;AAClC,WAAO,KAAK;AAAA,EACd;AAAA;AAAA,EAGA,QAAc;AACZ,SAAK,MAAM,SAAS;AAAA,EACtB;AACF;","names":[]}

package/dist/types-CVsP7gFI.d.cts

@@ -0,0 +1,235 @@
+import { ZodType } from 'zod';
+
+interface TextPart {
+    type: "text";
+    text: string;
+}
+interface ToolCallPart {
+    type: "tool-call";
+    toolCallType: "function";
+    toolCallId: string;
+    toolName: string;
+    args: string;
+}
+interface ToolResultPart {
+    type: "tool-result";
+    toolCallId: string;
+    toolName: string;
+    result: unknown;
+    isError?: boolean;
+}
+type ContentPart = TextPart | ToolCallPart | ToolResultPart;
+interface SystemMessage {
+    role: "system";
+    content: string;
+}
+interface UserMessage {
+    role: "user";
+    content: string | ContentPart[];
+}
+interface AssistantMessage {
+    role: "assistant";
+    content: string | ContentPart[];
+}
+interface ToolMessage {
+    role: "tool";
+    content: ToolResultPart[];
+}
+type CoreMessage = SystemMessage | UserMessage | AssistantMessage | ToolMessage;
+interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens?: number;
+}
+interface ToolCall {
+    toolCallType: "function";
+    toolCallId: string;
+    toolName: string;
+    args: string;
+}
+interface ToolResult {
+    toolCallId: string;
+    toolName: string;
+    result: unknown;
+    isError?: boolean;
+}
+interface LanguageModelGenerateOptions {
+    inputFormat: "prompt" | "messages";
+    mode: {
+        type: "regular";
+        tools?: LanguageModelTool[];
+        toolChoice?: ToolChoice;
+    } | {
+        type: "object-json";
+        schema?: unknown;
+    } | {
+        type: "object-tool";
+        tool: LanguageModelTool;
+    };
+    prompt: CoreMessage[];
+    abortSignal?: AbortSignal;
+    headers?: Record<string, string>;
+    providerMetadata?: Record<string, unknown>;
+}
+interface LanguageModelTool {
+    type: "function";
+    name: string;
+    description?: string;
+    parameters: Record<string, unknown>;
+}
+type ToolChoice = {
+    type: "auto";
+} | {
+    type: "none";
+} | {
+    type: "required";
+} | {
+    type: "tool";
+    toolName: string;
+};
+interface LanguageModelGenerateResult {
+    text?: string;
+    toolCalls?: ToolCall[];
+    finishReason: FinishReason;
+    usage: TokenUsage;
+    rawCall: {
+        rawPrompt: unknown;
+        rawSettings: Record<string, unknown>;
+    };
+    rawResponse?: {
+        headers?: Record<string, string>;
+    };
+    warnings?: unknown[];
+    request?: {
+        body: string;
+    };
+    response?: {
+        id: string;
+        timestamp: Date;
+        modelId: string;
+    };
+    providerMetadata?: Record<string, unknown>;
+    sources?: unknown[];
+    reasoning?: unknown;
+}
+type FinishReason = "stop" | "tool-calls" | "length" | "content-filter" | "error" | "other";
+interface TextDeltaPart {
+    type: "text-delta";
+    textDelta: string;
+}
+interface ToolCallStreamPart {
+    type: "tool-call";
+    toolCallType: "function";
+    toolCallId: string;
+    toolName: string;
+    args: string;
+}
+interface ToolCallDeltaPart {
+    type: "tool-call-delta";
+    toolCallType: "function";
+    toolCallId: string;
+    toolName: string;
+    argsTextDelta: string;
+}
+interface FinishPart {
+    type: "finish";
+    finishReason: FinishReason;
+    usage: TokenUsage;
+}
+type StreamPart = TextDeltaPart | ToolCallStreamPart | ToolCallDeltaPart | FinishPart;
+interface LanguageModelStreamResult {
+    stream: ReadableStream<StreamPart>;
+    rawCall: {
+        rawPrompt: unknown;
+        rawSettings: Record<string, unknown>;
+    };
+    rawResponse?: {
+        headers?: Record<string, string>;
+    };
+    warnings?: unknown[];
+    request?: {
+        body: string;
+    };
+}
+/**
+ * Language model interface — the core provider abstraction.
+ * Implementations: MockProvider (testing), GaussProvider (Rust NAPI), or any custom provider.
+ */
+interface LanguageModel {
+    readonly specificationVersion: string;
+    readonly provider: string;
+    readonly modelId: string;
+    readonly defaultObjectGenerationMode?: string;
+    doGenerate(options: LanguageModelGenerateOptions): Promise<LanguageModelGenerateResult>;
+    doStream(options: LanguageModelGenerateOptions): Promise<LanguageModelStreamResult>;
+}
+interface ToolDefinition<PARAMS = unknown, RESULT = unknown> {
+    type: "function";
+    description?: string;
+    parameters: ZodType<PARAMS>;
+    execute?: (args: PARAMS, options?: ToolExecuteOptions) => Promise<RESULT>;
+}
+interface ToolExecuteOptions {
+    abortSignal?: AbortSignal;
+    toolCallId?: string;
+    messages?: Array<{
+        role: string;
+        content: string;
+    }>;
+}
+type Tool<PARAMS = unknown, RESULT = unknown> = ToolDefinition<PARAMS, RESULT>;
+type ToolSet = Record<string, Tool<any, any>>;
+interface StepResult<TOOLS extends ToolSet = ToolSet> {
+    text: string;
+    toolCalls: Array<{
+        toolCallType: "function";
+        toolCallId: string;
+        toolName: string;
+        args: unknown;
+    }>;
+    toolResults: ToolResult[];
+    finishReason: FinishReason;
+    usage: TokenUsage;
+    warnings?: unknown[];
+    response?: {
+        id: string;
+        timestamp: Date;
+        modelId: string;
+    };
+}
+interface GenerateTextResult<TOOLS extends ToolSet = ToolSet, OUTPUT = never> {
+    text: string;
+    toolCalls: Array<{
+        toolCallType: "function";
+        toolCallId: string;
+        toolName: string;
+        args: unknown;
+    }>;
+    toolResults: ToolResult[];
+    finishReason: FinishReason;
+    usage: TokenUsage;
+    steps: StepResult<TOOLS>[];
+    warnings?: unknown[];
+    response?: {
+        id: string;
+        timestamp: Date;
+        modelId: string;
+    };
+}
+interface StreamTextResult<TOOLS extends ToolSet = ToolSet, OUTPUT = never> {
+    textStream: ReadableStream<string>;
+    fullStream: ReadableStream<StreamPart>;
+    text: Promise<string>;
+    toolCalls: Promise<Array<{
+        toolCallType: "function";
+        toolCallId: string;
+        toolName: string;
+        args: unknown;
+    }>>;
+    toolResults: Promise<ToolResult[]>;
+    finishReason: Promise<FinishReason>;
+    usage: Promise<TokenUsage>;
+    steps: Promise<StepResult<TOOLS>[]>;
+}
+
+export type { CoreMessage as C, FinishReason as F, GenerateTextResult as G, LanguageModel as L, StepResult as S, Tool as T, ToolExecuteOptions as a, ToolSet as b, ToolChoice as c, TokenUsage as d, StreamTextResult as e, ToolResult as f };

package/dist/types-CVsP7gFI.d.ts

@@ -0,0 +1,235 @@
+import { ZodType } from 'zod';
+
+interface TextPart {
+    type: "text";
+    text: string;
+}
+interface ToolCallPart {
+    type: "tool-call";
+    toolCallType: "function";
+    toolCallId: string;
+    toolName: string;
+    args: string;
+}
+interface ToolResultPart {
+    type: "tool-result";
+    toolCallId: string;
+    toolName: string;
+    result: unknown;
+    isError?: boolean;
+}
+type ContentPart = TextPart | ToolCallPart | ToolResultPart;
+interface SystemMessage {
+    role: "system";
+    content: string;
+}
+interface UserMessage {
+    role: "user";
+    content: string | ContentPart[];
+}
+interface AssistantMessage {
+    role: "assistant";
+    content: string | ContentPart[];
+}
+interface ToolMessage {
+    role: "tool";
+    content: ToolResultPart[];
+}
+type CoreMessage = SystemMessage | UserMessage | AssistantMessage | ToolMessage;
+interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens?: number;
+}
+interface ToolCall {
+    toolCallType: "function";
+    toolCallId: string;
+    toolName: string;
+    args: string;
+}
+interface ToolResult {
+    toolCallId: string;
+    toolName: string;
+    result: unknown;
+    isError?: boolean;
+}
+interface LanguageModelGenerateOptions {
+    inputFormat: "prompt" | "messages";
+    mode: {
+        type: "regular";
+        tools?: LanguageModelTool[];
+        toolChoice?: ToolChoice;
+    } | {
+        type: "object-json";
+        schema?: unknown;
+    } | {
+        type: "object-tool";
+        tool: LanguageModelTool;
+    };
+    prompt: CoreMessage[];
+    abortSignal?: AbortSignal;
+    headers?: Record<string, string>;
+    providerMetadata?: Record<string, unknown>;
+}
+interface LanguageModelTool {
+    type: "function";
+    name: string;
+    description?: string;
+    parameters: Record<string, unknown>;
+}
+type ToolChoice = {
+    type: "auto";
+} | {
+    type: "none";
+} | {
+    type: "required";
+} | {
+    type: "tool";
+    toolName: string;
+};
+interface LanguageModelGenerateResult {
+    text?: string;
+    toolCalls?: ToolCall[];
+    finishReason: FinishReason;
+    usage: TokenUsage;
+    rawCall: {
+        rawPrompt: unknown;
+        rawSettings: Record<string, unknown>;
+    };
+    rawResponse?: {
+        headers?: Record<string, string>;
+    };
+    warnings?: unknown[];
+    request?: {
+        body: string;
+    };
+    response?: {
+        id: string;
+        timestamp: Date;
+        modelId: string;
+    };
+    providerMetadata?: Record<string, unknown>;
+    sources?: unknown[];
+    reasoning?: unknown;
+}
+type FinishReason = "stop" | "tool-calls" | "length" | "content-filter" | "error" | "other";
+interface TextDeltaPart {
+    type: "text-delta";
+    textDelta: string;
+}
+interface ToolCallStreamPart {
+    type: "tool-call";
+    toolCallType: "function";
+    toolCallId: string;
+    toolName: string;
+    args: string;
+}
+interface ToolCallDeltaPart {
+    type: "tool-call-delta";
+    toolCallType: "function";
+    toolCallId: string;
+    toolName: string;
+    argsTextDelta: string;
+}
+interface FinishPart {
+    type: "finish";
+    finishReason: FinishReason;
+    usage: TokenUsage;
+}
+type StreamPart = TextDeltaPart | ToolCallStreamPart | ToolCallDeltaPart | FinishPart;
+interface LanguageModelStreamResult {
+    stream: ReadableStream<StreamPart>;
+    rawCall: {
+        rawPrompt: unknown;
+        rawSettings: Record<string, unknown>;
+    };
+    rawResponse?: {
+        headers?: Record<string, string>;
+    };
+    warnings?: unknown[];
+    request?: {
+        body: string;
+    };
+}
+/**
+ * Language model interface — the core provider abstraction.
+ * Implementations: MockProvider (testing), GaussProvider (Rust NAPI), or any custom provider.
+ */
+interface LanguageModel {
+    readonly specificationVersion: string;
+    readonly provider: string;
+    readonly modelId: string;
+    readonly defaultObjectGenerationMode?: string;
+    doGenerate(options: LanguageModelGenerateOptions): Promise<LanguageModelGenerateResult>;
+    doStream(options: LanguageModelGenerateOptions): Promise<LanguageModelStreamResult>;
+}
+interface ToolDefinition<PARAMS = unknown, RESULT = unknown> {
+    type: "function";
+    description?: string;
+    parameters: ZodType<PARAMS>;
+    execute?: (args: PARAMS, options?: ToolExecuteOptions) => Promise<RESULT>;
+}
+interface ToolExecuteOptions {
+    abortSignal?: AbortSignal;
+    toolCallId?: string;
+    messages?: Array<{
+        role: string;
+        content: string;
+    }>;
+}
+type Tool<PARAMS = unknown, RESULT = unknown> = ToolDefinition<PARAMS, RESULT>;
+type ToolSet = Record<string, Tool<any, any>>;
+interface StepResult<TOOLS extends ToolSet = ToolSet> {
+    text: string;
+    toolCalls: Array<{
+        toolCallType: "function";
+        toolCallId: string;
+        toolName: string;
+        args: unknown;
+    }>;
+    toolResults: ToolResult[];
+    finishReason: FinishReason;
+    usage: TokenUsage;
+    warnings?: unknown[];
+    response?: {
+        id: string;
+        timestamp: Date;
+        modelId: string;
+    };
+}
+interface GenerateTextResult<TOOLS extends ToolSet = ToolSet, OUTPUT = never> {
+    text: string;
+    toolCalls: Array<{
+        toolCallType: "function";
+        toolCallId: string;
+        toolName: string;
+        args: unknown;
+    }>;
+    toolResults: ToolResult[];
+    finishReason: FinishReason;
+    usage: TokenUsage;
+    steps: StepResult<TOOLS>[];
+    warnings?: unknown[];
+    response?: {
+        id: string;
+        timestamp: Date;
+        modelId: string;
+    };
+}
+interface StreamTextResult<TOOLS extends ToolSet = ToolSet, OUTPUT = never> {
+    textStream: ReadableStream<string>;
+    fullStream: ReadableStream<StreamPart>;
+    text: Promise<string>;
+    toolCalls: Promise<Array<{
+        toolCallType: "function";
+        toolCallId: string;
+        toolName: string;
+        args: unknown;
+    }>>;
+    toolResults: Promise<ToolResult[]>;
+    finishReason: Promise<FinishReason>;
+    usage: Promise<TokenUsage>;
+    steps: Promise<StepResult<TOOLS>[]>;
+}
+
+export type { CoreMessage as C, FinishReason as F, GenerateTextResult as G, LanguageModel as L, StepResult as S, Tool as T, ToolExecuteOptions as a, ToolSet as b, ToolChoice as c, TokenUsage as d, StreamTextResult as e, ToolResult as f };

package/dist/virtual-fs.adapter-BBLS-3AY.d.ts

@@ -0,0 +1,26 @@
+import { F as FilesystemPort, a as FilesystemZone, L as ListOptions, b as FileEntry, c as FileStat, S as SearchOptions, d as SearchResult } from './token-counter.port-CRgxZZGe.js';
+
+type DiskSyncFn = (filePath: string, content: string) => Promise<void>;
+interface VirtualFsOptions {
+    basePath?: string;
+    onSync?: DiskSyncFn;
+}
+declare class VirtualFilesystem implements FilesystemPort {
+    private readonly zones;
+    private readonly basePath;
+    private readonly onSync?;
+    constructor(options?: VirtualFsOptions);
+    read(path: string, zone?: FilesystemZone): Promise<string>;
+    write(path: string, content: string, zone?: FilesystemZone): Promise<void>;
+    exists(path: string, zone?: FilesystemZone): Promise<boolean>;
+    delete(path: string, zone?: FilesystemZone): Promise<void>;
+    list(path: string, options?: ListOptions, zone?: FilesystemZone): Promise<FileEntry[]>;
+    stat(path: string, zone?: FilesystemZone): Promise<FileStat>;
+    glob(pattern: string, zone?: FilesystemZone): Promise<string[]>;
+    search(pattern: string, options?: SearchOptions, zone?: FilesystemZone): Promise<SearchResult[]>;
+    syncToPersistent(): Promise<void>;
+    clearTransient(): Promise<void>;
+    private ensureParentDirs;
+}
+
+export { type DiskSyncFn as D, VirtualFilesystem as V };

package/dist/virtual-fs.adapter-nb0CTYOj.d.cts

@@ -0,0 +1,26 @@
+import { F as FilesystemPort, a as FilesystemZone, L as ListOptions, b as FileEntry, c as FileStat, S as SearchOptions, d as SearchResult } from './token-counter.port-D7BHMCRR.cjs';
+
+type DiskSyncFn = (filePath: string, content: string) => Promise<void>;
+interface VirtualFsOptions {
+    basePath?: string;
+    onSync?: DiskSyncFn;
+}
+declare class VirtualFilesystem implements FilesystemPort {
+    private readonly zones;
+    private readonly basePath;
+    private readonly onSync?;
+    constructor(options?: VirtualFsOptions);
+    read(path: string, zone?: FilesystemZone): Promise<string>;
+    write(path: string, content: string, zone?: FilesystemZone): Promise<void>;
+    exists(path: string, zone?: FilesystemZone): Promise<boolean>;
+    delete(path: string, zone?: FilesystemZone): Promise<void>;
+    list(path: string, options?: ListOptions, zone?: FilesystemZone): Promise<FileEntry[]>;
+    stat(path: string, zone?: FilesystemZone): Promise<FileStat>;
+    glob(pattern: string, zone?: FilesystemZone): Promise<string[]>;
+    search(pattern: string, options?: SearchOptions, zone?: FilesystemZone): Promise<SearchResult[]>;
+    syncToPersistent(): Promise<void>;
+    clearTransient(): Promise<void>;
+    private ensureParentDirs;
+}
+
+export { type DiskSyncFn as D, VirtualFilesystem as V };

package/dist/workflow/index.cjs

@@ -0,0 +1,9 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkINLNGRXMcjs = require('../chunk-INLNGRXM.cjs');
+
+
+
+exports.WorkflowBuilder = _chunkINLNGRXMcjs.WorkflowBuilder; exports.defineWorkflow = _chunkINLNGRXMcjs.defineWorkflow;
+//# sourceMappingURL=index.cjs.map

package/dist/workflow/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/giulioleone/Sviluppo/gauss/gauss-flow/dist/workflow/index.cjs"],"names":[],"mappings":"AAAA;AACE;AACA;AACF,yDAA8B;AAC9B;AACE;AACA;AACF,uHAAC","file":"/Users/giulioleone/Sviluppo/gauss/gauss-flow/dist/workflow/index.cjs"}

package/dist/workflow/index.d.cts

@@ -0,0 +1,62 @@
+import { W as WorkflowContext, h as WorkflowStep, R as RetryConfig, a as WorkflowDefinition } from '../workflow.port-BaCttxrw.cjs';
+export { e as AnyStep, V as ValidationResult, f as WorkflowEvent, c as WorkflowEventListener, b as WorkflowPort, d as WorkflowResult } from '../workflow.port-BaCttxrw.cjs';
+
+type ConditionFn = (ctx: WorkflowContext) => boolean;
+type RollbackFn = (ctx: WorkflowContext) => Promise<void>;
+type PromptFn = (ctx: WorkflowContext) => string;
+interface ConditionalOpts {
+    condition: ConditionFn;
+    ifTrue: WorkflowStep;
+    ifFalse?: WorkflowStep;
+}
+interface LoopOpts {
+    body: WorkflowStep;
+    condition: ConditionFn;
+    maxIterations?: number;
+}
+interface ForeachOpts {
+    iterable: string;
+    step: WorkflowStep;
+    itemKey?: string;
+    indexKey?: string;
+    aggregateOutputKey?: string;
+    aggregationMode?: "array" | "concat" | "merge";
+    maxConcurrency?: number;
+    maxIterations?: number;
+}
+interface MapOpts {
+    input: string;
+    transform: WorkflowStep;
+    outputKey: string;
+    itemKey?: string;
+    indexKey?: string;
+    filter?: (item: unknown, index: number, ctx: WorkflowContext) => boolean;
+    maxConcurrency?: number;
+}
+declare class WorkflowBuilder {
+    private readonly id;
+    private readonly workflowName;
+    private readonly steps;
+    private timeoutMs?;
+    private initCtx?;
+    constructor(id: string, name: string);
+    step(id: string, name: string, execute: (ctx: WorkflowContext) => Promise<WorkflowContext>): this;
+    parallel(id: string, name: string, branches: WorkflowStep[], mergeStrategy?: 'all' | 'first' | 'race'): this;
+    conditional(id: string, name: string, opts: ConditionalOpts): this;
+    loop(id: string, name: string, opts: LoopOpts): this;
+    foreach(id: string, name: string, opts: ForeachOpts): this;
+    map(id: string, name: string, opts: MapOpts): this;
+    agentStep(id: string, name: string, prompt: string | PromptFn, outputKey: string): this;
+    /** Apply retry config to the last added step */
+    withRetry(config: Partial<RetryConfig>): this;
+    /** Apply rollback to the last added step */
+    withRollback(fn: RollbackFn): this;
+    /** Apply condition to the last added step */
+    withCondition(fn: ConditionFn): this;
+    withTimeout(ms: number): this;
+    withInitialContext(ctx: WorkflowContext): this;
+    build(): WorkflowDefinition;
+}
+declare function defineWorkflow(id: string, name: string): WorkflowBuilder;
+
+export { WorkflowBuilder, WorkflowContext, WorkflowDefinition, defineWorkflow };