@juspay/neurolink 9.63.0 → 9.64.0

package/dist/lib/providers/openRouter.js

@@ -32,15 +32,19 @@ const getOpenRouterConfig = () => {
  *
  * OpenRouter uses a 'provider/model' format for model names.
  * For example:
- *   - 'anthropic/claude-3-5-sonnet'
+ *   - 'anthropic/claude-sonnet-4.5'
  *   - 'openai/gpt-4o'
- *   - 'google/gemini-2.0-flash'
+ *   - 'google/gemini-2.5-flash'
  *   - 'meta-llama/llama-3-70b-instruct'
  *
  * You can override the default by setting the OPENROUTER_MODEL environment variable.
+ *
+ * Default updated from `anthropic/claude-3-5-sonnet` to `anthropic/claude-sonnet-4.5`
+ * because OpenRouter sunset the Claude 3.5 Sonnet endpoint upstream — every
+ * call against the old default returned `No endpoints found` 404s.
  */
 const getDefaultOpenRouterModel = () => {
-    return getProviderModel("OPENROUTER_MODEL", "anthropic/claude-3-5-sonnet");
+    return getProviderModel("OPENROUTER_MODEL", "anthropic/claude-sonnet-4.5");
 };
 /**
  * OpenRouter Provider - BaseProvider Implementation

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

@@ -19,6 +19,20 @@ export type ZodUnknownSchema = ZodTypeAny;
  * through `unknown` to this type at the third-party boundary.
  */
 export type ZodToJsonSchemaInput = Parameters<typeof zodToJsonSchema>[0];
+/**
+ * Dialects accepted by Zod 4's native `z.toJSONSchema(schema, { target })`.
+ * Note the `.` in `"openapi-3.0"`: this differs from the `zod-to-json-schema`
+ * package's `"openApi3"` form. The schemaConversion helper maps between the
+ * two so internal call sites can use a single `"openApi3"` identifier.
+ */
+export type Zod4NativeTarget = "draft-07" | "openapi-3.0";
+/**
+ * Subset of Zod 4's `ToJSONSchemaParams` we forward through. Kept minimal so
+ * the type stays stable even if Zod 4 grows the surface in future releases.
+ */
+export type Zod4NativeParams = {
+    target?: Zod4NativeTarget;
+};
 /**
  * Union type for schema validation (Zod or AI SDK schema)
  * Commonly used in provider interfaces and validation functions

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

@@ -399,9 +399,6 @@ export type StreamingParser = {
     /** Reset parser state for new stream */
     reset(): void;
 };
-export type HippocampusMemory = import("@juspay/hippocampus").HippocampusConfig & {
-    enabled?: boolean;
-};
 /** Value types accepted as session variables by the loop REPL. */
 export type SessionVariableValue = string | number | boolean;
 /** State snapshot for the active REPL loop session. */

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

@@ -32,10 +32,17 @@
  * - Current time (Unix ms): `Date.now()`
  * - Current time (ISO): `new Date().toISOString()`
  */
-import type { HippocampusMemory } from "./common.js";
+import type { HippocampusMemory, HippocampusStorageConfig } from "./memory.js";
 import type { ObservabilityConfig } from "./observability.js";
-export type StorageConfig = import("@juspay/hippocampus").StorageConfig;
-export type { HippocampusMemory };
+/**
+ * Legacy public alias for the Hippocampus storage configuration.
+ * The structural definition lives in `./memory.ts`; this re-export keeps
+ * the SDK surface stable for callers who imported `StorageConfig` from
+ * the package barrel. Defined as a `type` alias rather than a re-export
+ * so the canonical `HippocampusStorageConfig` name is the one ESLint
+ * uniqueness checks see.
+ */
+export type StorageConfig = HippocampusStorageConfig;
 /**
  * Configuration for conversation memory feature
  */

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

