@juspay/neurolink 9.54.2 → 9.54.4

package/dist/lib/utils/tokenEstimation.d.ts

@@ -11,7 +11,7 @@
  * - Mistral/Codestral: 1.26x
  * - OpenAI/GPT: 1.0x (baseline)
  */
-import type { ChatMessage } from "../types/conversation.js";
+import type { ChatMessage } from "../types/index.js";
 /** Characters per token for English text */
 export declare const CHARS_PER_TOKEN = 4;
 /** Characters per token for code */

package/dist/lib/utils/tokenUtils.d.ts

@@ -7,8 +7,7 @@
  * - analytics.ts
  * - streamAnalytics.ts
  */
-import type { TokenUsage } from "../types/analytics.js";
-import type { RawUsageObject, TokenExtractionOptions } from "../types/index.js";
+import type { TokenUsage, RawUsageObject, TokenExtractionOptions } from "../types/index.js";
 /**
  * Extract input token count from various provider formats
  * Priority: input > inputTokens > promptTokens

package/dist/lib/utils/toolCallRepair.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Schema-Driven Tool Call Repair (BZ-665)
+ *
+ * Implements `experimental_repairToolCall` for the Vercel AI SDK.
+ * When an LLM sends a wrong tool name or wrong parameter names,
+ * this module attempts deterministic, schema-driven repair:
+ *
+ *  1. Tool name: case-insensitive → substring → Levenshtein
+ *  2. Param names: compare against JSON schema properties dynamically
+ *  3. Type coercion: string→number, JSON string→object/array per schema
+ *
+ * Zero static alias maps. The tool's JSON schema is the only source of truth.
+ *
+ * @module utils/toolCallRepair
+ */
+import type { ToolCallRepairFunction, ToolSet } from "ai";
+/**
+ * Create an `experimental_repairToolCall` handler for streamText/generateText.
+ * Fully dynamic — reads the tool schema at repair time, no configuration needed.
+ */
+export declare function createToolCallRepair(): ToolCallRepairFunction<ToolSet>;

package/dist/lib/utils/toolCallRepair.js

