@juspay/neurolink 9.61.0 → 9.61.2

package/dist/core/baseProvider.js

@@ -314,7 +314,7 @@ export class BaseProvider {
                         status: (tr.status === "error"
                             ? "failure"
                             : "success"),
-                        result: tr.result,
+                        result: tr.output ?? tr.result,
                         error: tr.error,
                     }))
                     : undefined,

package/dist/core/modules/GenerationHandler.js

@@ -441,7 +441,7 @@ export class GenerationHandler {
                         toolExecutions.push({
                             name: toolName,
                             input: toolArgs,
-                            output: trRecord.result ?? "success",
+                            output: (trRecord.output ?? trRecord.result) ?? "success",
                         });
                     }
                 }

package/dist/core/redisConversationMemoryManager.d.ts

@@ -80,6 +80,7 @@ export declare class RedisConversationMemoryManager implements IConversationMemo
         [key: string]: unknown;
     }>, toolResults: Array<{
         toolCallId?: string;
+        output?: unknown;
         result?: unknown;
         error?: string;
         [key: string]: unknown;

package/dist/core/redisConversationMemoryManager.js

@@ -1340,18 +1340,22 @@ User message: "${userMessage}"`;
                 const toolCallId = String(toolResult.toolCallId || toolResult.id || "unknown");
                 const toolName = toolCallMap.get(toolCallId) ||
                     String(toolResult.toolName || "unknown");
+                const toolResultRecord = toolResult;
+                const selectedResultField = "output" in toolResultRecord ? "output" : "result";
+                const toolResultValue = selectedResultField === "output"
+                    ? toolResultRecord.output
+                    : toolResult.result;
                 // Serialize the tool result to string for content field
                 let serializedResult;
-                if (typeof toolResult.result === "string") {
-                    serializedResult = toolResult.result;
+                if (typeof toolResultValue === "string") {
+                    serializedResult = toolResultValue;
                 }
-                else if (toolResult.result === undefined ||
-                    toolResult.result === null) {
-                    serializedResult = String(toolResult.result ?? "null");
+                else if (toolResultValue === undefined || toolResultValue === null) {
+                    serializedResult = String(toolResultValue ?? "null");
                 }
                 else {
                     try {
-                        serializedResult = JSON.stringify(toolResult.result, null, 2);
+                        serializedResult = JSON.stringify(toolResultValue, null, 2);
                     }
                     catch (serializeError) {
                         serializedResult = `[Serialization failed: ${serializeError instanceof Error ? serializeError.message : String(serializeError)}]`;
@@ -1366,7 +1370,7 @@ User message: "${userMessage}"`;
                 // The surrogate carries `_meta.neurolinkArtifactId` on the raw result object.
                 let artifactId;
                 try {
-                    const rawResult = toolResult.result;
+                    const rawResult = toolResultValue;
                     if (rawResult && typeof rawResult === "object") {
                         const meta = rawResult._meta;
                         if (meta && typeof meta === "object") {

package/dist/lib/core/baseProvider.js

@@ -314,7 +314,7 @@ export class BaseProvider {
                         status: (tr.status === "error"
                             ? "failure"
                             : "success"),
-                        result: tr.result,
+                        result: tr.output ?? tr.result,
                         error: tr.error,
                     }))
                     : undefined,

package/dist/lib/core/modules/GenerationHandler.js

@@ -441,7 +441,7 @@ export class GenerationHandler {
                         toolExecutions.push({
                             name: toolName,
                             input: toolArgs,
-                            output: trRecord.result ?? "success",
+                            output: (trRecord.output ?? trRecord.result) ?? "success",
                         });
                     }
                 }

package/dist/lib/core/redisConversationMemoryManager.d.ts

@@ -80,6 +80,7 @@ export declare class RedisConversationMemoryManager implements IConversationMemo
         [key: string]: unknown;
     }>, toolResults: Array<{
         toolCallId?: string;
+        output?: unknown;
         result?: unknown;
         error?: string;
         [key: string]: unknown;

package/dist/lib/core/redisConversationMemoryManager.js

@@ -1340,18 +1340,22 @@ User message: "${userMessage}"`;
                 const toolCallId = String(toolResult.toolCallId || toolResult.id || "unknown");
                 const toolName = toolCallMap.get(toolCallId) ||
                     String(toolResult.toolName || "unknown");
+                const toolResultRecord = toolResult;
+                const selectedResultField = "output" in toolResultRecord ? "output" : "result";
+                const toolResultValue = selectedResultField === "output"
+                    ? toolResultRecord.output
+                    : toolResult.result;
                 // Serialize the tool result to string for content field
                 let serializedResult;
-                if (typeof toolResult.result === "string") {
-                    serializedResult = toolResult.result;
+                if (typeof toolResultValue === "string") {
+                    serializedResult = toolResultValue;
                 }
-                else if (toolResult.result === undefined ||
-                    toolResult.result === null) {
-                    serializedResult = String(toolResult.result ?? "null");
+                else if (toolResultValue === undefined || toolResultValue === null) {
+                    serializedResult = String(toolResultValue ?? "null");
                 }
                 else {
                     try {
-                        serializedResult = JSON.stringify(toolResult.result, null, 2);
+                        serializedResult = JSON.stringify(toolResultValue, null, 2);
                     }
                     catch (serializeError) {
                         serializedResult = `[Serialization failed: ${serializeError instanceof Error ? serializeError.message : String(serializeError)}]`;
@@ -1366,7 +1370,7 @@ User message: "${userMessage}"`;
                 // The surrogate carries `_meta.neurolinkArtifactId` on the raw result object.
                 let artifactId;
                 try {
-                    const rawResult = toolResult.result;
+                    const rawResult = toolResultValue;
                     if (rawResult && typeof rawResult === "object") {
                         const meta = rawResult._meta;
                         if (meta && typeof meta === "object") {

package/dist/lib/mcp/toolRegistry.js

@@ -301,12 +301,18 @@ export class MCPToolRegistry extends MCPRegistry {
                 span.setAttribute("tool.arguments_size", argsStr.length);
                 // HITL Safety Check: Request confirmation if required
                 let finalArgs = args;
-                if (this.hitlManager && this.hitlManager.isEnabled()) {
+                const HITLState = context?.hitlState;
+                if (!HITLState?.triggered &&
+                    this.hitlManager &&
+                    this.hitlManager.isEnabled()) {
                     const requiresConfirmation = this.hitlManager.requiresConfirmation(toolName, args);
                     if (requiresConfirmation) {
                         registryLogger.info(`Tool '${toolName}' requires HITL confirmation`);
                         span.addEvent("tool.hitl_requested");
                         try {
+                            if (HITLState) {
+                                HITLState.triggered = true;
+                            }
                             const confirmationResult = await this.hitlManager.requestConfirmation(toolName, args, {
                                 serverId: tool.serverId,
                                 sessionId: execContext.sessionId,

package/dist/lib/neurolink.js

@@ -7199,6 +7199,7 @@ Current user's request: ${currentInput}`;
             inputSize: inputStr.length,
             truncatedInput: inputStr.length > 2048 ? inputStr.substring(0, 2048) : inputStr,
             options,
+            hitlState: { triggered: false },
         };
     }
     async executeToolWithSpan(toolName, params, options, executionContext, toolSpan) {
@@ -7305,7 +7306,7 @@ Current user's request: ${currentInput}`;
                 circuitBreakerState: prepared.circuitBreaker.getState(),
             });
             const result = await prepared.circuitBreaker.execute(async () => {
-                return withRetry(async () => withTimeout(this.executeToolInternal(toolName, params, prepared.finalOptions), prepared.finalOptions.timeout, ErrorFactory.toolTimeout(toolName, prepared.finalOptions.timeout)), {
+                return withRetry(async () => withTimeout(this.executeToolInternal(toolName, params, prepared.finalOptions, executionContext.hitlState), prepared.finalOptions.timeout, ErrorFactory.toolTimeout(toolName, prepared.finalOptions.timeout)), {
                     maxAttempts: prepared.finalOptions.maxRetries + 1,
                     delayMs: prepared.finalOptions.retryDelayMs,
                     isRetriable: isRetriableError,
@@ -7526,7 +7527,7 @@ Current user's request: ${currentInput}`;
      * - Annotations: skip cache for destructive tools, retry safe tools on failure
      * - Middleware: apply global middleware chain before execution
      */
-    async executeToolInternal(toolName, params, options) {
+    async executeToolInternal(toolName, params, options, HITLState) {
         const functionTag = "NeuroLink.executeToolInternal";
         // === MCP ENHANCEMENT: Infer annotations for cache/retry decisions ===
         const toolAnnotations = this.getToolAnnotationsForExecution(toolName);
@@ -7645,6 +7646,7 @@ Current user's request: ${currentInput}`;
                 const context = {
                     ...storedContext,
                     ...passedAuthContext,
+                    hitlState: HITLState,
                 };
                 logger.debug(`[Using merged context for unified registry tool:`, {
                     toolName,

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

@@ -232,3 +232,6 @@ export type HITLManager = {
     on(event: string, listener: (...args: unknown[]) => void): HITLManager;
     emit(event: string, ...args: unknown[]): boolean;
 };
+export type HITLExecutionState = {
+    triggered: boolean;
+};

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

@@ -9,6 +9,7 @@ import type { StandardRecord, StringArray, ZodUnknownSchema } from "./aliases.js
 import type { ValidationError } from "../utils/parameterValidation.js";
 import type { MCPToolAnnotations } from "./mcp.js";
 import type { Logger } from "./utilities.js";
+import type { HITLExecutionState } from "./hitl.js";
 /**
  * Commonly used Zod schema type aliases for cleaner type declarations
  */
@@ -48,6 +49,7 @@ export type ExecutionContext<T = StandardRecord> = {
     timeoutMs?: number;
     maxRetries?: number;
     startTime?: number;
+    hitlState?: HITLExecutionState;
 };
 /**
  * Cache configuration options
@@ -439,6 +441,7 @@ export type PendingToolExecution = {
     toolResults: Array<{
         toolCallId?: string;
         toolName?: string;
+        output?: unknown;
         result?: unknown;
         error?: string;
         timestamp?: Date;

package/dist/lib/utils/errorHandling.js

@@ -5,6 +5,7 @@
 import { ErrorCategory, ErrorSeverity } from "../constants/enums.js";
 import { logger } from "./logger.js";
 import { CircuitBreakerOpenError } from "../types/index.js";
+import { HITLTimeoutError } from "../hitl/hitlErrors.js";
 // Error codes for different scenarios
 export const ERROR_CODES = {
     // Tool errors
@@ -950,6 +951,9 @@ export function isRetriableError(error) {
     if (error instanceof NeuroLinkError) {
         return error.retriable;
     }
+    if (error instanceof HITLTimeoutError) {
+        return false;
+    }
     // Check for common retriable error patterns
     const retriablePatterns = [
         /timeout/i,

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

@@ -8,16 +8,24 @@ import type { ZodUnknownSchema } from "../types/index.js";
  * - Top-level $ref resolution
  * - Nested $ref within properties, items, additionalProperties
  * - $ref within allOf, anyOf, oneOf arrays
+ * - Deep $ref paths like "#/definitions/Foo/properties/bar"
  * - Circular reference detection to prevent infinite loops
  */
-export declare function inlineJsonSchema(schema: Record<string, unknown>, definitions?: Record<string, Record<string, unknown>>, visited?: Set<string>): Record<string, unknown>;
+export declare function inlineJsonSchema(schema: Record<string, unknown>, definitions?: Record<string, Record<string, unknown>>, visited?: Set<string>, rootSchema?: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Recursively ensure all nested schemas have a type field.
+ * Google Vertex AI requires ALL schema objects (including nested properties) to have a type field.
+ * This function walks through the schema tree and adds type:"object" to any object-like schema
+ * that's missing its type field.
+ */
+export declare function ensureNestedSchemaTypes(schema: Record<string, unknown>): Record<string, unknown>;
 /**
  * Convert Zod schema to JSON Schema format for provider APIs.
  *
  * Handles three input types:
- * 1. Zod schemas (have `_def.typeName`) — converted via zod-to-json-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
+ * 1. Zod schemas (have `_def.typeName`) -- converted via zod-to-json-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 declare function convertZodToJsonSchema(zodSchema: ZodUnknownSchema): object;
 export declare function normalizeJsonSchemaObject(schema: Record<string, unknown> | undefined | null): Record<string, unknown>;

package/dist/lib/utils/schemaConversion.js

@@ -2,6 +2,53 @@ import { zodToJsonSchema } from "zod-to-json-schema";
 import { jsonSchemaToZod } from "json-schema-to-zod";
 import { z } from "zod";
 import { logger } from "./logger.js";
+/**
+ * Resolve a deep JSON pointer path within a schema.
+ * Handles paths like "#/definitions/ToolParameters/properties/foo/properties/bar"
+ *
+ * Implements RFC 6901 token decoding so property names containing the literal
+ * characters "/" or "~" can still be resolved (their escaped forms are "~1"
+ * and "~0" respectively). Because "#/..." is the URI-fragment form of a JSON
+ * Pointer (RFC 6901 §6), each segment may also be percent-encoded; we decode
+ * that first.
+ *
+ * Order matters: percent-decode → "~1" → "/" → "~0" → "~". Reversing the
+ * tilde steps would let "~01" round-trip to "/" instead of the intended "~1".
+ */
+function resolveDeepRef(rootSchema, refPath) {
+    // Strip the leading "#/" then split + decode each segment per RFC 6901
+    const pathParts = refPath
+        .replace(/^#\//, "")
+        .split("/")
+        .map((seg) => safePercentDecode(seg).replace(/~1/g, "/").replace(/~0/g, "~"));
+    let current = rootSchema;
+    for (const part of pathParts) {
+        if (current && typeof current === "object" && part in current) {
+            current = current[part];
+        }
+        else {
+            return undefined;
+        }
+    }
+    if (current && typeof current === "object") {
+        return current;
+    }
+    return undefined;
+}
+/**
+ * Percent-decode a JSON Pointer segment defensively. Falls back to the raw
+ * segment if the input contains a malformed escape sequence (decodeURIComponent
+ * throws URIError on those) — better to attempt a literal match than fail the
+ * whole resolution.
+ */
+function safePercentDecode(segment) {
+    try {
+        return decodeURIComponent(segment);
+    }
+    catch {
+        return segment;
+    }
+}
 /**
  * Inline a JSON Schema by recursively resolving all $ref references.
  * zodToJsonSchema with 'name' option produces schemas with $ref pointing to definitions.
@@ -11,29 +58,45 @@ import { logger } from "./logger.js";
  * - Top-level $ref resolution
  * - Nested $ref within properties, items, additionalProperties
  * - $ref within allOf, anyOf, oneOf arrays
+ * - Deep $ref paths like "#/definitions/Foo/properties/bar"
  * - Circular reference detection to prevent infinite loops
  */
-export function inlineJsonSchema(schema, definitions, visited = new Set()) {
+export function inlineJsonSchema(schema, definitions, visited = new Set(), rootSchema) {
     // Use definitions from schema if not provided
     const defs = definitions ||
         schema.definitions;
+    // Keep track of the root schema for deep ref resolution
+    const root = rootSchema || schema;
     // Handle $ref at current level
-    if (typeof schema.$ref === "string" &&
-        schema.$ref.startsWith("#/definitions/")) {
-        const defName = schema.$ref.replace("#/definitions/", "");
+    if (typeof schema.$ref === "string" && schema.$ref.startsWith("#/")) {
+        const refPath = schema.$ref;
         // Prevent circular reference infinite loops
-        if (visited.has(defName)) {
-            logger.debug(`[SCHEMA-INLINE] Circular reference detected for: ${defName}`);
+        if (visited.has(refPath)) {
+            logger.debug(`[SCHEMA-INLINE] Circular reference detected for: ${refPath}`);
             // Return a simple object placeholder for circular refs
             return { type: "object" };
         }
-        if (defs && defs[defName]) {
-            visited.add(defName);
-            // Recursively inline the resolved definition
-            const resolved = inlineJsonSchema({ ...defs[defName] }, defs, visited);
-            visited.delete(defName);
-            return resolved;
+        // Try simple definition lookup first (for #/definitions/SomeName)
+        if (refPath.startsWith("#/definitions/")) {
+            const defName = refPath.replace("#/definitions/", "");
+            // Check if it's a simple definition name (no slashes after definitions/)
+            if (!defName.includes("/") && defs && defs[defName]) {
+                visited.add(refPath);
+                const resolved = inlineJsonSchema({ ...defs[defName] }, defs, visited, root);
+                visited.delete(refPath);
+                return resolved;
+            }
+        }
+        // Try deep path resolution for complex paths like
+        // #/definitions/ToolParameters/properties/accountPerformance/properties/roas
+        const resolved = resolveDeepRef(root, refPath);
+        if (resolved) {
+            visited.add(refPath);
+            const inlined = inlineJsonSchema({ ...resolved }, defs, visited, root);
+            visited.delete(refPath);
+            return inlined;
         }
+        logger.debug(`[SCHEMA-INLINE] Could not resolve $ref: ${refPath}`);
     }
     // Create result without $ref and definitions
     const result = {};
@@ -47,7 +110,7 @@ export function inlineJsonSchema(schema, definitions, visited = new Set()) {
             const properties = {};
             for (const [propName, propSchema] of Object.entries(value)) {
                 if (propSchema && typeof propSchema === "object") {
-                    properties[propName] = inlineJsonSchema(propSchema, defs, visited);
+                    properties[propName] = inlineJsonSchema(propSchema, defs, visited, root);
                 }
                 else {
                     properties[propName] = propSchema;
@@ -59,32 +122,32 @@ export function inlineJsonSchema(schema, definitions, visited = new Set()) {
             // Handle array items schema
             if (Array.isArray(value)) {
                 result[key] = value.map((item) => item && typeof item === "object"
-                    ? inlineJsonSchema(item, defs, visited)
+                    ? inlineJsonSchema(item, defs, visited, root)
                     : item);
             }
             else {
-                result[key] = inlineJsonSchema(value, defs, visited);
+                result[key] = inlineJsonSchema(value, defs, visited, root);
             }
         }
         else if (key === "additionalProperties" &&
             value &&
             typeof value === "object") {
-            result[key] = inlineJsonSchema(value, defs, visited);
+            result[key] = inlineJsonSchema(value, defs, visited, root);
         }
         else if ((key === "allOf" || key === "anyOf" || key === "oneOf") &&
             Array.isArray(value)) {
             // Handle composition schemas
             result[key] = value.map((item) => item && typeof item === "object"
-                ? inlineJsonSchema(item, defs, visited)
+                ? inlineJsonSchema(item, defs, visited, root)
                 : item);
         }
         else if (key === "not" && value && typeof value === "object") {
-            result[key] = inlineJsonSchema(value, defs, visited);
+            result[key] = inlineJsonSchema(value, defs, visited, root);
         }
         else if ((key === "if" || key === "then" || key === "else") &&
             value &&
             typeof value === "object") {
-            result[key] = inlineJsonSchema(value, defs, visited);
+            result[key] = inlineJsonSchema(value, defs, visited, root);
         }
         else {
             result[key] = value;
@@ -92,13 +155,129 @@ export function inlineJsonSchema(schema, definitions, visited = new Set()) {
     }
     return result;
 }
+/**
+ * Recursively ensure all nested schemas have a type field.
+ * Google Vertex AI requires ALL schema objects (including nested properties) to have a type field.
+ * This function walks through the schema tree and adds type:"object" to any object-like schema
+ * that's missing its type field.
+ */
+export function ensureNestedSchemaTypes(schema) {
+    if (!schema || typeof schema !== "object") {
+        return {};
+    }
+    let result = { ...schema };
+    // CRITICAL FIX: Flatten single-item allOf for Google Vertex AI compatibility
+    // When we have { allOf: [{ type: "object", ... }], nullable: true }, flatten it to:
+    // { type: "object", ..., nullable: true }
+    if (result.allOf &&
+        Array.isArray(result.allOf) &&
+        result.allOf.length === 1 &&
+        result.allOf[0] &&
+        typeof result.allOf[0] === "object") {
+        const innerSchema = result.allOf[0];
+        // Only flatten if inner schema has meaningful content (type, properties, items, etc.)
+        if (innerSchema.type ||
+            innerSchema.properties ||
+            innerSchema.items ||
+            innerSchema.enum) {
+            logger.debug(`[SCHEMA-TYPE-FIX] Flattening single-item allOf with type: ${innerSchema.type}`);
+            // Merge: inner schema properties take precedence, except for wrapper's metadata
+            const { allOf: _ignored, ...wrapperProps } = result;
+            result = {
+                ...innerSchema,
+                ...wrapperProps, // Keep wrapper's nullable, description, etc.
+            };
+            // If inner schema had its own nullable/description, restore them
+            if (innerSchema.description && !wrapperProps.description) {
+                result.description = innerSchema.description;
+            }
+        }
+    }
+    // Infer type from structure if missing
+    if (!result.type) {
+        // If it has properties, it's an object
+        if (result.properties) {
+            result.type = "object";
+            logger.debug(`[SCHEMA-TYPE-FIX] Added type:"object" to schema with properties`);
+        }
+        // If it has items, it's an array
+        else if (result.items) {
+            result.type = "array";
+            logger.debug(`[SCHEMA-TYPE-FIX] Added type:"array" to schema with items`);
+        }
+        // If it has enum, infer from enum values — but only when ALL elements
+        // share the same primitive type. A mixed enum like [1, "x"] would
+        // otherwise be silently narrowed to whatever the first element is.
+        else if (result.enum &&
+            Array.isArray(result.enum) &&
+            result.enum.length > 0) {
+            if (result.enum.every((v) => typeof v === "string")) {
+                result.type = "string";
+                logger.debug(`[SCHEMA-TYPE-FIX] Added type:"string" to schema with enum`);
+            }
+            else if (result.enum.every((v) => typeof v === "number")) {
+                result.type = "number";
+                logger.debug(`[SCHEMA-TYPE-FIX] Added type:"number" to schema with enum`);
+            }
+            // Mixed-type enum: leave result.type unset rather than narrow it.
+        }
+        // If it has allOf with typed schemas, infer from first item
+        else if (result.allOf &&
+            Array.isArray(result.allOf) &&
+            result.allOf.length > 0) {
+            const firstItem = result.allOf[0];
+            if (firstItem && firstItem.type) {
+                result.type = firstItem.type;
+                logger.debug(`[SCHEMA-TYPE-FIX] Inferred type from allOf: ${result.type}`);
+            }
+        }
+    }
+    // Recursively process properties
+    if (result.properties && typeof result.properties === "object") {
+        const properties = {};
+        for (const [propName, propSchema] of Object.entries(result.properties)) {
+            if (propSchema && typeof propSchema === "object") {
+                properties[propName] = ensureNestedSchemaTypes(propSchema);
+            }
+            else {
+                properties[propName] = propSchema;
+            }
+        }
+        result.properties = properties;
+    }
+    // Recursively process items (for arrays)
+    if (result.items && typeof result.items === "object") {
+        if (Array.isArray(result.items)) {
+            result.items = result.items.map((item) => item && typeof item === "object"
+                ? ensureNestedSchemaTypes(item)
+                : item);
+        }
+        else {
+            result.items = ensureNestedSchemaTypes(result.items);
+        }
+    }
+    // Recursively process additionalProperties
+    if (result.additionalProperties &&
+        typeof result.additionalProperties === "object") {
+        result.additionalProperties = ensureNestedSchemaTypes(result.additionalProperties);
+    }
+    // Recursively process allOf, anyOf, oneOf
+    for (const key of ["allOf", "anyOf", "oneOf"]) {
+        if (result[key] && Array.isArray(result[key])) {
+            result[key] = result[key].map((item) => item && typeof item === "object"
+                ? ensureNestedSchemaTypes(item)
+                : item);
+        }
+    }
+    return result;
+}
 /**
  * Convert Zod schema to JSON Schema format for provider APIs.
  *
  * Handles three input types:
- * 1. Zod schemas (have `_def.typeName`) — converted via zod-to-json-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
+ * 1. Zod schemas (have `_def.typeName`) -- converted via zod-to-json-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) {
     const schema = zodSchema;
@@ -110,11 +289,11 @@ export function convertZodToJsonSchema(zodSchema) {
         schema.jsonSchema !== null &&
         typeof schema.jsonSchema === "object") {
         const extracted = schema.jsonSchema;
-        return ensureTypeField(extracted);
+        return ensureNestedSchemaTypes(ensureTypeField(extracted));
     }
     // Plain JSON Schema object (from external MCP tools) — no Zod internals
     if (!isZodSchema(schema)) {
-        return ensureTypeField(schema);
+        return ensureNestedSchemaTypes(ensureTypeField(schema));
     }
     // Actual Zod schema — convert via zod-to-json-schema
     try {
@@ -123,13 +302,15 @@ export function convertZodToJsonSchema(zodSchema) {
         const zodV3Schema = zodSchema;
         const jsonSchema = zodToJsonSchema(zodV3Schema, {
             name: "ToolParameters",
-            target: "jsonSchema7",
+            target: "openApi3", // Use OpenAPI 3.0 for nullable: true instead of anyOf with null (required for Vertex AI)
             errorMessages: true,
         });
         // zodToJsonSchema with 'name' produces { $ref: "#/definitions/ToolParameters", definitions: {...} }
-        // Inline the $ref to produce a flat schema before passing to ensureTypeField
+        // Inline the $ref to produce a flat schema, ensure the root has a type
+        // field, then walk the tree so nested objects/arrays/additionalProperties
+        // also pick up an inferred type (Vertex/Gemini require it everywhere).
         const inlined = inlineJsonSchema(jsonSchema);
-        return ensureTypeField(inlined);
+        return ensureNestedSchemaTypes(ensureTypeField(inlined));
     }
     catch (error) {
         logger.warn("Failed to convert Zod schema to JSON Schema", {

package/dist/mcp/toolRegistry.js

@@ -301,12 +301,18 @@ export class MCPToolRegistry extends MCPRegistry {
                 span.setAttribute("tool.arguments_size", argsStr.length);
                 // HITL Safety Check: Request confirmation if required
                 let finalArgs = args;
-                if (this.hitlManager && this.hitlManager.isEnabled()) {
+                const HITLState = context?.hitlState;
+                if (!HITLState?.triggered &&
+                    this.hitlManager &&
+                    this.hitlManager.isEnabled()) {
                     const requiresConfirmation = this.hitlManager.requiresConfirmation(toolName, args);
                     if (requiresConfirmation) {
                         registryLogger.info(`Tool '${toolName}' requires HITL confirmation`);
                         span.addEvent("tool.hitl_requested");
                         try {
+                            if (HITLState) {
+                                HITLState.triggered = true;
+                            }
                             const confirmationResult = await this.hitlManager.requestConfirmation(toolName, args, {
                                 serverId: tool.serverId,
                                 sessionId: execContext.sessionId,

package/dist/neurolink.js

@@ -7199,6 +7199,7 @@ Current user's request: ${currentInput}`;
             inputSize: inputStr.length,
             truncatedInput: inputStr.length > 2048 ? inputStr.substring(0, 2048) : inputStr,
             options,
+            hitlState: { triggered: false },
         };
     }
     async executeToolWithSpan(toolName, params, options, executionContext, toolSpan) {
@@ -7305,7 +7306,7 @@ Current user's request: ${currentInput}`;
                 circuitBreakerState: prepared.circuitBreaker.getState(),
             });
             const result = await prepared.circuitBreaker.execute(async () => {
-                return withRetry(async () => withTimeout(this.executeToolInternal(toolName, params, prepared.finalOptions), prepared.finalOptions.timeout, ErrorFactory.toolTimeout(toolName, prepared.finalOptions.timeout)), {
+                return withRetry(async () => withTimeout(this.executeToolInternal(toolName, params, prepared.finalOptions, executionContext.hitlState), prepared.finalOptions.timeout, ErrorFactory.toolTimeout(toolName, prepared.finalOptions.timeout)), {
                     maxAttempts: prepared.finalOptions.maxRetries + 1,
                     delayMs: prepared.finalOptions.retryDelayMs,
                     isRetriable: isRetriableError,
@@ -7526,7 +7527,7 @@ Current user's request: ${currentInput}`;
      * - Annotations: skip cache for destructive tools, retry safe tools on failure
      * - Middleware: apply global middleware chain before execution
      */
-    async executeToolInternal(toolName, params, options) {
+    async executeToolInternal(toolName, params, options, HITLState) {
         const functionTag = "NeuroLink.executeToolInternal";
         // === MCP ENHANCEMENT: Infer annotations for cache/retry decisions ===
         const toolAnnotations = this.getToolAnnotationsForExecution(toolName);
@@ -7645,6 +7646,7 @@ Current user's request: ${currentInput}`;
                 const context = {
                     ...storedContext,
                     ...passedAuthContext,
+                    hitlState: HITLState,
                 };
                 logger.debug(`[Using merged context for unified registry tool:`, {
                     toolName,