@@ -217,6 +217,12 @@ export type GenerateOptions = {
     region?: string;
     temperature?: number;
     maxTokens?: number;
+    /** Top-p (nucleus) sampling parameter. Controls diversity of generated tokens. */
+    topP?: number;
+    /** Top-k sampling parameter. Limits the number of tokens considered. (Google/Gemini models only) */
+    topK?: number;
+    /** Stop sequences that will halt generation when encountered. */
+    stopSequences?: string[];
     systemPrompt?: string;
     /**
      * Zod schema for structured output validation
@@ -753,6 +759,12 @@ export type TextGenerationOptions = {
     region?: string;
     temperature?: number;
     maxTokens?: number;
+    /** Top-p (nucleus) sampling parameter. Controls diversity of generated tokens. */
+    topP?: number;
+    /** Top-k sampling parameter. Limits the number of tokens considered. (Google/Gemini models only) */
+    topK?: number;
+    /** Stop sequences that will halt generation when encountered. */
+    stopSequences?: string[];
     systemPrompt?: string;
     schema?: ZodUnknownSchema | Schema<unknown>;
     /**
@@ -926,6 +938,8 @@ export type TextGenerationOptions = {
     conversationMemoryConfig?: Partial<ConversationMemoryConfig>;
     originalPrompt?: string;
     middleware?: MiddlewareFactoryOptions;
+    onFinish?: OnFinishCallback;
+    onError?: OnErrorCallback;
     expectedOutcome?: string;
     evaluationCriteria?: string[];
     csvOptions?: {

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

@@ -30,6 +30,7 @@ export * from "./guardrails.js";
 export * from "./hitl.js";
 export * from "./mcp.js";
 export * from "./mcpOutput.js";
+export * from "./memory.js";
 export * from "./middleware.js";
 export * from "./model.js";
 export * from "./multimodal.js";

package/dist/lib/types/index.js

@@ -31,6 +31,7 @@ export * from "./guardrails.js";
 export * from "./hitl.js";
 export * from "./mcp.js";
 export * from "./mcpOutput.js";
+export * from "./memory.js";
 export * from "./middleware.js";
 export * from "./model.js";
 export * from "./multimodal.js";

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

@@ -0,0 +1,96 @@
+/**
+ * Local structural types for the optional @juspay/hippocampus integration.
+ *
+ * These mirror the public shapes that ship with @juspay/hippocampus's
+ * `dist/types.d.ts` so NeuroLink's public type surface stays compatible
+ * for consumers that already configure memory, while the runtime package
+ * itself becomes an optional peer dependency. The previous setup (a hard
+ * value import of @juspay/hippocampus) made pnpm pull a registry copy of
+ * @juspay/neurolink to satisfy Hippocampus's peer, which transitively
+ * dragged @ai-sdk/google + @ai-sdk/google-vertex into the production
+ * dependency graph.
+ *
+ * Naming:
+ *  - Hippocampus's own `StorageType` and `RedisStorageConfig` collide with
+ *    NeuroLink's in-house Redis manager types in `common.ts` /
+ *    `conversation.ts`. To satisfy the `unique-type-names` ESLint rule,
+ *    the storage variants get a `Memory*` prefix here.
+ *  - `HippocampusMemory` (consumer-facing) and `StorageConfig` (legacy
+ *    re-export) keep their original public names — only their definitions
+ *    move from `import("@juspay/hippocampus").Foo` to local structural form.
+ */
+export type MemorySqliteStorageConfig = {
+    type: "sqlite";
+    /** Path to SQLite file. Default: ./data/hippocampus.sqlite */
+    path?: string;
+};
+export type MemoryRedisStorageConfig = {
+    type: "redis";
+    host?: string;
+    port?: number;
+    password?: string;
+    db?: number;
+    keyPrefix?: string;
+    ttl?: number;
+};
+export type MemoryS3StorageConfig = {
+    type: "s3";
+    bucket: string;
+    prefix?: string;
+};
+export type MemoryCustomStorageConfig = {
+    type: "custom";
+    onGet: (ownerId: string) => Promise<string | null>;
+    onSet: (ownerId: string, memory: string) => Promise<void>;
+    onDelete: (ownerId: string) => Promise<void>;
+    onClose?: () => Promise<void>;
+};
+/**
+ * Storage configuration accepted by the optional Hippocampus client.
+ * Re-exported with the legacy `StorageConfig` name from `conversation.ts`
+ * to preserve the existing public type surface.
+ */
+export type HippocampusStorageConfig = MemorySqliteStorageConfig | MemoryRedisStorageConfig | MemoryS3StorageConfig | MemoryCustomStorageConfig;
+/** Per-call options accepted by `Hippocampus.add`. */
+export type HippocampusAddOptions = {
+    prompt?: string;
+    maxWords?: number;
+};
+/** Constructor config accepted by the Hippocampus class. */
+export type HippocampusConfig = {
+    storage?: HippocampusStorageConfig;
+    prompt?: string;
+    neurolink?: {
+        provider?: string;
+        model?: string;
+        temperature?: number;
+    };
+    maxWords?: number;
+};
+/**
+ * Subset of the @juspay/hippocampus client surface that NeuroLink core
+ * actually calls. Defining this locally lets the initializer / SDK code
+ * avoid a value or even a type import from the optional package.
+ */
+export type HippocampusLike = {
+    add: (ownerId: string, content: string, options?: HippocampusAddOptions) => Promise<string>;
+    get: (ownerId: string) => Promise<string | null>;
+    delete: (ownerId: string) => Promise<void>;
+    close: () => Promise<void>;
+};
+/**
+ * Consumer-facing memory config. Same shape as before — the `enabled`
+ * flag toggles activation while the rest is passed straight through to
+ * the Hippocampus constructor when the optional package is installed.
+ */
+export type HippocampusMemory = HippocampusConfig & {
+    enabled?: boolean;
+};
+/**
+ * Shape of the dynamically-required `@juspay/hippocampus` module surface
+ * that NeuroLink's lazy initializer reaches for. Only the constructor is
+ * surfaced here; the rest of the module is irrelevant to core.
+ */
+export type HippocampusModule = {
+    Hippocampus: new (config?: HippocampusConfig) => HippocampusLike;
+};

package/dist/lib/types/memory.js

@@ -0,0 +1,23 @@
+/**
+ * Local structural types for the optional @juspay/hippocampus integration.
+ *
+ * These mirror the public shapes that ship with @juspay/hippocampus's
+ * `dist/types.d.ts` so NeuroLink's public type surface stays compatible
+ * for consumers that already configure memory, while the runtime package
+ * itself becomes an optional peer dependency. The previous setup (a hard
+ * value import of @juspay/hippocampus) made pnpm pull a registry copy of
+ * @juspay/neurolink to satisfy Hippocampus's peer, which transitively
+ * dragged @ai-sdk/google + @ai-sdk/google-vertex into the production
+ * dependency graph.
+ *
+ * Naming:
+ *  - Hippocampus's own `StorageType` and `RedisStorageConfig` collide with
+ *    NeuroLink's in-house Redis manager types in `common.ts` /
+ *    `conversation.ts`. To satisfy the `unique-type-names` ESLint rule,
+ *    the storage variants get a `Memory*` prefix here.
+ *  - `HippocampusMemory` (consumer-facing) and `StorageConfig` (legacy
+ *    re-export) keep their original public names — only their definitions
+ *    move from `import("@juspay/hippocampus").Foo` to local structural form.
+ */
+export {};
+//# sourceMappingURL=memory.js.map

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

@@ -703,6 +703,15 @@ export type GenAIModelsAPI = {
         }>;
         config?: Record<string, unknown>;
     }) => Promise<GenAIGenerateContentResponse>;
