@juspay/neurolink 12.38.1 → 12.39.1

package/dist/providers/googleNativeGemini3/utils.d.ts

@@ -8,7 +8,7 @@
  * This module extracts the functions that are duplicated between the two
  * providers so they can share a single implementation.
  */
-import type { GenerateStopReason, ThinkingConfig, AgenticLoopOptions, ChatMessage, CollectedChunkResult, MinimalChatMessage, NativeFunctionCall, NativeFunctionResponse, NativeToolDeclarationsResult, NativeToolsConfig, StreamChannel, VertexNativePart, GeminiMultimodalInput, MultimodalAudioEntry, MultimodalVideoEntry } from "../../types/index.js";
+import type { GenerateStopReason, ThinkingConfig, AgenticLoopOptions, ChatMessage, CollectedChunkResult, MinimalChatMessage, NativeFunctionCall, NativeFunctionResponse, NativeToolDeclarationsResult, NativeToolsConfig, StreamChannel, VertexNativePart, GeminiMultimodalInput, MultimodalAudioEntry, MultimodalVideoEntry, ModelMessage } from "../../types/index.js";
 import type { Tool, ToolExecutionGuards } from "../../types/index.js";
 /**
  * A per-turn tool execute map that deduplicates identical tool calls.
@@ -66,6 +66,13 @@ export declare function refreshNativeToolDeclarations(liveTools: Record<string,
  */
 export declare function buildNativeConfig(options: {
     temperature?: number;
+    /**
+     * Nucleus sampling. Subject to the same registry-driven
+     * sampling-param strip as `temperature` — a model that rejects
+     * classic sampling params (see `SAMPLING_PARAM_REJECTING_FAMILIES`)
+     * gets neither on the wire.
+     */
+    topP?: number;
     maxTokens?: number;
     systemPrompt?: string;
     /**
@@ -421,6 +428,42 @@ export declare function prependConversationMessages(contents: Array<{
     role: string;
     parts: unknown[];
 }>, conversationMessages?: Array<ChatMessage | MinimalChatMessage>): void;
+/**
+ * Convert a native Gemini `contents` array (the shape this module builds and
+ * `prependConversationMessages` emits) into the generic V3 prompt shape that
+ * caller model middleware operates on.
+ *
+ * Gemini has no wire-visible `system` role — `systemInstruction` rides
+ * separately on `config` — so this only ever emits `user` / `assistant` /
+ * `tool` messages. A `functionResponse`-only `user` entry becomes a V3
+ * `tool` message rather than `user`: `UserModelMessage.content` cannot carry
+ * a `ToolResultPart`, only `ToolModelMessage.content` can, and that grouping
+ * (a `model` turn of `functionCall` parts followed by a `user` turn of
+ * matching `functionResponse` parts) is exactly what
+ * `prependConversationMessages` above produces.
+ */
+export declare function geminiContentsToV3Prompt(contents: Array<{
+    role: string;
+    parts: unknown[];
+}>): ModelMessage[];
+/**
+ * Reverse of `geminiContentsToV3Prompt`: rebuild a native Gemini `contents`
+ * array from a (possibly middleware-rewritten) V3 prompt. A `system`
+ * message has no `contents` entry of its own — Gemini carries it on
+ * `config.systemInstruction` — so its text is returned separately
+ * (`systemText`) and the caller folds it into the request config.
+ *
+ * The synthesized `toolCallId` from the forward direction is intentionally
+ * discarded: Gemini pairs a call to its result by position, not by id, so
+ * reconstruction only needs `{name, args}` / `{name, response}`.
+ */
+export declare function v3PromptToGeminiContents(prompt: ModelMessage[]): {
+    contents: Array<{
+        role: string;
+        parts: unknown[];
+    }>;
+    systemText?: string;
+};
 /**
  * Build the `parts` array for the current user turn of a Gemini native
  * `generateContent` request, including inline image + PDF blobs.

package/dist/providers/googleNativeGemini3/utils.js

@@ -422,12 +422,15 @@ export function refreshNativeToolDeclarations(liveTools, current) {
 export function buildNativeConfig(options, toolsConfig) {
     // Registry-driven sampling strip applied for uniformity with every other
     // provider path (inert for current Gemini models).
-    const samplingParams = resolveSamplingParams("google-ai", options.model, { temperature: options.temperature ?? 1.0 }, // Gemini 3 requires 1.0 for tool calling
+    const samplingParams = resolveSamplingParams("google-ai", options.model, { temperature: options.temperature ?? 1.0, topP: options.topP }, // Gemini 3 requires 1.0 for tool calling
     "googleAiStudio.buildNativeConfig");
     const config = {
         ...(samplingParams.temperature !== undefined && {
             temperature: samplingParams.temperature,
         }),
+        ...(samplingParams.topP !== undefined && {
+            topP: samplingParams.topP,
+        }),
         maxOutputTokens: options.maxTokens,
     };
     if (toolsConfig) {
@@ -1306,6 +1309,302 @@ conversationMessages) {
         }
     }
 }
+// ── Gemini contents ↔ V3 prompt conversion ──
+//
+// Caller model middleware (transformParams / wrapGenerate / wrapStream)
+// operates on the generic `ModelMessage[]` prompt shape, not on Gemini's
+// native `contents`. These two functions are the boundary: the native
+// stream/generate loops build `contents` exactly as they always have, hand
+// it through `geminiContentsToV3Prompt` before invoking middleware, and
+// rebuild `contents` from whatever prompt the middleware settled on via
+// `v3PromptToGeminiContents`.
+function hasTextField(part) {
+    if (typeof part !== "object" || part === null || !("text" in part)) {
+        return false;
+    }
+    return typeof part.text === "string";
+}
+function hasInlineDataField(part) {
+    if (typeof part !== "object" || part === null || !("inlineData" in part)) {
+        return false;
+    }
+    const inline = part.inlineData;
+    return (typeof inline === "object" &&
+        inline !== null &&
+        "mimeType" in inline &&
+        "data" in inline);
+}
+function hasFunctionCallField(part) {
+    return typeof part === "object" && part !== null && "functionCall" in part;
+}
+function hasFunctionResponseField(part) {
+    return (typeof part === "object" && part !== null && "functionResponse" in part);
+}
+function readThoughtSignature(part) {
+    if (typeof part !== "object" ||
+        part === null ||
+        !("thoughtSignature" in part)) {
+        return undefined;
+    }
+    return typeof part.thoughtSignature === "string"
+        ? part.thoughtSignature
+        : undefined;
+}
+function withThoughtSignature(part, thoughtSignature) {
+    if (!thoughtSignature) {
+        return part;
+    }
+    return {
+        ...part,
+        providerOptions: {
+            ...part.providerOptions,
+            googleAiStudio: {
+                ...part.providerOptions?.googleAiStudio,
+                thoughtSignature,
+            },
+        },
+    };
+}
+function readProviderThoughtSignature(providerOptions) {
+    if (typeof providerOptions !== "object" || providerOptions === null) {
+        return undefined;
+    }
+    const studio = providerOptions.googleAiStudio;
+    if (typeof studio !== "object" || studio === null) {
+        return undefined;
+    }
+    const sig = studio.thoughtSignature;
+    return typeof sig === "string" ? sig : undefined;
+}
+function isFunctionResponseOnlyEntry(parts) {
+    return parts.length > 0 && parts.every(hasFunctionResponseField);
+}
+function toV3ToolResultPart(part) {
+    if (!hasFunctionResponseField(part)) {
+        return undefined;
+    }
+    return {
+        type: "tool-result",
+        // Gemini pairs a function response to its call by position, not by id —
+        // nothing downstream of this conversion reads this value back.
+        toolCallId: `gemini-tool-${randomUUID()}`,
+        toolName: part.functionResponse.name,
+        output: part.functionResponse.response,
+    };
+}
+function toV3UserPart(part) {
+    if (hasTextField(part)) {
+        return withThoughtSignature({ type: "text", text: part.text }, readThoughtSignature(part));
+    }
+    if (hasInlineDataField(part)) {
+        return {
+            type: "file",
+            data: part.inlineData.data,
+            mediaType: part.inlineData.mimeType,
+        };
+    }
+    return undefined;
+}
+function toV3AssistantPart(part) {
+    if (hasTextField(part)) {
+        return withThoughtSignature({ type: "text", text: part.text }, readThoughtSignature(part));
+    }
+    if (hasFunctionCallField(part)) {
+        return withThoughtSignature({
+            type: "tool-call",
+            toolCallId: `gemini-tool-${randomUUID()}`,
+            toolName: part.functionCall.name,
+            input: part.functionCall.args ?? {},
+        }, part.thoughtSignature);
+    }
+    return undefined;
+}
+/**
+ * Convert a native Gemini `contents` array (the shape this module builds and
+ * `prependConversationMessages` emits) into the generic V3 prompt shape that
+ * caller model middleware operates on.
+ *
+ * Gemini has no wire-visible `system` role — `systemInstruction` rides
+ * separately on `config` — so this only ever emits `user` / `assistant` /
+ * `tool` messages. A `functionResponse`-only `user` entry becomes a V3
+ * `tool` message rather than `user`: `UserModelMessage.content` cannot carry
+ * a `ToolResultPart`, only `ToolModelMessage.content` can, and that grouping
+ * (a `model` turn of `functionCall` parts followed by a `user` turn of
+ * matching `functionResponse` parts) is exactly what
+ * `prependConversationMessages` above produces.
+ */
+export function geminiContentsToV3Prompt(contents) {
+    const messages = [];
+    for (const entry of contents) {
+        const parts = Array.isArray(entry.parts) ? entry.parts : [];
+        if (entry.role === "user" && isFunctionResponseOnlyEntry(parts)) {
+            const content = parts
+                .map(toV3ToolResultPart)
+                .filter((p) => p !== undefined);
+            if (content.length > 0) {
+                messages.push({ role: "tool", content });
+            }
+            continue;
+        }
+        if (entry.role === "user") {
+            const content = parts
+                .map(toV3UserPart)
+                .filter((p) => p !== undefined);
+            if (content.length > 0) {
+                messages.push({ role: "user", content });
+            }
+            continue;
+        }
+        if (entry.role === "model") {
+            const content = parts
+                .map(toV3AssistantPart)
+                .filter((p) => p !== undefined);
+            if (content.length > 0) {
+                messages.push({ role: "assistant", content });
+            }
+        }
+    }
+    return messages;
+}
+function dataContentToBase64(data) {
+    if (typeof data === "string") {
+        return data;
+    }
+    if (Buffer.isBuffer(data)) {
+        return data.toString("base64");
+    }
+    if (data instanceof ArrayBuffer) {
+        return Buffer.from(data).toString("base64");
+    }
+    return Buffer.from(data.buffer, data.byteOffset, data.byteLength).toString("base64");
+}
+function userContentToGeminiParts(content) {
+    if (typeof content === "string") {
+        return content.length > 0 ? [{ text: content }] : [];
+    }
+    const parts = [];
+    for (const part of content) {
+        if (part.type === "text") {
+            if (part.text.length > 0) {
+                const sig = readProviderThoughtSignature(part.providerOptions);
+                parts.push(sig
+                    ? { text: part.text, thoughtSignature: sig }
+                    : { text: part.text });
+            }
+        }
+        else if (part.type === "image" && !(part.image instanceof URL)) {
+            parts.push({
+                inlineData: {
+                    mimeType: part.mediaType ?? "application/octet-stream",
+                    data: dataContentToBase64(part.image),
+                },
+            });
+        }
+        else if (part.type === "file" && !(part.data instanceof URL)) {
+            parts.push({
+                inlineData: {
+                    mimeType: part.mediaType,
+                    data: dataContentToBase64(part.data),
+                },
+            });
+        }
+    }
+    return parts;
+}
+function assistantContentToGeminiParts(content) {
+    if (typeof content === "string") {
+        return content.length > 0 ? [{ text: content }] : [];
+    }
+    const parts = [];
+    for (const part of content) {
+        if (part.type === "text") {
+            if (part.text.length > 0) {
+                const sig = readProviderThoughtSignature(part.providerOptions);
+                parts.push(sig
+                    ? { text: part.text, thoughtSignature: sig }
+                    : { text: part.text });
+            }
+        }
+        else if (part.type === "tool-call") {
+            const sig = readProviderThoughtSignature(part.providerOptions);
+            const call = {
+                functionCall: {
+                    name: part.toolName,
+                    args: (part.input ?? {}),
+                },
+            };
+            if (sig) {
+                call.thoughtSignature = sig;
+            }
+            parts.push(call);
+        }
+        // `reasoning` / `file` / `tool-result` / `tool-approval-request` parts on
+        // an assistant message have no native Gemini wire shape and are dropped
+        // — this path never emitted them into `contents` before this conversion
+        // existed either.
+    }
+    return parts;
+}
+function toolContentToGeminiParts(content) {
+    const parts = [];
+    for (const item of content) {
+        if (item.type === "tool-result") {
+            parts.push({
+                functionResponse: {
+                    name: item.toolName,
+                    response: item.output && typeof item.output === "object"
+                        ? item.output
+                        : { result: item.output },
+                },
+            });
+        }
+    }
+    return parts;
+}
+/**
+ * Reverse of `geminiContentsToV3Prompt`: rebuild a native Gemini `contents`
+ * array from a (possibly middleware-rewritten) V3 prompt. A `system`
+ * message has no `contents` entry of its own — Gemini carries it on
+ * `config.systemInstruction` — so its text is returned separately
+ * (`systemText`) and the caller folds it into the request config.
+ *
+ * The synthesized `toolCallId` from the forward direction is intentionally
+ * discarded: Gemini pairs a call to its result by position, not by id, so
+ * reconstruction only needs `{name, args}` / `{name, response}`.
+ */
+export function v3PromptToGeminiContents(prompt) {
+    const contents = [];
+    const systemChunks = [];
+    for (const message of prompt) {
+        if (message.role === "system") {
+            if (message.content.length > 0) {
+                systemChunks.push(message.content);
+            }
+            continue;
+        }
+        if (message.role === "user") {
+            const parts = userContentToGeminiParts(message.content);
+            if (parts.length > 0) {
+                contents.push({ role: "user", parts });
+            }
+            continue;
+        }
+        if (message.role === "assistant") {
+            const parts = assistantContentToGeminiParts(message.content);
+            if (parts.length > 0) {
+                contents.push({ role: "model", parts });
+            }
+            continue;
+        }
+        const parts = toolContentToGeminiParts(message.content);
+        if (parts.length > 0) {
+            contents.push({ role: "user", parts });
+        }
+    }
+    return systemChunks.length > 0
+        ? { contents, systemText: systemChunks.join("\n\n") }
+        : { contents };
+}
 /**
  * Build the `parts` array for the current user turn of a Gemini native
  * `generateContent` request, including inline image + PDF blobs.

package/dist/types/providerCatalog.generated.d.ts

@@ -1,2 +1,2 @@
-export type CatalogProviderName = "api-route" | "baseten" | "cerebras" | "cloudflare" | "deepseek" | "fireworks" | "friendli" | "gmicloud" | "groq" | "huggingface" | "inception-labs" | "io-intelligence" | "mancer" | "mistral" | "morph" | "novita" | "perplexity" | "sambanova" | "together-ai" | "upstage" | "xai";
-export type CatalogCredentialKey = "apiRoute" | "baseten" | "cerebras" | "cloudflare" | "deepseek" | "fireworks" | "friendli" | "gmicloud" | "groq" | "huggingFace" | "inceptionLabs" | "ioIntelligence" | "mancer" | "mistral" | "morph" | "novita" | "perplexity" | "sambanova" | "together" | "upstage" | "xai";
+export type CatalogProviderName = "above-dev" | "aiand" | "ambient" | "api-route" | "baseten" | "bee-heossi" | "cerebras" | "charm-hyper" | "chutes" | "cloudflare" | "deepinfra" | "deepseek" | "empiriolabs" | "featherless-ai" | "fireworks" | "friendli" | "gmicloud" | "groq" | "huggingface" | "inception-labs" | "inco" | "inference-net" | "io-intelligence" | "koscompute" | "lilac" | "llmtech" | "mancer" | "mistral" | "moark" | "morph" | "neuralwatt" | "novita" | "ovhcloud" | "pareto-inference" | "perplexity" | "sambanova" | "sarvam" | "synthetic" | "together-ai" | "upstage" | "xai";
+export type CatalogCredentialKey = "aboveDev" | "aiand" | "ambient" | "apiRoute" | "baseten" | "beeHeossi" | "cerebras" | "charmHyper" | "chutes" | "cloudflare" | "deepinfra" | "deepseek" | "empiriolabs" | "featherlessAi" | "fireworks" | "friendli" | "gmicloud" | "groq" | "huggingFace" | "inceptionLabs" | "inco" | "inferenceNet" | "ioIntelligence" | "koscompute" | "lilac" | "llmtech" | "mancer" | "mistral" | "moark" | "morph" | "neuralwatt" | "novita" | "ovhcloud" | "paretoInference" | "perplexity" | "sambanova" | "sarvam" | "synthetic" | "together" | "upstage" | "xai";

package/dist/types/providers.d.ts

@@ -172,6 +172,18 @@ export type NeurolinkCredentials = {
         apiKey?: string;
         baseURL?: string;
     };
+    aboveDev?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
+    aiand?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
+    ambient?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
     apiRoute?: {
         apiKey?: string;
         baseURL?: string;
@@ -180,19 +192,43 @@ export type NeurolinkCredentials = {
         apiKey?: string;
         baseURL?: string;
     };
+    beeHeossi?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
     cerebras?: {
         apiKey?: string;
         baseURL?: string;
     };
+    charmHyper?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
+    chutes?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
     cloudflare?: {
         apiKey?: string;
         baseURL?: string;
         accountId?: string;
     };
+    deepinfra?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
     deepseek?: {
         apiKey?: string;
         baseURL?: string;
     };
+    empiriolabs?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
+    featherlessAi?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
     fireworks?: {
         apiKey?: string;
         baseURL?: string;
@@ -217,10 +253,30 @@ export type NeurolinkCredentials = {
         apiKey?: string;
         baseURL?: string;
     };
+    inco?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
+    inferenceNet?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
     ioIntelligence?: {
         apiKey?: string;
         baseURL?: string;
     };
+    koscompute?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
+    lilac?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
+    llmtech?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
     mancer?: {
         apiKey?: string;
         baseURL?: string;
@@ -229,14 +285,30 @@ export type NeurolinkCredentials = {
         apiKey?: string;
         baseURL?: string;
     };
+    moark?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
     morph?: {
         apiKey?: string;
         baseURL?: string;
     };
+    neuralwatt?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
     novita?: {
         apiKey?: string;
         baseURL?: string;
     };
+    ovhcloud?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
+    paretoInference?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
     perplexity?: {
         apiKey?: string;
         baseURL?: string;
@@ -245,6 +317,14 @@ export type NeurolinkCredentials = {
         apiKey?: string;
         baseURL?: string;
     };
+    sarvam?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
+    synthetic?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
     together?: {
         apiKey?: string;
         baseURL?: string;