@@ -0,0 +1,298 @@
+/**
+ * Schema-Driven Tool Call Repair (BZ-665)
+ *
+ * Implements `experimental_repairToolCall` for the Vercel AI SDK.
+ * When an LLM sends a wrong tool name or wrong parameter names,
+ * this module attempts deterministic, schema-driven repair:
+ *
+ *  1. Tool name: case-insensitive → substring → Levenshtein
+ *  2. Param names: compare against JSON schema properties dynamically
+ *  3. Type coercion: string→number, JSON string→object/array per schema
+ *
+ * Zero static alias maps. The tool's JSON schema is the only source of truth.
+ *
+ * @module utils/toolCallRepair
+ */
+import { logger } from "./logger.js";
+/**
+ * Create an `experimental_repairToolCall` handler for streamText/generateText.
+ * Fully dynamic — reads the tool schema at repair time, no configuration needed.
+ */
+export function createToolCallRepair() {
+    return async ({ toolCall, tools, inputSchema, error }) => {
+        // Import error classes lazily to avoid circular deps at module level
+        const { NoSuchToolError: NoSuchTool, InvalidToolInputError: InvalidInput } = await import("ai");
+        if (NoSuchTool.isInstance(error)) {
+            return repairToolName(toolCall, Object.keys(tools));
+        }
+        if (InvalidInput.isInstance(error)) {
+            try {
+                const schema = await inputSchema({ toolName: toolCall.toolName });
+                return repairToolInput(toolCall, schema);
+            }
+            catch {
+                // inputSchema() failed — can't repair without schema
+                return null;
+            }
+        }
+        return null;
+    };
+}
+// ─── Tool Name Repair ──────────────────────────────────────────────
+/**
+ * Attempt to match a wrong tool name against available tool names.
+ * Strategies (in order): case-insensitive exact → substring → Levenshtein.
+ */
+function repairToolName(toolCall, availableTools) {
+    const called = toolCall.toolName;
+    // Guard: empty or whitespace-only tool name cannot be meaningfully repaired
+    if (!called || called.trim().length === 0) {
+        return null;
+    }
+    // 1. Case-insensitive exact match
+    const ciMatch = availableTools.find((t) => t.toLowerCase() === called.toLowerCase());
+    if (ciMatch) {
+        logger.debug(`[ToolCallRepair] Name repair (case): "${called}" → "${ciMatch}"`);
+        return { ...toolCall, toolName: ciMatch };
+    }
+    // 2. Substring match: "search_file" is substring of "search_files" or vice versa.
+    // Only accept when exactly one tool matches to avoid ambiguous repairs.
+    const calledLower = called.toLowerCase();
+    const subCandidates = availableTools.filter((t) => {
+        const tLower = t.toLowerCase();
+        return tLower.includes(calledLower) || calledLower.includes(tLower);
+    });
+    if (subCandidates.length === 1) {
+        logger.debug(`[ToolCallRepair] Name repair (substring): "${called}" → "${subCandidates[0]}"`);
+        return { ...toolCall, toolName: subCandidates[0] };
+    }
+    // 3. Levenshtein distance — accept if normalized distance < 0.3
+    // Compare by normalized score (not raw edits) so length differences don't skew selection.
+    let bestMatch = null;
+    let bestNormalized = Infinity;
+    for (const t of availableTools) {
+        const dist = levenshtein(calledLower, t.toLowerCase());
+        const maxLen = Math.max(called.length, t.length);
+        const normalized = maxLen === 0 ? 0 : dist / maxLen;
+        if (normalized < 0.3 && normalized < bestNormalized) {
+            bestNormalized = normalized;
+            bestMatch = t;
+        }
+    }
+    if (bestMatch) {
+        logger.debug(`[ToolCallRepair] Name repair (levenshtein ${bestNormalized.toFixed(2)}): "${called}" → "${bestMatch}"`);
+        return { ...toolCall, toolName: bestMatch };
+    }
+    logger.debug(`[ToolCallRepair] Could not repair tool name "${called}". Available: [${availableTools.join(", ")}]`);
+    return null;
+}
+// ─── Tool Input Repair ─────────────────────────────────────────────
+/**
+ * Attempt to repair wrong parameter names and types using the JSON schema.
+ * Compares LLM-provided keys against schema properties dynamically.
+ *
+ * `toolCall.input` is a JSON string per LanguageModelV3ToolCall.
+ */
+function repairToolInput(toolCall, schema) {
+    let args;
+    try {
+        args = JSON.parse(toolCall.input);
+    }
+    catch {
+        return null; // input is not valid JSON — can't repair
+    }
+    if (!args || typeof args !== "object" || Array.isArray(args)) {
+        return null;
+    }
+    const schemaProps = schema.properties;
+    if (!schemaProps) {
+        return null;
+    }
+    const expectedKeys = Object.keys(schemaProps);
+    const inputObj = args;
+    const inputKeys = Object.keys(inputObj);
+    const repaired = Object.create(null);
+    let didRepair = false;
+    const dropUnknown = schema.additionalProperties === false;
+    for (const inputKey of inputKeys) {
+        // Already matches a schema property — keep as-is
+        if (expectedKeys.includes(inputKey)) {
+            repaired[inputKey] = inputObj[inputKey];
+            continue;
+        }
+        // Try to find a matching schema property
+        const mapped = findMatchingKey(inputKey, expectedKeys);
+        if (mapped) {
+            // Don't overwrite an already-populated canonical key — but still mark as repaired
+            // so the function returns the corrected object instead of null.
+            if (Object.prototype.hasOwnProperty.call(repaired, mapped)) {
+                didRepair = true;
+                continue;
+            }
+            logger.debug(`[ToolCallRepair] Param repair: "${inputKey}" → "${mapped}" (tool: ${toolCall.toolName})`);
+            repaired[mapped] = inputObj[inputKey];
+            didRepair = true;
+        }
+        else if (dropUnknown) {
+            // Schema forbids extra properties — drop unmapped keys
+            logger.debug(`[ToolCallRepair] Dropping unmapped key "${inputKey}" (additionalProperties: false, tool: ${toolCall.toolName})`);
+            didRepair = true;
+        }
+        else {
+            // Unknown key — pass through (schema allows additionalProperties)
+            repaired[inputKey] = inputObj[inputKey];
+        }
+    }
+    // Type coercion based on schema types
+    for (const key of Object.keys(repaired)) {
+        const propSchema = schemaProps[key];
+        if (!propSchema) {
+            continue;
+        }
+        const coerced = coerceType(repaired[key], propSchema);
+        if (coerced !== repaired[key]) {
+            logger.debug(`[ToolCallRepair] Type coercion on "${key}": ${typeof repaired[key]} → ${typeof coerced} (tool: ${toolCall.toolName})`);
+            repaired[key] = coerced;
+            didRepair = true;
+        }
+    }
+    if (didRepair) {
+        return { ...toolCall, input: JSON.stringify(repaired) };
+    }
+    return null;
+}
+/**
+ * Find a matching schema key for a mismatched input key.
+ * Strategies: case-insensitive → Levenshtein (threshold ≤2 edits).
+ */
+function findMatchingKey(inputKey, schemaKeys) {
+    const inputLower = inputKey.toLowerCase();
+    // Case-insensitive match
+    const ciMatch = schemaKeys.find((k) => k.toLowerCase() === inputLower);
+    if (ciMatch) {
+        return ciMatch;
+    }
+    // Levenshtein — threshold ≤2 edits
+    let best = null;
+    let bestDist = Infinity;
+    for (const k of schemaKeys) {
+        const dist = levenshtein(inputLower, k.toLowerCase());
+        if (dist <= 2 && dist < bestDist) {
+            bestDist = dist;
+            best = k;
+        }
+    }
+    return best;
+}
+// ─── Type Coercion ─────────────────────────────────────────────────
+/**
+ * Coerce a value to match the expected schema type.
+ * Handles: string→number, JSON string→object, JSON string→array, value→[value].
+ */
+function coerceType(value, propSchema) {
+    const expectedType = propSchema.type;
+    if (!expectedType || value === null || value === undefined) {
+        return value;
+    }
+    // String → Number (trim first, reject empty/whitespace, require finite result)
+    if (expectedType === "number" && typeof value === "string") {
+        const trimmed = value.trim();
+        if (trimmed !== "") {
+            const num = Number(trimmed);
+            if (isFinite(num)) {
+                return num;
+            }
+        }
+    }
+    // String → Integer (strict: reject "12abc", "3.7", etc.)
+    if (expectedType === "integer" && typeof value === "string") {
+        const trimmed = value.trim();
+        if (/^[+-]?\d+$/.test(trimmed)) {
+            const num = Number(trimmed);
+            if (Number.isSafeInteger(num)) {
+                return num;
+            }
+        }
+    }
+    // String → Boolean
+    if (expectedType === "boolean" && typeof value === "string") {
+        if (value.toLowerCase() === "true") {
+            return true;
+        }
+        if (value.toLowerCase() === "false") {
+            return false;
+        }
+    }
+    // JSON string → Object
+    if (expectedType === "object" && typeof value === "string") {
+        try {
+            const parsed = JSON.parse(value);
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                return parsed;
+            }
+        }
+        catch {
+            // Not valid JSON — return as-is
+        }
+    }
+    // JSON string → Array
+    if (expectedType === "array" && typeof value === "string") {
+        try {
+            const parsed = JSON.parse(value);
+            if (Array.isArray(parsed)) {
+                return parsed;
+            }
+        }
+        catch {
+            // Not valid JSON — return as-is
+        }
+    }
+    // Single non-string value → Array (wrap).
+    // Strings are excluded because they are more likely a JSON-encoded array
+    // that failed to parse above, and wrapping "foo" into ["foo"] is rarely correct.
+    if (expectedType === "array" &&
+        !Array.isArray(value) &&
+        typeof value !== "string") {
+        return [value];
+    }
+    return value;
+}
+// ─── Levenshtein Distance ──────────────────────────────────────────
+/**
+ * Compute Levenshtein edit distance between two strings.
+ * Uses the iterative matrix approach — O(m*n) time, O(min(m,n)) space.
+ */
+function levenshtein(a, b) {
+    if (a === b) {
+        return 0;
+    }
+    if (a.length === 0) {
+        return b.length;
+    }
+    if (b.length === 0) {
+        return a.length;
+    }
+    // Use shorter string as column to minimize space
+    if (a.length > b.length) {
+        [a, b] = [b, a];
+    }
+    const aLen = a.length;
+    const bLen = b.length;
+    let prev = new Array(aLen + 1);
+    let curr = new Array(aLen + 1);
+    for (let i = 0; i <= aLen; i++) {
+        prev[i] = i;
+    }
+    for (let j = 1; j <= bLen; j++) {
+        curr[0] = j;
+        for (let i = 1; i <= aLen; i++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            curr[i] = Math.min(prev[i] + 1, // deletion
+            curr[i - 1] + 1, // insertion
+            prev[i - 1] + cost);
+        }
+        [prev, curr] = [curr, prev];
+    }
+    return prev[aLen];
+}
+//# sourceMappingURL=toolCallRepair.js.map