+    embedContent: (params: {
+        model: string;
+        contents: string | string[];
+        config?: Record<string, unknown>;
+    }) => Promise<{
+        embeddings?: Array<{
+            values?: number[];
+        }>;
+    }>;
 };
 /**
  * Google AI client interface
@@ -713,17 +722,52 @@ export type GenAIClient = {
     };
     models: GenAIModelsAPI;
 };
+/**
+ * HTTP options for Google GenAI SDK
+ * Allows custom fetch implementation for proxy support
+ */
+export type GoogleGenAIHttpOptions = {
+    /** Custom fetch implementation for proxy support */
+    fetch?: typeof fetch;
+};
 /**
  * Google GenAI constructor type
  * Supports both API key (Google AI Studio) and Vertex AI configurations
  */
 export type GoogleGenAIClass = new (cfg: {
     apiKey: string;
+    httpOptions?: GoogleGenAIHttpOptions;
 } | {
     vertexai: boolean;
     project: string;
     location: string;
+    httpOptions?: GoogleGenAIHttpOptions;
 }) => GenAIClient;
+/**
+ * Google Vertex AI provider settings for native SDK configuration
+ * Used with @google/genai SDK in vertexai mode
+ *
+ * Note: Authentication is handled via environment variables (GOOGLE_APPLICATION_CREDENTIALS)
+ * or the temporary credentials file approach, not through these settings fields.
+ */
+export type GoogleVertexProviderSettings = {
+    /** Google Cloud project ID */
+    project: string;
+    /** Google Cloud region/location (e.g., 'us-central1') */
+    location: string;
+    /** Optional custom fetch implementation */
+    fetch?: typeof fetch;
+};
+/**
+ * Anthropic Vertex AI settings for Claude models on Vertex
+ * Used with @anthropic-ai/vertex-sdk
+ */
+export type AnthropicVertexSettings = {
+    /** Google Cloud project ID */
+    projectId: string;
+    /** Google Cloud region for Anthropic models (e.g., 'us-east5') */
+    region: string;
+};
 /**
  * OpenAI-compatible models endpoint response structure
  */
