@juspay/neurolink 10.6.0 → 10.6.2

package/dist/lib/providers/sagemaker/errors.js

@@ -192,7 +192,8 @@ export function handleSageMakerError(error, endpoint) {
 /**
  * Extract request ID from AWS SDK error for debugging
  *
- * @param error - Error object that might contain request ID
+ * @param error - Error object that might contain request ID (AWS SDK errors
+ *   carry it as an untyped extra field, so the value is treated as opaque)
  * @returns Request ID if found, undefined otherwise
  */
 function extractRequestId(error) {

package/dist/lib/proxy/proxyFetch.js

@@ -509,10 +509,14 @@ async function executeProxiedFetch(input, init, proxyEnv) {
                 fetchInput = input;
             }
             const undici = await import("undici");
-            const response = await undici.fetch(fetchInput, {
+            // undici's fetch types and lib.dom's diverge on iterator helper details,
+            // so the runtime-identical response is typed as either flavor (widening
+            // assertion so control flow keeps the union) and narrowed
+            // (overlap-checked) back to the DOM flavor at the return boundary.
+            const response = (await undici.fetch(fetchInput, {
                 ...fetchInit,
                 dispatcher,
-            });
+            }));
             if (logger.shouldLog("debug")) {
                 const { parsed: responseBody, size: responseSize, type: responseType, headers: responseHeaders, } = await readResponseBody(response);
                 logger.debug("[Observability] HTTP response from LLM provider", {

package/dist/lib/rag/ChunkerFactory.js

@@ -177,7 +177,7 @@ export class ChunkerFactory extends BaseFactory {
         }, DEFAULT_CHUNKER_METADATA.latex);
         // Register semantic chunker (placeholder - uses recursive as fallback)
         this.registerChunker("semantic", async (config) => {
-            // TODO: Implement dedicated SemanticChunker with LLM support
+            // TODO(#1179): Implement dedicated SemanticChunker with LLM support
             // For now, fall back to RecursiveChunker with semantic defaults
             const { RecursiveChunker } = await import("./chunkers/RecursiveChunker.js");
             return new RecursiveChunker(config);

package/dist/lib/rag/chunking/semanticChunker.js

@@ -138,8 +138,7 @@ export class SemanticChunker {
     async getEmbeddings(segments, provider, modelName) {
         const embeddingProvider = await ProviderFactory.createProvider(provider, modelName);
         // Check if provider has embed method
-        if (typeof embeddingProvider.embed !==
-            "function") {
+        if (typeof embeddingProvider.embed !== "function") {
             throw new Error(`Provider ${provider} does not support embeddings`);
         }
         const embeddings = [];

package/dist/lib/rag/document/MDocument.js

@@ -210,8 +210,7 @@ export class MDocument {
             model: modelName,
         });
         const embeddingProvider = await ProviderFactory.createProvider(provider, modelName);
-        if (typeof embeddingProvider.embed !==
-            "function") {
+        if (typeof embeddingProvider.embed !== "function") {
             throw new Error(`Provider ${provider} does not support embeddings`);
         }
         this.state.embeddings = [];

package/dist/lib/rag/document/loaders.js

@@ -273,14 +273,27 @@ export class PDFLoader {
         return ext === ".pdf";
     }
     async loadPdfParser() {
+        // pdf-parse is an optional dependency — resolve it dynamically and
+        // validate at runtime that it exposes a callable parser (either the
+        // module itself or its default export) instead of blindly asserting.
+        let pdfParseModule;
         try {
-            // pdf-parse is an optional dependency - use dynamic import with type assertion
-            const pdfParse = (await import("pdf-parse"));
-            return pdfParse.default || pdfParse;
+            pdfParseModule = await import("pdf-parse");
         }
         catch {
             throw new Error("pdf-parse module not available");
         }
+        const candidate = (typeof pdfParseModule === "object" &&
+            pdfParseModule !== null &&
+            "default" in pdfParseModule
+            ? pdfParseModule.default
+            : undefined) || pdfParseModule;
+        if (typeof candidate !== "function") {
+            // Outside the try/catch so this message isn't swallowed by the
+            // module-not-available rethrow.
+            throw new Error("pdf-parse module does not export a parse function");
+        }
+        return candidate;
     }
     parsePageRange(range, totalPages) {
         const pages = [];

package/dist/lib/rag/pipeline/RAGPipeline.js

@@ -371,8 +371,7 @@ export class RAGPipeline {
         if (!this.embeddingProvider) {
             throw new Error("Embedding provider not initialized");
         }
-        if (typeof this.embeddingProvider
-            .embed !== "function") {
+        if (typeof this.embeddingProvider.embed !== "function") {
             throw new Error(`Provider ${this.config.embeddingModel.provider} does not support embeddings`);
         }
         return await withTimeout(this.embeddingProvider.embed(text), DEFAULT_TIMEOUT_MS, "Embedding generation timed out");

package/dist/lib/rag/retrieval/hybridSearch.js

@@ -177,8 +177,7 @@ export function createHybridSearch(options) {
         try {
             // Generate query embedding
             const embeddingProvider = await ProviderFactory.createProvider(embeddingModel?.provider, embeddingModel?.modelName);
-            if (typeof embeddingProvider
-                .embed !== "function") {
+            if (typeof embeddingProvider.embed !== "function") {
                 throw new Error(`Embedding provider does not support the embed() method. ` +
                     `Please use a provider that supports embeddings (e.g., OpenAI text-embedding-3-small, Vertex text-embedding-004).`);
             }

package/dist/lib/rag/retrieval/vectorQueryTool.js

@@ -66,8 +66,7 @@ export function createVectorQueryTool(config, vectorStore) {
                     // Generate query embedding
                     const embeddingProvider = await ProviderFactory.createProvider(embeddingModel.provider, embeddingModel.modelName);
                     // Check if provider has embed method
-                    if (typeof embeddingProvider
-                        .embed !== "function") {
+                    if (typeof embeddingProvider.embed !== "function") {
                         throw new Error(`Provider ${embeddingModel.provider} does not support embeddings`);
                     }
                     const queryEmbedding = await embeddingProvider.embed(params.query);

package/dist/lib/sdk/toolRegistration.js

@@ -250,8 +250,12 @@ export function validateTool(name, tool) {
             throw new Error(`Tool '${name}' parameters must be an object. ` +
                 `Received: ${typeof tool.parameters}`);
         }
-        // Check for common schema validation methods (Zod uses 'parse', others might use 'validate')
-        const params = tool.parameters;
+        // Check for common schema validation methods (Zod uses 'parse', others might use 'validate').
+        // Despite the declared Zod type, callers may pass custom schema objects at
+        // runtime — this function's whole purpose is to validate that; probe as
+        // `unknown` and narrow to a generic record for feature detection.
+        const paramsCandidate = tool.parameters;
+        const params = paramsCandidate;
         const hasValidationMethod = typeof params.parse === "function" ||
             typeof params.validate === "function" ||
             "_def" in params; // Zod schemas have _def property

package/dist/lib/server/middleware/cache.d.ts

@@ -83,6 +83,10 @@ export declare class LRUCache<K, V> {
      * Check if a key exists in the cache
      */
     has(key: K): boolean;
+    /**
+     * Iterate over all keys currently in the cache
+     */
+    keys(): IterableIterator<K>;
     /**
      * Delete a key from the cache
      */

package/dist/lib/server/middleware/cache.js

@@ -219,6 +219,12 @@ export class LRUCache {
     has(key) {
         return this.cache.has(key);
     }
+    /**
+     * Iterate over all keys currently in the cache
+     */
+    keys() {
+        return this.cache.keys();
+    }
     /**
      * Delete a key from the cache
      */
@@ -335,9 +341,7 @@ export class ResponseCacheStore {
         // For production, consider using a more efficient data structure
         let invalidated = 0;
         const keysToDelete = [];
-        // Get all keys (requires accessing internal cache)
-        const internalCache = this.cache.cache;
-        for (const key of internalCache.keys()) {
+        for (const key of this.cache.keys()) {
             const matches = pattern instanceof RegExp ? pattern.test(key) : key.includes(pattern);
             if (matches) {
                 keysToDelete.push(key);

package/dist/lib/server/middleware/validation.js

@@ -75,7 +75,8 @@ export function createRequestValidationMiddleware(config) {
                 const formattedError = errorFormatter(errors.map((e) => new ServerValidationError([e], ctx.requestId)));
                 const error = new ServerValidationError(errors, ctx.requestId);
                 // Attach formatted response to error
-                error.response = formattedError;
+                error.response =
+                    formattedError;
                 throw error;
             }
             return next();

package/dist/lib/server/utils/redaction.js

@@ -80,13 +80,13 @@ function redactChunkByType(chunk, redactedFields, placeholder, config) {
     const chunkType = typedChunk.type;
     switch (chunkType) {
         case "step-start":
-            return redactStepStart(typedChunk, redactedFields, placeholder);
+            return redactStepStart(chunk, redactedFields, placeholder);
         case "tool-call":
-            return redactToolCall(typedChunk, redactedFields, placeholder, config);
+            return redactToolCall(chunk, redactedFields, placeholder, config);
         case "tool-result":
-            return redactToolResult(typedChunk, redactedFields, placeholder, config);
+            return redactToolResult(chunk, redactedFields, placeholder, config);
         case "error":
-            return redactError(typedChunk, redactedFields, placeholder);
+            return redactError(chunk, redactedFields, placeholder);
         default:
             return redactGenericChunk(typedChunk, redactedFields, placeholder);
     }
@@ -99,13 +99,12 @@ function redactStepStart(chunk, redactedFields, placeholder) {
         return chunk;
     }
     const { payload, ...rest } = chunk;
-    const payloadObj = payload;
-    const redactedPayload = redactObject(payloadObj, redactedFields, placeholder, 0);
-    return {
+    const redactedPayload = redactObject(payload, redactedFields, placeholder, 0);
+    const redacted = {
         ...rest,
-        type: "step-start",
         payload: redactedPayload,
     };
+    return redacted;
 }
 /**
  * Redact tool-call chunks
@@ -114,49 +113,45 @@ function redactToolCall(chunk, redactedFields, placeholder, config) {
     // Handle chunks with payload structure
     if (hasPayload(chunk)) {
         const { payload, ...rest } = chunk;
-        const payloadObj = payload;
         // Redact tool arguments if configured
-        if (payloadObj.toolCall && typeof payloadObj.toolCall === "object") {
-            const toolCall = payloadObj.toolCall;
+        if (payload.toolCall && typeof payload.toolCall === "object") {
+            const toolCall = payload.toolCall;
             const redactArgs = config?.redactToolArgs !== false && redactedFields.has("args");
-            return {
+            const redacted = {
                 ...rest,
-                type: "tool-call",
                 payload: {
-                    ...payloadObj,
+                    ...payload,
                     toolCall: {
                         ...toolCall,
                         args: redactArgs ? placeholder : toolCall.args,
                     },
                 },
             };
+            return redacted;
         }
-        return {
+        const redacted = {
             ...rest,
-            type: "tool-call",
-            payload: redactObject(payloadObj, redactedFields, placeholder, 0),
+            payload: redactObject(payload, redactedFields, placeholder, 0),
         };
+        return redacted;
     }
     // Handle chunks with data structure (DataStreamEvent format)
     if (hasData(chunk)) {
         const { data, ...rest } = chunk;
-        const dataObj = data;
         const redactArgs = config?.redactToolArgs !== false && redactedFields.has("args");
         // Check for arguments field in data
-        if ("arguments" in dataObj && redactArgs) {
+        if ("arguments" in data && redactArgs) {
             return {
                 ...rest,
-                type: "tool-call",
                 data: {
-                    ...dataObj,
+                    ...data,
                     arguments: placeholder,
                 },
             };
         }
         return {
             ...rest,
-            type: "tool-call",
-            data: redactObject(dataObj, redactedFields, placeholder, 0),
+            data: redactObject(data, redactedFields, placeholder, 0),
         };
     }
     return chunk;
@@ -169,26 +164,23 @@ function redactToolResult(chunk, redactedFields, placeholder, config) {
     // Handle chunks with payload structure
     if (hasPayload(chunk)) {
         const { payload, ...rest } = chunk;
-        const payloadObj = payload;
-        return {
+        const redacted = {
             ...rest,
-            type: "tool-result",
             payload: {
-                ...payloadObj,
-                result: redactResult ? placeholder : payloadObj.result,
+                ...payload,
+                result: redactResult ? placeholder : payload.result,
             },
         };
+        return redacted;
     }
     // Handle chunks with data structure (DataStreamEvent format)
     if (hasData(chunk)) {
         const { data, ...rest } = chunk;
-        const dataObj = data;
         return {
             ...rest,
-            type: "tool-result",
             data: {
-                ...dataObj,
-                result: redactResult ? placeholder : dataObj.result,
+                ...data,
+                result: redactResult ? placeholder : data.result,
             },
         };
     }
@@ -202,11 +194,9 @@ function redactError(chunk, redactedFields, placeholder) {
     // Handle chunks with data structure (DataStreamEvent format)
     if (hasData(chunk)) {
         const { data, ...rest } = chunk;
-        const dataObj = data;
-        const { stack, ...dataRest } = dataObj;
+        const { stack, ...dataRest } = data;
         return {
             ...rest,
-            type: "error",
             data: {
                 ...redactObject(dataRest, redactedFields, placeholder, 0),
                 ...(isProduction ? {} : { stack }),
@@ -214,7 +204,8 @@ function redactError(chunk, redactedFields, placeholder) {
         };
     }
     // Handle direct chunk with stack
-    const { stack, ...restChunk } = chunk;
+    const chunkRecord = chunk;
+    const { stack, ...restChunk } = chunkRecord;
     const redactedRest = redactObject(restChunk, redactedFields, placeholder, 0);
     return {
         ...redactedRest,
@@ -270,9 +261,10 @@ function redactObject(obj, redactedFields, placeholder, depth) {
  * Type guard for chunks with payload
  */
 function hasPayload(chunk) {
-    return ("payload" in chunk &&
-        chunk.payload !== null &&
-        typeof chunk.payload === "object");
+    const record = chunk;
+    return ("payload" in record &&
+        record.payload !== null &&
+        typeof record.payload === "object");
 }
 /**
  * Type guard for chunks with data (DataStreamEvent format)

package/dist/lib/server/websocket/WebSocketHandler.js

@@ -334,17 +334,17 @@ export function createAgentWebSocketHandler(_neurolink) {
     // Register message routes
     router.route("generate", async (connection, payload) => {
         const { prompt, options: _options } = payload;
-        // TODO: Implement generate using neurolink
+        // TODO(#1179): Implement generate using neurolink
         return { type: "response", data: `Received: ${prompt}` };
     });
     router.route("stream", async (connection, payload) => {
         const { prompt, options: _options } = payload;
-        // TODO: Implement streaming using neurolink
+        // TODO(#1179): Implement streaming using neurolink
         return { type: "stream_start", data: { prompt } };
     });
     router.route("tool_call", async (connection, payload) => {
         const { toolName, args: _args } = payload;
-        // TODO: Implement tool call using neurolink
+        // TODO(#1179): Implement tool call using neurolink
         return { type: "tool_result", data: { toolName, result: null } };
     });
     return {

package/dist/lib/services/server/ai/observability/instrumentation.js

@@ -225,6 +225,7 @@ class ContextEnricher {
         const userId = context?.userId ?? currentConfig?.userId ?? "guest";
         const sessionId = context?.sessionId ?? currentConfig?.sessionId;
         // Get span name for operation auto-detection
+        // (sdk-trace-base's Span type includes the ReadableSpan members)
         const spanName = span.name;
         // Determine if auto-detection is enabled for this context
         const autoDetect = this.shouldAutoDetectOperationName(context);
@@ -386,9 +387,11 @@ class ContextEnricher {
      */
     onEnd(span) {
         try {
-            // Get span attributes (ReadableSpan interface)
-            const readableSpan = span;
-            const attributes = readableSpan.attributes || {};
+            // Get span attributes (sdk-trace-base's Span type includes the
+            // ReadableSpan members, so attributes/name/status are directly typed).
+            // Keep the {} fallback: this processor can be attached to an external
+            // app-owned TracerProvider whose span implementation may omit attributes.
+            const attributes = span.attributes ?? {};
             // Handle wrapper/trace-root spans: update trace name with detected operation
             // This supports host apps (like Curator) that create wrapper spans before AI calls
             // This is optional - if spanContext fails, we skip wrapper span support
@@ -437,7 +440,7 @@ class ContextEnricher {
                 const provider = attributes["gen_ai.system"] ||
                     attributes["ai.model.provider"];
                 logger.debug(`${LOG_PREFIX} GenAI span detected`, {
-                    spanName: readableSpan.name,
+                    spanName: span.name,
                     model,
                     provider,
                 });
@@ -529,7 +532,7 @@ class ContextEnricher {
                 // *returns* { isError:true } (no exception thrown), so Langfuse sees
                 // level=DEFAULT and no status message. Parse the stringified result
                 // and surface the embedded error text.
-                if (readableSpan.name === "ai.toolCall" &&
+                if (span.name === "ai.toolCall" &&
                     readableStatus?.code !== SpanStatusCode.ERROR) {
                     applyToolCallIsErrorStatus(mutableAttrs);
                 }

package/dist/lib/types/classifierRouter.d.ts

@@ -13,6 +13,7 @@
  * Type names are domain-prefixed `Classifier*` to stay globally unique across
  * `src/lib/types/` (see CLAUDE.md rule 9).
  */
+import type { ValidationSchema } from "./aliases.js";
 /** Coarse difficulty buckets the classifier maps a request into. */
 export type ClassifierDifficulty = "trivial" | "simple" | "moderate" | "hard" | "expert";
 /** Which classification strategy to run. */
@@ -166,7 +167,7 @@ export type ClassifierGenerateOptions = {
     temperature?: number;
     maxTokens?: number;
     disableTools?: boolean;
-    schema?: unknown;
+    schema?: ValidationSchema;
     timeout?: number | string;
     context?: Record<string, unknown>;
 };

package/dist/lib/types/providers.d.ts

@@ -2,6 +2,7 @@
  * Provider-specific type definitions for NeuroLink
  */
 import type { UnknownRecord, JsonValue, StreamingCapability } from "./common.js";
+import type { NeuroLink } from "../neurolink.js";
 import { AIProviderName, AnthropicModels, BedrockModels, DeepSeekModels, GoogleAIModels, LlamaCppModels, LMStudioModels, NvidiaNimModels, OpenAIModels, VertexModels } from "../constants/enums.js";
 import type { ValidationSchema } from "./aliases.js";
 import type { EnhancedGenerateResult, GenerateResult, TextGenerationOptions } from "./generate.js";
@@ -1669,8 +1670,8 @@ export type ToolWithLegacyParams = {
  * factory functions.
  */
 export type ProviderConstructor = {
-    new (modelName?: string, providerName?: string, sdk?: UnknownRecord, region?: string, credentials?: UnknownRecord): AIProvider;
-} | ((modelName?: string, providerName?: string, sdk?: UnknownRecord, region?: string, credentials?: UnknownRecord) => Promise<AIProvider>);
+    new (modelName?: string, providerName?: string, sdk?: NeuroLink, region?: string, credentials?: UnknownRecord): AIProvider;
+} | ((modelName?: string, providerName?: string, sdk?: NeuroLink, region?: string, credentials?: UnknownRecord) => Promise<AIProvider>);
 /** Provider registration entry held by ProviderFactory. */
 export type ProviderRegistration = {
     constructor: ProviderConstructor;
@@ -1779,6 +1780,25 @@ export type VertexNativePart = {
         data: string;
     };
 };
+/**
+ * Part variants that ride the native Gemini agentic tool loop in addition to
+ * the plain `VertexNativePart` content shapes: model-issued function calls
+ * replayed into history, and the function responses (plus wrap-up nudge text
+ * parts) sent back on the next user turn. Mirrors the optional
+ * `functionCall` / `functionResponse` members of the @google/genai SDK's
+ * `Part` type, so loop contents stay directly assignable to the SDK payload.
+ */
+export type VertexNativeLoopPart = VertexNativePart | {
+    functionCall: {
+        name: string;
+        args: Record<string, unknown>;
+    };
+} | {
+    functionResponse: {
+        name: string;
+        response: Record<string, unknown>;
+    };
+};
 /**
  * Subset of `GenerateOptions["input"]` consumed by the shared Gemini-native
  * multimodal-parts builder. Kept narrow so the helper doesn't depend on the

package/dist/lib/utils/pdfProcessor.js

@@ -264,6 +264,8 @@ export class PDFProcessor {
                     clearTimeout(timeoutHandle);
                 }
                 try {
+                    // Optional call: guards against a runtime pdf-parse version whose
+                    // instances lack destroy(), while the typed v2 class declares it.
                     await pdf.destroy?.();
                 }
                 catch {

package/dist/lib/utils/safeFetch.js

@@ -58,6 +58,23 @@ function buildPinnedAgent(hostname, addresses) {
         },
     });
 }
+/**
+ * Runtime-validating narrow across the undici → DOM `Response` type boundary.
+ * `readBoundedBuffer` only touches `headers.get()` and `arrayBuffer()`; the
+ * two libraries' `Response` declarations disagree on unrelated members
+ * (headers iterator shapes), so validate the members actually used instead
+ * of blindly asserting.
+ */
+function isBoundedBufferResponse(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const candidate = value;
+    return (typeof candidate.arrayBuffer === "function" &&
+        typeof candidate.headers === "object" &&
+        candidate.headers !== null &&
+        typeof candidate.headers.get === "function");
+}
 /**
  * Safely download a binary asset from an external URL.
  *
@@ -96,6 +113,9 @@ export async function safeDownload(url, options) {
     }
     // readBoundedBuffer expects a Response that exposes Content-Length and
     // arrayBuffer(). undici Response satisfies both.
+    if (!isBoundedBufferResponse(response)) {
+        throw new Error(`safeDownload(${options.label}): response is missing headers.get()/arrayBuffer()`);
+    }
     return readBoundedBuffer(response, options.maxBytes, options.label);
 }
 //# sourceMappingURL=safeFetch.js.map

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

@@ -27,7 +27,7 @@ export declare function ensureNestedSchemaTypes(schema: Record<string, unknown>)
  * 2. AI SDK `jsonSchema()` wrappers (have `.jsonSchema` property) -- extracted directly
  * 3. Plain JSON Schema objects (have `type`/`properties` but no `_def`) -- returned as-is
  */
-export declare function convertZodToJsonSchema(zodSchema: ZodUnknownSchema, target?: "jsonSchema7" | "openApi3"): object;
+export declare function convertZodToJsonSchema(zodSchema: ZodUnknownSchema | Record<string, unknown>, target?: "jsonSchema7" | "openApi3"): object;
 export declare function normalizeJsonSchemaObject(schema: Record<string, unknown> | undefined | null): Record<string, unknown>;
 /**
  * Normalize a JSON Schema for the OpenAI chat-completions `tools` wire

package/dist/lib/utils/schemaConversion.js

@@ -308,7 +308,10 @@ export function ensureNestedSchemaTypes(schema) {
  * 2. AI SDK `jsonSchema()` wrappers (have `.jsonSchema` property) -- extracted directly
  * 3. Plain JSON Schema objects (have `type`/`properties` but no `_def`) -- returned as-is
  */
-export function convertZodToJsonSchema(zodSchema, 
+export function convertZodToJsonSchema(
+// The union mirrors the three documented input shapes: Zod schemas plus
+// plain-object forms (AI SDK `jsonSchema()` wrappers and raw JSON Schema).
+zodSchema, 
 // Default to JSON Schema draft-07 so non-Vertex consumers (Bedrock, MCP
 // tool registration, etc.) keep their pre-migration dialect. Vertex/Gemini
 // callers opt into "openApi3" explicitly to get `nullable: true` instead
@@ -360,6 +363,7 @@ target = "jsonSchema7") {
     try {
         // Zod 4→3 boundary: zodToJsonSchema types reference Zod 3's ZodSchema via zod/v3.
         // Runtime compatible — cast through unknown at this third-party boundary only.
+        // eslint-disable-next-line no-restricted-syntax -- genuine third-party type-system boundary: zod-to-json-schema's input type is zod/v3's ZodType, structurally incompatible with the Zod 4 schema held here (no overlap, single assertion cannot compile); runtime-compatible fallback contract documented above.
         const zodV3Schema = zodSchema;
         const jsonSchema = zodToJsonSchema(zodV3Schema, {
             name: "ToolParameters",

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

@@ -368,7 +368,7 @@ export declare function hasJudge(config: WorkflowConfig): boolean;
 export declare function getAllJudges(config: WorkflowConfig): JudgeConfig[];
 /**
  * Calculate estimated workflow cost (placeholder)
- * TODO: Implement actual provider-specific pricing
+ * TODO(#1179): Implement actual provider-specific pricing
  * @param config - Workflow configuration
  * @param estimatedTokens - Estimated number of tokens for the request
  * @returns Estimated cost in USD

package/dist/lib/workflow/config.js

@@ -383,7 +383,7 @@ export function getAllJudges(config) {
 }
 /**
  * Calculate estimated workflow cost (placeholder)
- * TODO: Implement actual provider-specific pricing
+ * TODO(#1179): Implement actual provider-specific pricing
  * @param config - Workflow configuration
  * @param estimatedTokens - Estimated number of tokens for the request
  * @returns Estimated cost in USD

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

@@ -10,7 +10,7 @@ const functionTag = "WorkflowRegistry";
 // ============================================================================
 /**
  * In-memory workflow registry
- * TODO: Consider persistent storage in future phases
+ * TODO(#1179): Consider persistent storage in future phases
  */
 const workflowRegistry = new Map();
 // ============================================================================

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

@@ -158,7 +158,7 @@ export async function runWorkflow(config, options) {
                     totalInputTokens: calculateInputTokens(ensembleResult.responses),
                     totalOutputTokens: calculateOutputTokens(ensembleResult.responses),
                     totalTokens: calculateTotalTokens(ensembleResult.responses),
-                    byModel: [], // TODO: Populate per-model breakdown
+                    byModel: [], // TODO(#1179): Populate per-model breakdown
                 },
                 // Additional metadata
                 metadata: options.metadata,

package/dist/lib/workflow/utils/workflowMetrics.d.ts

@@ -46,7 +46,7 @@ export declare function calculateModelMetrics(responses: EnsembleResponse[]): Re
 /**
  * Calculate consensus level between responses
  * NOTE: Placeholder implementation - uses response length similarity
- * TODO: Implement semantic similarity in Phase 2
+ * TODO(#1179): Implement semantic similarity in Phase 2
  */
 export declare function calculateConsensus(responses: EnsembleResponse[]): number;
 /**

package/dist/lib/workflow/utils/workflowMetrics.js

@@ -159,7 +159,7 @@ export function calculateModelMetrics(responses) {
 /**
  * Calculate consensus level between responses
  * NOTE: Placeholder implementation - uses response length similarity
- * TODO: Implement semantic similarity in Phase 2
+ * TODO(#1179): Implement semantic similarity in Phase 2
  */
 export function calculateConsensus(responses) {
     const successful = responses.filter((r) => r.status === "success");

package/dist/mcp/elicitationProtocol.js

@@ -355,7 +355,7 @@ export function createSelectRequest(message, selectOptions, options) {
  */
 export function createFormRequest(message, fields, options) {
     const requestOptions = {
-        fields: fields,
+        fields,
     };
     if (options.submitLabel !== undefined) {
         requestOptions.submitLabel = options.submitLabel;

package/dist/mcp/mcpRegistryClient.js

@@ -272,7 +272,7 @@ export class MCPRegistryClient extends EventEmitter {
         if (wellKnown) {
             return wellKnown;
         }
-        // TODO: Fetch from remote registry
+        // TODO(#1179): Fetch from remote registry
         return undefined;
     }
     /**