package/dist/lib/utils/toolUtils.d.ts

@@ -3,7 +3,7 @@
  *
  * Consolidates environment variable access to avoid scattered process.env calls
  */
-import type { ToolConfig } from "../types/configTypes.js";
+import type { ToolConfig } from "../types/index.js";
 /**
  * Check if built-in tools should be disabled
  * Centralized function to replace direct process.env access

package/dist/lib/utils/transformationUtils.d.ts

@@ -2,7 +2,7 @@
  * Object Transformation Utilities
  * Centralizes repeated object transformation patterns to improve code reuse and maintainability
  */
-import type { StandardRecord, StringArray } from "../types/typeAliases.js";
+import type { StandardRecord, StringArray } from "../types/index.js";
 /**
  * Transform tool execution results from AI SDK format to NeuroLink GenerateResult format
  * Handles both single execution and array formats with robust type checking

package/dist/lib/utils/ttsProcessor.d.ts

@@ -6,7 +6,7 @@
  *
  * @module utils/ttsProcessor
  */
-import type { TTSOptions, TTSResult, TTSVoice } from "../types/ttsTypes.js";
+import type { TTSOptions, TTSResult, TTSHandler } from "../types/index.js";
 import { ErrorCategory, ErrorSeverity } from "../constants/enums.js";
 import { NeuroLinkError } from "./errorHandling.js";
 /**
@@ -34,74 +34,6 @@ export declare class TTSError extends NeuroLinkError {
         originalError?: Error;
     });
 }
-/**
- * TTS Handler interface for provider-specific implementations
- *
- * Each provider (Google AI, OpenAI, etc.) implements this interface
- * to provide TTS generation capabilities using their respective APIs.
- *
- * **Timeout Handling:**
- * Implementations MUST handle their own timeouts for the `synthesize()` method.
- * Recommended timeout: 30 seconds. Implementations should use `withTimeout()` utility
- * or provider-specific timeout mechanisms (e.g., Google Cloud client timeout).
- *
- * **Error Handling:**
- * Implementations should throw TTSError for all failures, including timeouts.
- * Use appropriate error codes from TTS_ERROR_CODES.
- *
- * @example
- * ```typescript
- * class MyTTSHandler implements TTSHandler {
- *   async synthesize(text: string, options: TTSOptions): Promise<TTSResult> {
- *     // REQUIRED: Implement timeout handling
- *     return await withTimeout(
- *       this.actualSynthesis(text, options),
- *       30000, // 30 second timeout
- *       'TTS synthesis timed out'
- *     );
- *   }
- *
- *   isConfigured(): boolean {
- *     return !!process.env.MY_TTS_API_KEY;
- *   }
- * }
- * ```
- */
-export type TTSHandler = {
-    /**
-     * Generate audio from text using provider-specific TTS API
-     *
-     * **IMPORTANT: Timeout Responsibility**
-     * Implementations MUST enforce their own timeouts (recommended: 30 seconds).
-     * Use the `withTimeout()` utility or provider-specific timeout mechanisms.
-     *
-     * @param text - Text to convert to speech (pre-validated, non-empty, within length limits)
-     * @param options - TTS configuration options (voice, format, speed, etc.)
-     * @returns Audio buffer with metadata
-     * @throws {TTSError} On synthesis failure, timeout, or configuration issues
-     */
-    synthesize(text: string, options: TTSOptions): Promise<TTSResult>;
-    /**
-     * Get available voices for the provider
-     *
-     * @param languageCode - Optional language filter (e.g., "en-US")
-     * @returns List of available voices
-     */
-    getVoices?(languageCode?: string): Promise<TTSVoice[]>;
-    /**
-     * Validate that the provider is properly configured
-     *
-     * @returns True if provider can generate TTS
-     */
-    isConfigured(): boolean;
-    /**
-     * Maximum text length supported by this provider (in bytes)
-     * Different providers have different limits
-     *
-     * @default 3000 if not specified
-     */
-    maxTextLength?: number;
-};
 /**
  * TTS processor class for orchestrating text-to-speech operations
  *

package/dist/lib/utils/ttsProcessor.js

@@ -9,8 +9,7 @@
 import { logger } from "./logger.js";
 import { ErrorCategory, ErrorSeverity } from "../constants/enums.js";
 import { NeuroLinkError } from "./errorHandling.js";
-import { SpanSerializer, SpanType, SpanStatus, } from "../observability/index.js";
-import { getMetricsAggregator } from "../observability/index.js";
+import { SpanSerializer, SpanType, SpanStatus, getMetricsAggregator, } from "../observability/index.js";
 /**
  * TTS-specific error codes
  */