@@ -1499,8 +1543,8 @@ export type ToolWithLegacyParams = {
  * factory functions.
  */
 export type ProviderConstructor = {
-    new (modelName?: string, providerName?: string, sdk?: UnknownRecord, region?: string): AIProvider;
-} | ((modelName?: string, providerName?: string, sdk?: UnknownRecord, region?: string) => Promise<AIProvider>);
+    new (modelName?: string, providerName?: string, sdk?: UnknownRecord, region?: string, credentials?: UnknownRecord): AIProvider;
+} | ((modelName?: string, providerName?: string, sdk?: UnknownRecord, region?: string, credentials?: UnknownRecord) => Promise<AIProvider>);
 /** Provider registration entry held by ProviderFactory. */
 export type ProviderRegistration = {
     constructor: ProviderConstructor;
@@ -1603,6 +1647,9 @@ export type GoogleLiveAudioQueueItem = {
 /**
  * Single part inside a Google Vertex "native" (non-AI-SDK) generateContent
  * payload — either inline text or an inline base64 data blob.
+ *
+ * Despite the "Vertex" prefix, the shape is identical for the Google AI
+ * Studio native path (`@google/genai` SDK), so AI Studio re-uses this type.
  */
 export type VertexNativePart = {
     text: string;
@@ -1612,6 +1659,21 @@ export type VertexNativePart = {
         data: string;
     };
 };
+/**
+ * Subset of `GenerateOptions["input"]` consumed by the shared Gemini-native
+ * multimodal-parts builder. Kept narrow so the helper doesn't depend on the
+ * full `GenerateOptions` shape. The `images` field mirrors the public
+ * `GenerateOptions["input"].images` shape so the helper accepts the same
+ * value SDK callers pass in (plain Buffer/string or `ImageWithAltText`).
+ */
+export type GeminiMultimodalInput = {
+    text?: string;
+    pdfFiles?: Array<Buffer | string>;
+    images?: Array<Buffer | string | {
+        data: Buffer | string;
+        altText?: string;
+    }>;
+};
 /**
  * Internal helpers used by the conversation-history builder in
  * providers/googleVertex.ts to merge interleaved tool call / result turns.
@@ -1627,3 +1689,79 @@ export type VertexRegularSegment = {
     parts: unknown[];
 };
 export type VertexSegment = VertexToolStep | VertexRegularSegment;
+/**
+ * Function declaration shape accepted by the @google/genai SDK when tools are
+ * attached to a Vertex generateContent call.
+ */
+export type VertexGenaiFunctionDeclaration = {
+    name: string;
+    description: string;
+    parametersJsonSchema?: Record<string, unknown>;
+};
+/**
+ * Message payload passed to the Anthropic Vertex SDK — mirrors the Anthropic
+ * Messages API shape (role + structured content blocks).
+ */
+export type VertexAnthropicMessage = {
+    role: "user" | "assistant";
+    content: string | Array<{
+        type: "text";
+        text: string;
+    } | {
+        type: "image";
+        source: {
+            type: "base64";
+            media_type: string;
+            data: string;
+        };
+    } | {
+        type: "document";
+        source: {
+            type: "base64";
+            media_type: string;
+            data: string;
+        };
+    } | {
+        type: "tool_use";
+        id: string;
+        name: string;
+        input: unknown;
+    } | {
+        type: "tool_result";
+        tool_use_id: string;
+        content: string;
+    } | {
+        type: "thinking";
+        thinking: string;
+    } | {
+        type: "redacted_thinking";
+        data: string;
+    }>;
+};
+/** Tool definition accepted by the Anthropic Vertex SDK. */
+export type VertexAnthropicTool = {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties?: Record<string, unknown>;
+        required?: string[];
+    };
+};
+/**
+ * Content block variants returned by the Anthropic Vertex SDK during streaming
+ * and generation — used to narrow responses before handing tool calls back.
+ */
+export type VertexAnthropicContentBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+} | {
+    type: "tool_result";
+    tool_use_id: string;
+    content: string;
+};

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

@@ -314,6 +314,12 @@ export type StreamOptions = {
     region?: string;
     temperature?: number;
     maxTokens?: number;
+    /** Top-p (nucleus) sampling parameter. Controls diversity of generated tokens. */
+    topP?: number;
+    /** Top-k sampling parameter. Limits the number of tokens considered. (Google/Gemini models only) */
+    topK?: number;
+    /** Stop sequences that will halt generation when encountered. */
+    stopSequences?: string[];
     systemPrompt?: string;
     schema?: ValidationSchema;
     tools?: Record<string, Tool>;

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

@@ -0,0 +1,13 @@
+/**
+ * Dedupes per-error invocations of the user-supplied `onError` lifecycle
+ * callback. The same thrown error can travel through both the middleware
+ * pipeline (which fires `onError` then re-throws) and the top-level
+ * generate/stream catch in `neurolink.ts` — without a guard, the consumer
+ * callback would fire twice for one logical failure.
+ *
+ * Strategy: stamp a non-enumerable Symbol on the error object the first
+ * time a firing site is reached, skip subsequent firings. Symbol.for
+ * lets us share the same key across modules without import gymnastics.
+ */
+import type { LifecycleErrorPayload, OnErrorCallback } from "../types/index.js";
+export declare function fireOnErrorOnce(onError: OnErrorCallback | undefined, error: unknown, payload: LifecycleErrorPayload): void;

package/dist/lib/utils/lifecycleCallbacks.js

@@ -0,0 +1,44 @@
+/**
+ * Dedupes per-error invocations of the user-supplied `onError` lifecycle
+ * callback. The same thrown error can travel through both the middleware
+ * pipeline (which fires `onError` then re-throws) and the top-level
+ * generate/stream catch in `neurolink.ts` — without a guard, the consumer
+ * callback would fire twice for one logical failure.
+ *
+ * Strategy: stamp a non-enumerable Symbol on the error object the first
+ * time a firing site is reached, skip subsequent firings. Symbol.for
+ * lets us share the same key across modules without import gymnastics.
+ */
+const ON_ERROR_FIRED = Symbol.for("neurolink.onErrorFired");
+export function fireOnErrorOnce(onError, error, payload) {
+    if (typeof onError !== "function") {
+        return;
+    }
+    if (error && typeof error === "object") {
+        const errAsRecord = error;
+        if (errAsRecord[ON_ERROR_FIRED]) {
+            return;
+        }
+        try {
+            Object.defineProperty(error, ON_ERROR_FIRED, {
+                value: true,
+                enumerable: false,
+                writable: false,
+                configurable: false,
+            });
+        }
+        catch {
+            // Frozen/sealed error object — proceed without the stamp; the
+            // worst case is a single duplicate fire if multiple sites observe
+            // the same frozen value, which is the pre-existing behaviour.
+        }
+    }
+    try {
+        const result = onError(payload);
+        Promise.resolve(result).catch(() => undefined);
+    }
+    catch {
+        // Consumer callback errors must not poison the original throw.
+    }
+}
+//# sourceMappingURL=lifecycleCallbacks.js.map

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

@@ -17,6 +17,16 @@ export declare function convertToModelMessages(messages: MultimodalChatMessage[]
  * Enhanced with CSV file processing support
  */
 export declare function buildMessagesArray(options: TextGenerationOptions | StreamOptions): Promise<ModelMessage[]>;
+/**
+ * Process the unified files array with auto-detection.
+ * Handles lazy file registration, full processing, and preview injection.
+ *
+ * Exported so providers that bypass BaseProvider.generate() (e.g.
+ * GoogleVertex's native @google/genai path) can still preprocess
+ * `input.files` — without this, mimetype-hint and text-file inputs
+ * would silently never reach the model on those paths.
+ */
+export declare function processUnifiedFilesArray(options: GenerateOptions, maxSize: number, provider: string): Promise<void>;
 /**
  * Build multimodal message array with image support
  * Detects when images are present and routes through provider adapter

package/dist/lib/utils/messageBuilder.js

@@ -534,8 +534,13 @@ export async function buildMessagesArray(options) {
                             csvSection += metadataText + `\n\n`;
                         }
                     }
-                    csvSection += buildCSVToolInstructions(filePath);
+                    // Put the actual CSV content BEFORE the tool instructions —
+                    // buildCSVToolInstructions references "the CSV data shown above"
+                    // and the trailing position keeps that reference accurate.
+                    // Vertex Gemini misreads CSV-only prompts as "no files attached"
+                    // when the NOTE-then-data order makes the reference dangle.
                     csvSection += result.content;
+                    csvSection += buildCSVToolInstructions(filePath);
                     csvContent += csvSection;
                     logger.info(`[CSV] ✅ Processed: ${filename}`, result.metadata);
                 }
@@ -664,8 +669,11 @@ function appendDetectedFileResult(result, file, options) {
                 csvSection += metadataText + `\n\n`;
             }
         }
-        csvSection += buildCSVToolInstructions(filePath);
+        // Put the actual CSV content BEFORE the tool instructions —
+        // buildCSVToolInstructions references "the CSV data shown above" and
+        // the trailing position keeps that reference accurate.
         csvSection += result.content;
+        csvSection += buildCSVToolInstructions(filePath);
         options.input.text += csvSection;
         logger.info(`[FileDetector] ✅ CSV: ${filename}`);
     }
@@ -771,8 +779,13 @@ function appendDetectedFileResult(result, file, options) {
 /**
  * Process the unified files array with auto-detection.
  * Handles lazy file registration, full processing, and preview injection.
+ *
+ * Exported so providers that bypass BaseProvider.generate() (e.g.
+ * GoogleVertex's native @google/genai path) can still preprocess
+ * `input.files` — without this, mimetype-hint and text-file inputs
+ * would silently never reach the model on those paths.
  */
-async function processUnifiedFilesArray(options, maxSize, provider) {
+export async function processUnifiedFilesArray(options, maxSize, provider) {
     if (!options.input.files || options.input.files.length === 0) {
         return;
     }
@@ -864,6 +877,24 @@ async function processUnifiedFilesArray(options, maxSize, provider) {
             }
         }
         logger.info(`[NEUROLINK] File processing complete: ${includedCount}/${totalFiles} files included in message`);
+        // Augment options.systemPrompt with file-handling guidance so providers
+        // that bypass the message-builder's system message and read
+        // `options.systemPrompt` directly (e.g. GoogleVertex's native @google/genai
+        // path uses `config.systemInstruction = options.systemPrompt`) still see
+        // the "treat inlined CSV/PDF as the actual file" guidance. Without this,
+        // Vertex Gemini 2.5 reliably responds with "no files attached" even
+        // though the CSV content is fully embedded in the user prompt.
+        if (includedCount > 0) {
+            const filePromptAugmentation = `\n\nIMPORTANT FILE HANDLING INSTRUCTIONS:
+- The full content of the user's local file(s) is INLINED in this message under "## CSV Data from ..." / "## PDF Data from ..." / "## File: ..." headings — it is the actual file the user is asking about.
+- TREAT THE INLINED CONTENT AS IF IT WERE AN ATTACHMENT. Do NOT respond with "no files attached" or ask the user to re-upload — the data is already here.
+- DO NOT use GitHub tools (get_file_contents, search_code, etc.) for local files - they only work for remote repository files.
+- Analyze the inlined file content directly without attempting to fetch or read files using tools.`;
+            const existingSystem = (options.systemPrompt || "").trim();
+            options.systemPrompt = existingSystem
+                ? `${existingSystem}${filePromptAugmentation}`
+                : filePromptAugmentation.trim();
+        }
     });
 }
 /**
@@ -891,8 +922,11 @@ async function processExplicitCsvFiles(options) {
                     csvSection += metadataText + `\n\n`;
                 }
             }
-            csvSection += buildCSVToolInstructions(filePath);
+            // Put the actual CSV content BEFORE the tool instructions —
+            // buildCSVToolInstructions references "the CSV data shown above"
+            // and the trailing position keeps that reference accurate.
             csvSection += result.content;
+            csvSection += buildCSVToolInstructions(filePath);
             options.input.text += csvSection;
             logger.info(`[CSV] ✅ Processed: ${filename}`);
         }
@@ -1001,7 +1035,8 @@ function buildMultimodalSystemPrompt(options, hasPDFFiles) {
             fileTypes.push("CSVs");
         }
         systemPrompt += `\n\nIMPORTANT FILE HANDLING INSTRUCTIONS:
-- File content (${fileTypes.join(", ")}, images) is already processed and included in this message
+- The full content of the user's local ${fileTypes.join(", ")} (and any images) is INLINED in this message under the "## CSV Data from ..." / "## PDF Data from ..." headings — it is the actual file the user is asking about.
+- TREAT THE INLINED CONTENT AS IF IT WERE AN ATTACHMENT. Do NOT respond with "no files attached" or ask the user to re-upload — the data is already here.
 - DO NOT use GitHub tools (get_file_contents, search_code, etc.) for local files - they only work for remote repository files
 - Analyze the provided file content directly without attempting to fetch or read files using tools
 - GitHub MCP tools are ONLY for remote repository operations, not local filesystem access

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

@@ -7,3 +7,14 @@ export declare function supportsThinkingConfig(modelName: string): boolean;
 export declare function supportsPromptCaching(modelName: string): boolean;
 export declare function getMaxThinkingBudgetTokens(modelName: string): number;
 export declare function getModelFamily(modelName: string): string;
+/**
+ * Check if a model has restricted output token limit (32768 max)
+ * This applies to:
+ * - All Gemini 3 models (gemini-3-flash, gemini-3-pro, etc.)
+ * - Image generation models (gemini-2.5-flash-image, gemini-3-pro-image-preview)
+ */
+export declare function hasRestrictedOutputLimit(modelName: string): boolean;
+/**
+ * Get the max output tokens for a model (32768 for restricted models)
+ */
+export declare const RESTRICTED_OUTPUT_TOKEN_LIMIT = 32768;