package/dist/lib/workflow/LAYER-EXAMPLES.d.ts

@@ -4,7 +4,7 @@
  *
  * Demonstrates ModelGroup-based execution with sequential and parallel strategies
  */
-import type { WorkflowConfig } from "./types.js";
+import type { WorkflowConfig } from "../types/index.js";
 declare const simpleParallelWorkflow: WorkflowConfig;
 declare const fastThenPremiumWorkflow: WorkflowConfig;
 declare const fallbackChainWorkflow: WorkflowConfig;

package/dist/lib/workflow/config.d.ts

@@ -6,8 +6,7 @@
  */
 import { z } from "zod";
 import { AIProviderName } from "../constants/enums.js";
-import type { JsonValue } from "../types/common.js";
-import type { ConditioningConfig, ExecutionConfig, JudgeConfig, ModelConfig, ModelGroup, WorkflowConfig } from "./types.js";
+import type { JsonValue, ConditioningConfig, ExecutionConfig, JudgeConfig, WorkflowModelConfig, ModelGroup, WorkflowConfig } from "../types/index.js";
 export declare const MIN_SCORE = 0;
 export declare const MAX_SCORE = 100;
 export declare const MAX_REASONING_LENGTH = 200;
@@ -141,8 +140,8 @@ export declare const WorkflowConfigSchema: z.ZodObject<{
     type: z.ZodEnum<{
         custom: "custom";
         chain: "chain";
-        ensemble: "ensemble";
         adaptive: "adaptive";
+        ensemble: "ensemble";
     }>;
     models: z.ZodArray<z.ZodObject<{
         provider: z.ZodType<AIProviderName, unknown, z.core.$ZodTypeInternals<AIProviderName, unknown>>;
@@ -305,7 +304,7 @@ export declare function usesModelGroups(config: WorkflowConfig): boolean;
  * @param config - Workflow configuration
  * @returns Array of all model configs
  */
-export declare function getAllModels(config: WorkflowConfig): ModelConfig[];
+export declare function getAllModels(config: WorkflowConfig): WorkflowModelConfig[];
 /**
  * Get model groups (converts flat models to single group if needed)
  * @param config - Workflow configuration
@@ -334,7 +333,7 @@ export declare function mergeWithDefaults(config: WorkflowConfig): WorkflowConfi
 /**
  * Validation result for workflow configuration
  */
-export type WorkflowConfigValidationResult = {
+type WorkflowConfigValidationResult = {
     success: boolean;
     data?: WorkflowConfig;
     error?: z.ZodError;
@@ -354,9 +353,9 @@ export declare function createWorkflowConfig(partial: Partial<WorkflowConfig> &
 /**
  * Validation result for model configuration
  */
-export type ModelConfigValidationResult = {
+type ModelConfigValidationResult = {
     success: boolean;
-    data?: ModelConfig;
+    data?: WorkflowModelConfig;
     error?: z.ZodError;
 };
 /**
@@ -364,11 +363,11 @@ export type ModelConfigValidationResult = {
  * @param config - Partial model configuration to validate
  * @returns Validation result with parsed data or error details
  */
-export declare function validateModelConfig(config: Partial<ModelConfig>): ModelConfigValidationResult;
+export declare function validateModelConfig(config: Partial<WorkflowModelConfig>): ModelConfigValidationResult;
 /**
  * Validation result for judge configuration
  */
-export type JudgeConfigValidationResult = {
+type JudgeConfigValidationResult = {
     success: boolean;
     data?: JudgeConfig;
     error?: z.ZodError;
@@ -399,3 +398,4 @@ export declare function getAllJudges(config: WorkflowConfig): JudgeConfig[];
  * @returns Estimated cost in USD
  */
 export declare function estimateWorkflowCost(config: WorkflowConfig, estimatedTokens: number): number;
+export {};

package/dist/lib/workflow/core/ensembleExecutor.d.ts

@@ -2,8 +2,7 @@
  * workflow/core/ensembleExecutor.ts
  * Parallel execution engine for ensemble workflows
  */
-import type { EnsembleResponse, ExecutionConfig, ModelGroup } from "../types.js";
-import type { EnsembleExecutionResult, ExecuteEnsembleOptions } from "./types/index.js";
+import type { EnsembleResponse, ExecutionConfig, ModelGroup, EnsembleExecutionResult, ExecuteEnsembleOptions } from "../../types/index.js";
 /**
  * Execute ensemble of models in parallel
  * @param options - Execution options including prompt and models

package/dist/lib/workflow/core/ensembleExecutor.js

@@ -6,7 +6,7 @@ import pLimit from "p-limit";
 import { AIProviderFactory } from "../../core/factory.js";
 import { logger } from "../../utils/logger.js";
 import { SpanSerializer, SpanType, SpanStatus, getMetricsAggregator, } from "../../observability/index.js";
-import { WorkflowError } from "../types.js";
+import { WorkflowError } from "../../types/index.js";
 const functionTag = "EnsembleExecutor";
 // ============================================================================
 // EXECUTION FUNCTIONS

package/dist/lib/workflow/core/judgeScorer.d.ts

@@ -2,14 +2,13 @@
  * workflow/core/judgeScorer.ts
  * Judge-based scoring system for ensemble response evaluation
  */
-import type { EnsembleResponse, JudgeScores, MultiJudgeScores } from "../types.js";
-import type { ScoreOptions, ScoreResult } from "./types/index.js";
+import type { EnsembleResponse, JudgeScores, MultiJudgeScores, ScoreOptions, JudgeScoreResult } from "../../types/index.js";
 /**
  * Execute judge scoring on ensemble responses
  * @param options - Scoring options including judges and responses
  * @returns Score result with judge evaluation
  */
-export declare function scoreEnsemble(options: ScoreOptions): Promise<ScoreResult>;
+export declare function scoreEnsemble(options: ScoreOptions): Promise<JudgeScoreResult>;
 /**
  * Get best response from judge scores
  * @param scores - Judge scores or multi-judge scores

package/dist/lib/workflow/core/judgeScorer.js

@@ -6,7 +6,7 @@ import { AIProviderFactory } from "../../core/factory.js";
 import { logger } from "../../utils/logger.js";
 import { SpanSerializer, SpanType, SpanStatus, getMetricsAggregator, } from "../../observability/index.js";
 import { MAX_REASONING_LENGTH } from "../config.js";
-import { WorkflowError } from "../types.js";
+import { WorkflowError } from "../../types/index.js";
 const functionTag = "JudgeScorer";
 // ============================================================================
 // SCORING FUNCTIONS

package/dist/lib/workflow/core/responseConditioner.d.ts

@@ -5,8 +5,7 @@
  * Uses judge feedback and ensemble responses to synthesize an improved final response.
  * Combines strengths from multiple responses based on evaluation insights.
  */
-import type { ConditioningConfig } from "../types.js";
-import type { ConditionOptions, ConditionResult } from "./types/index.js";
+import type { ConditioningConfig, ConditionOptions, ConditionResult } from "../../types/index.js";
 /**
  * Condition response by synthesizing improved version using judge feedback
  *

package/dist/lib/workflow/core/workflowRegistry.d.ts

@@ -2,8 +2,7 @@
  * workflow/core/workflowRegistry.ts
  * Registry for managing workflow configurations
  */
-import type { WorkflowConfig } from "../types.js";
-import type { ListOptions, RegisterOptions, RegisterResult, RegistryStats, WorkflowMetadata } from "./types/index.js";
+import type { WorkflowConfig, ListOptions, RegisterOptions, RegisterResult, RegistryStats, WorkflowMetadata } from "../../types/index.js";
 /**
  * Register a new workflow
  * @param config - Workflow configuration to register

package/dist/lib/workflow/core/workflowRunner.d.ts

@@ -11,12 +11,11 @@
  *
  * @module workflow/core/workflowRunner
  */
-import type { JsonValue } from "../../types/common.js";
-import type { WorkflowConfig, WorkflowResult } from "../types.js";
+import type { RunWorkflowOptions, WorkflowConfig, WorkflowResult } from "../../types/index.js";
 /**
  * Progressive workflow response for streaming
  */
-export type WorkflowStreamChunk = {
+type WorkflowStreamChunk = {
     /**
      * Type of response chunk
      */
@@ -30,42 +29,6 @@ export type WorkflowStreamChunk = {
      */
     partialResult?: Partial<WorkflowResult>;
 };
-/**
- * Options for workflow execution
- */
-export type RunWorkflowOptions = {
-    /**
-     * The user's prompt/query to send to models
-     */
-    prompt: string;
-    /**
-     * Optional conversation history for context
-     */
-    conversationHistory?: Array<{
-        role: "user" | "assistant";
-        content: string;
-    }>;
-    /**
-     * Override default timeout (ms) for this execution
-     */
-    timeout?: number;
-    /**
-     * Override default parallelism for this execution
-     */
-    parallelism?: number;
-    /**
-     * Enable verbose logging for debugging
-     */
-    verbose?: boolean;
-    /**
-     * Optional context/metadata to pass through
-     */
-    metadata?: Record<string, JsonValue>;
-    /**
-     * Enable progressive streaming (yield preliminary response)
-     */
-    streaming?: boolean;
-};
 /**
  * Execute a complete workflow
  *
@@ -113,3 +76,4 @@ export declare function runWorkflow(config: WorkflowConfig, options: RunWorkflow
  * ```
  */
 export declare function runWorkflowWithStreaming(config: WorkflowConfig, options: RunWorkflowOptions): AsyncGenerator<WorkflowStreamChunk, void, undefined>;
+export {};