@xmem-ai/memcode 4.0.2

package/dist/services/api/nvidiaClient.js

@@ -0,0 +1,653 @@
+import { randomUUID } from "crypto";
+import { ThinkTagSplitter, splitThinkTags } from "./reasoning.js";
+const DEFAULT_NVIDIA_API_URL = "https://integrate.api.nvidia.com/v1";
+function getNvidiaApiUrl() {
+  return (process.env.NVIDIA_BASE_URL || process.env.NVIDIA_API_URL || DEFAULT_NVIDIA_API_URL).replace(/\/+$/, "");
+}
+function finishReason(reason) {
+  if (reason === "tool_calls") return "tool_use";
+  if (reason === "length") return "max_tokens";
+  if (reason === "stop") return "end_turn";
+  return reason ?? "end_turn";
+}
+function parseToolArguments(argumentsValue) {
+  if (argumentsValue && typeof argumentsValue === "object" && !Array.isArray(argumentsValue)) {
+    return argumentsValue;
+  }
+  if (typeof argumentsValue !== "string" || argumentsValue.trim() === "") {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(argumentsValue);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+const NVIDIA_MODEL_MAP = {
+  "nim-llama4": "meta/llama-4-maverick-17b-128e-instruct",
+  "nim-llama4-maverick": "meta/llama-4-maverick-17b-128e-instruct",
+  "nim-llama4-scout": "meta/llama-4-scout-17b-16e-instruct",
+  "nim-llama3": "meta/llama-3.3-70b-instruct",
+  "nim-llama3-70b": "meta/llama-3.3-70b-instruct",
+  "nim-llama3-8b": "meta/llama-3.1-8b-instruct",
+  "nim-kimi": "moonshotai/kimi-k2.6",
+  "nim-kimi-k2.6": "moonshotai/kimi-k2.6",
+  "nim-glm": "z-ai/glm-5.1",
+  "nim-glm-5.1": "z-ai/glm-5.1",
+  "nim-minimax": "minimaxai/minimax-m3",
+  "nim-minimax-m2.7": "minimaxai/minimax-m2.7",
+  "nim-minimax-m3": "minimaxai/minimax-m3",
+  "nim-deepseek": "deepseek-ai/deepseek-v4-flash",
+  "nim-deepseek-flash": "deepseek-ai/deepseek-v4-flash",
+  "nim-deepseek-pro": "deepseek-ai/deepseek-v4-pro",
+  "nim-qwen3": "qwen/qwen3.5-397b-a17b",
+  "nim-qwen3-coder": "qwen/qwen3-coder-480b-a35b-instruct",
+  "nim-qwen3-next": "qwen/qwen3-next-80b-a3b-instruct",
+  "nim-mistral": "mistralai/mistral-large-3-675b-instruct-2512",
+  "nim-mistral-large": "mistralai/mistral-large-3-675b-instruct-2512",
+  "nim-mistral-medium": "mistralai/mistral-medium-3.5-128b",
+  "nim-mistral-small": "mistralai/mistral-small-4-119b-2603",
+  "nim-mistral-nemotron": "mistralai/mistral-nemotron",
+  "nim-codestral": "mistralai/codestral-22b-instruct-v0.1",
+  "nim-nemotron": "nvidia/llama-3.3-nemotron-super-49b-v1",
+  "nim-nemotron-3-ultra": "nvidia/nemotron-3-ultra-550b-a55b",
+  "nim-nemotron-3-ultra-550b": "nvidia/nemotron-3-ultra-550b-a55b",
+  "nim-nemotron-3-ultra-550b-a55b": "nvidia/nemotron-3-ultra-550b-a55b",
+  "nim-nemotron-ultra": "nvidia/llama-3.1-nemotron-ultra-253b-v1",
+  "nim-nemotron-super": "nvidia/llama-3.3-nemotron-super-49b-v1",
+  "nim-nemotron-nano": "nvidia/llama-3.1-nemotron-nano-8b-v1",
+  "nim-nemotron-340b": "nvidia/nemotron-4-340b-instruct",
+  "nim-gemma4": "google/gemma-4-31b-it",
+  "nim-gemma3-12b": "google/gemma-3-12b-it",
+  "nim-codegemma": "google/codegemma-7b",
+  "nim-phi4": "microsoft/phi-4-mini-instruct",
+  "nim-gpt-oss": "openai/gpt-oss-120b",
+  "nim-gpt-oss-20b": "openai/gpt-oss-20b",
+  "nim-granite": "ibm/granite-3.0-8b-instruct",
+  "nim-granite-code": "ibm/granite-34b-code-instruct",
+  "nim-step": "stepfun-ai/step-3.5-flash"
+};
+function normalizeSystemPrompt(systemPrompt) {
+  if (!systemPrompt) return void 0;
+  let text = "";
+  if (typeof systemPrompt === "string") {
+    text = systemPrompt;
+  } else if (Array.isArray(systemPrompt)) {
+    text = systemPrompt.map((p) => typeof p === "string" ? p : p?.text ?? "").filter(Boolean).join("\n\n");
+  }
+  text = text.trim();
+  if (!text) return void 0;
+  const prefix = [
+    "You are memCode, an AI coding assistant. Help users with software engineering tasks.",
+    "IMPORTANT BEHAVIOR RULES:",
+    "- For greetings, questions, or conversation: respond directly with text. Do NOT call any tool.",
+    "- Only call tools when they are relevant to the user request and the tool description says they fit.",
+    "- Use file, shell, task, MCP, memory, browser, and agent tools only when they directly help complete the task.",
+    '- Identify yourself as "memCode" when asked who you are.',
+    '- Do NOT start your response with the word "assistant" or any role label.',
+    ""
+  ].join("\n");
+  return prefix + text;
+}
+function convertMessages(messages) {
+  return messages.map((msg) => {
+    const role = msg.role === "assistant" ? "assistant" : msg.role;
+    if (typeof msg.content === "string") {
+      return { role, content: msg.content };
+    }
+    if (!Array.isArray(msg.content)) {
+      return { role, content: "" };
+    }
+    const textParts = [];
+    const toolCalls = [];
+    const toolResults = [];
+    for (const block of msg.content) {
+      if (block.type === "text" && block.text) {
+        textParts.push(block.text);
+      } else if (block.type === "tool_use") {
+        toolCalls.push({
+          id: block.id,
+          type: "function",
+          function: {
+            name: block.name,
+            arguments: typeof block.input === "string" ? block.input : JSON.stringify(block.input ?? {})
+          }
+        });
+      } else if (block.type === "tool_result") {
+        const rc = Array.isArray(block.content) ? block.content.map((c) => c.text ?? JSON.stringify(c)).join("\n") : typeof block.content === "string" ? block.content : JSON.stringify(block.content ?? "");
+        toolResults.push({ role: "tool", tool_call_id: block.tool_use_id, content: rc });
+      }
+    }
+    if (toolResults.length > 0) {
+      const msgs = [];
+      if (textParts.length > 0 || toolCalls.length > 0) {
+        msgs.push({
+          role,
+          content: textParts.join("\n\n") || null,
+          ...toolCalls.length > 0 && { tool_calls: toolCalls }
+        });
+      }
+      return [...msgs, ...toolResults];
+    }
+    if (toolCalls.length === 0) {
+      return { role, content: textParts.join("\n\n") || "" };
+    }
+    return {
+      role,
+      content: textParts.length > 0 ? textParts.join("\n\n") : null,
+      tool_calls: toolCalls
+    };
+  }).flat();
+}
+function convertTools(tools) {
+  if (!tools || tools.length === 0) return void 0;
+  return tools.map((tool) => ({
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.input_schema || { type: "object", properties: {} }
+    }
+  }));
+}
+function stripRolePrefix(text) {
+  return text.replace(/^(assistant|user|system)\s*[:：\n]+\s*/i, "");
+}
+function parseLlamaToolCall(text) {
+  if (!text || !text.trim().startsWith("{")) return null;
+  try {
+    const obj = JSON.parse(text.trim());
+    if (obj.type === "function" && obj.name) {
+      return { name: obj.name, input: obj.parameters ?? obj.arguments ?? obj.input ?? {} };
+    }
+  } catch {
+  }
+  return null;
+}
+function getNvidiaThinkingFamily(model) {
+  const m = model.toLowerCase();
+  if (m.includes("deepseek-ai/deepseek-v4")) return "deepseek";
+  if (m.includes("nvidia/nemotron-3-ultra")) return "nemotron3";
+  return null;
+}
+function getNvidiaReasoningEffort(params) {
+  const effort = params.output_config?.effort;
+  if (effort === "low" || effort === "medium" || effort === "high") return effort;
+  return "high";
+}
+function applyNvidiaThinkingParams(requestBody, nvidiaModel, params) {
+  const family = getNvidiaThinkingFamily(nvidiaModel);
+  if (!family) return;
+  const thinking = params.thinking;
+  const enabled = thinking?.type === "enabled" || thinking?.type === "adaptive";
+  const chatTemplateKwargs = {
+    ...requestBody.chat_template_kwargs ?? {}
+  };
+  if (family === "deepseek") {
+    chatTemplateKwargs.thinking = enabled;
+    if (enabled) {
+      chatTemplateKwargs.reasoning_effort = getNvidiaReasoningEffort(params);
+    }
+  } else if (family === "nemotron3") {
+    chatTemplateKwargs.enable_thinking = enabled;
+    if (enabled) {
+      const budget = typeof thinking?.budget_tokens === "number" ? thinking.budget_tokens : requestBody.max_tokens;
+      requestBody.reasoning_budget = Math.max(
+        1,
+        Math.min(requestBody.max_tokens - 1, budget)
+      );
+    }
+  }
+  requestBody.chat_template_kwargs = chatTemplateKwargs;
+}
+function formatNvidiaError(status, body, model) {
+  if (status === 401) return `NVIDIA NIM: invalid API key.
+Get a key at: https://build.nvidia.com \u2192 Sign in \u2192 Get API Key`;
+  if (status === 402) return `NVIDIA NIM: out of free credits for "${model}".
+Each model gets 1,000 free calls.
+  \u2022 Try /model nim-llama4 or /model nim-qwen3
+  \u2022 Add credits: https://build.nvidia.com`;
+  if (status === 429) return `NVIDIA NIM: rate limit hit for "${model}" (free: 40 RPM).
+Wait a moment or switch: /model nim-llama4`;
+  if (status === 404) return `NVIDIA NIM: model "${model}" not found.
+Try: nim-llama4, nim-kimi, nim-deepseek, nim-mistral`;
+  return `NVIDIA NIM error ${status}: ${body}`;
+}
+async function* createNvidiaStream(model, systemPrompt, messages, tools, maxTokens, requestParams, apiKey, signal) {
+  const nvidiaModel = NVIDIA_MODEL_MAP[model] || model;
+  const nvidiaTools = convertTools(tools);
+  const normalizedSystem = normalizeSystemPrompt(systemPrompt);
+  const convertedMessages = convertMessages(messages);
+  const nvidiaMessages = normalizedSystem ? [{ role: "system", content: normalizedSystem }, ...convertedMessages] : convertedMessages;
+  const requestBody = {
+    model: nvidiaModel,
+    messages: nvidiaMessages,
+    max_tokens: maxTokens,
+    stream: true
+  };
+  applyNvidiaThinkingParams(requestBody, nvidiaModel, requestParams);
+  if (nvidiaTools && nvidiaTools.length > 0) {
+    requestBody.tools = nvidiaTools;
+  }
+  yield {
+    type: "message_start",
+    message: {
+      id: `msg_${randomUUID()}`,
+      type: "message",
+      role: "assistant",
+      content: [],
+      model,
+      stop_reason: null,
+      stop_sequence: null,
+      container: null,
+      usage: { input_tokens: 0, output_tokens: 0 }
+    }
+  };
+  try {
+    const response = await fetch(`${getNvidiaApiUrl()}/chat/completions`, {
+      method: "POST",
+      headers: { "Authorization": `Bearer ${apiKey}`, "Content-Type": "application/json" },
+      body: JSON.stringify(requestBody),
+      signal
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(formatNvidiaError(response.status, error, nvidiaModel));
+    }
+    const reader = response.body?.getReader();
+    if (!reader) throw new Error("No response body from NVIDIA NIM");
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let textStarted = false;
+    let textStopped = false;
+    let thinkingStarted = false;
+    let thinkingStopped = false;
+    let textBuffer = "";
+    const thinkTagSplitter = new ThinkTagSplitter();
+    let hasToolUse = false;
+    const activeToolCalls = /* @__PURE__ */ new Map();
+    let toolBlockOffset = null;
+    let fullText = "";
+    while (true) {
+      if (signal?.aborted) throw new Error("Request was aborted.");
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.trim() || !line.startsWith("data: ")) continue;
+        const data = line.slice(6);
+        if (data === "[DONE]") continue;
+        try {
+          const chunk = JSON.parse(data);
+          const delta = chunk.choices?.[0]?.delta;
+          if (!delta) continue;
+          const reasoning = delta.reasoning_content || delta.reasoning;
+          if (reasoning && !hasToolUse) {
+            if (!thinkingStarted) {
+              thinkingStarted = true;
+              yield {
+                type: "content_block_start",
+                index: 0,
+                content_block: { type: "thinking", thinking: "", signature: "" }
+              };
+            }
+            yield {
+              type: "content_block_delta",
+              index: 0,
+              delta: { type: "thinking_delta", thinking: reasoning }
+            };
+          }
+          if (delta.content && !hasToolUse) {
+            for (const piece of thinkTagSplitter.feed(delta.content)) {
+              if (piece.type === "thinking") {
+                if (!thinkingStarted) {
+                  thinkingStarted = true;
+                  yield {
+                    type: "content_block_start",
+                    index: 0,
+                    content_block: { type: "thinking", thinking: "", signature: "" }
+                  };
+                }
+                if (!thinkingStopped) {
+                  yield {
+                    type: "content_block_delta",
+                    index: 0,
+                    delta: { type: "thinking_delta", thinking: piece.text }
+                  };
+                }
+              } else {
+                if (thinkingStarted && !thinkingStopped) {
+                  thinkingStopped = true;
+                  yield { type: "content_block_stop", index: 0 };
+                }
+                const textIndex = thinkingStarted ? 1 : 0;
+                const cleaned = !textStarted ? stripRolePrefix(piece.text) : piece.text;
+                fullText += cleaned;
+                textBuffer += cleaned;
+                const endsWithPunct = /[.!?\n]$/.test(piece.text.trimEnd());
+                if ((endsWithPunct || textBuffer.length >= 40) && textBuffer.length > 0) {
+                  if (!textStarted) {
+                    textStarted = true;
+                    yield { type: "content_block_start", index: textIndex, content_block: { type: "text", text: "" } };
+                  }
+                  yield { type: "content_block_delta", index: textIndex, delta: { type: "text_delta", text: textBuffer } };
+                  textBuffer = "";
+                }
+              }
+            }
+          }
+          if (delta.tool_calls) {
+            for (const tc of delta.tool_calls) {
+              const providerIndex = tc.index ?? 0;
+              if (toolBlockOffset === null) {
+                toolBlockOffset = (thinkingStarted ? 1 : 0) + (textStarted ? 1 : 0);
+              }
+              const blockIndex = toolBlockOffset + providerIndex;
+              let currentToolCall = activeToolCalls.get(providerIndex);
+              if (!currentToolCall) {
+                currentToolCall = {
+                  blockIndex,
+                  id: tc.id || `toolu_${randomUUID()}`,
+                  name: tc.function?.name || "",
+                  arguments: ""
+                };
+                activeToolCalls.set(providerIndex, currentToolCall);
+                hasToolUse = true;
+                yield {
+                  type: "content_block_start",
+                  index: blockIndex,
+                  content_block: { type: "tool_use", id: currentToolCall.id, name: currentToolCall.name, input: {} }
+                };
+              }
+              if (tc.function?.arguments) {
+                currentToolCall.arguments += tc.function.arguments;
+                yield { type: "content_block_delta", index: currentToolCall.blockIndex, delta: { type: "input_json_delta", partial_json: tc.function.arguments } };
+              }
+            }
+          }
+          if (chunk.choices?.[0]?.finish_reason) {
+            const rawFinishReason = chunk.choices[0].finish_reason;
+            for (const piece of thinkTagSplitter.flush()) {
+              if (piece.type === "thinking") {
+                if (!thinkingStarted) {
+                  thinkingStarted = true;
+                  yield {
+                    type: "content_block_start",
+                    index: 0,
+                    content_block: { type: "thinking", thinking: "", signature: "" }
+                  };
+                }
+                if (!thinkingStopped) {
+                  yield {
+                    type: "content_block_delta",
+                    index: 0,
+                    delta: { type: "thinking_delta", thinking: piece.text }
+                  };
+                }
+              } else {
+                if (thinkingStarted && !thinkingStopped) {
+                  thinkingStopped = true;
+                  yield { type: "content_block_stop", index: 0 };
+                }
+                const cleaned = !textStarted ? stripRolePrefix(piece.text) : piece.text;
+                fullText += cleaned;
+                textBuffer += cleaned;
+              }
+            }
+            if (textBuffer.length > 0 && !hasToolUse) {
+              if (thinkingStarted && !thinkingStopped) {
+                thinkingStopped = true;
+                yield { type: "content_block_stop", index: 0 };
+              }
+              const textIndex = thinkingStarted ? 1 : 0;
+              if (!textStarted) {
+                textStarted = true;
+                yield { type: "content_block_start", index: textIndex, content_block: { type: "text", text: "" } };
+              }
+              yield { type: "content_block_delta", index: textIndex, delta: { type: "text_delta", text: textBuffer } };
+              textBuffer = "";
+            }
+            if (textStarted && !hasToolUse && fullText.trim()) {
+              const llamaCall = parseLlamaToolCall(fullText.trim());
+              if (llamaCall) {
+                const replacementIndex = thinkingStarted ? 1 : 0;
+                yield { type: "content_block_stop", index: replacementIndex };
+                const toolId = `toolu_${randomUUID()}`;
+                yield { type: "content_block_start", index: replacementIndex, content_block: { type: "tool_use", id: toolId, name: llamaCall.name, input: {} } };
+                const argsJson = JSON.stringify(llamaCall.input);
+                yield { type: "content_block_delta", index: replacementIndex, delta: { type: "input_json_delta", partial_json: argsJson } };
+                yield { type: "content_block_stop", index: replacementIndex };
+                yield {
+                  type: "message_delta",
+                  delta: { stop_reason: "tool_use", stop_sequence: null },
+                  usage: { input_tokens: chunk.usage?.prompt_tokens || 0, output_tokens: chunk.usage?.completion_tokens || 0 },
+                  context_management: null
+                };
+                yield { type: "message_stop" };
+                return;
+              }
+            }
+            if (thinkingStarted && !thinkingStopped) yield { type: "content_block_stop", index: 0 };
+            if (textStarted && !hasToolUse && !textStopped) {
+              textStopped = true;
+              yield { type: "content_block_stop", index: thinkingStarted ? 1 : 0 };
+            }
+            for (const currentToolCall of [...activeToolCalls.values()].sort((a, b) => a.blockIndex - b.blockIndex)) {
+              yield { type: "content_block_stop", index: currentToolCall.blockIndex };
+            }
+            yield {
+              type: "message_delta",
+              delta: { stop_reason: finishReason(rawFinishReason), stop_sequence: null },
+              usage: { input_tokens: chunk.usage?.prompt_tokens || 0, output_tokens: chunk.usage?.completion_tokens || 0 },
+              context_management: null
+            };
+          }
+        } catch {
+          continue;
+        }
+      }
+    }
+    for (const piece of thinkTagSplitter.flush()) {
+      if (piece.type === "thinking") {
+        if (!thinkingStarted) {
+          thinkingStarted = true;
+          yield {
+            type: "content_block_start",
+            index: 0,
+            content_block: { type: "thinking", thinking: "", signature: "" }
+          };
+        }
+        if (!thinkingStopped) {
+          yield {
+            type: "content_block_delta",
+            index: 0,
+            delta: { type: "thinking_delta", thinking: piece.text }
+          };
+        }
+      } else {
+        if (thinkingStarted && !thinkingStopped) {
+          thinkingStopped = true;
+          yield { type: "content_block_stop", index: 0 };
+        }
+        const cleaned = !textStarted ? stripRolePrefix(piece.text) : piece.text;
+        fullText += cleaned;
+        textBuffer += cleaned;
+      }
+    }
+    if (textBuffer.length > 0 && !hasToolUse) {
+      if (thinkingStarted && !thinkingStopped) {
+        thinkingStopped = true;
+        yield { type: "content_block_stop", index: 0 };
+      }
+      const textIndex = thinkingStarted ? 1 : 0;
+      if (!textStarted) {
+        textStarted = true;
+        yield { type: "content_block_start", index: textIndex, content_block: { type: "text", text: "" } };
+      }
+      yield { type: "content_block_delta", index: textIndex, delta: { type: "text_delta", text: textBuffer } };
+      textBuffer = "";
+    }
+    if (thinkingStarted && !thinkingStopped) yield { type: "content_block_stop", index: 0 };
+    if (textStarted && !hasToolUse && !textStopped) {
+      textStopped = true;
+      yield { type: "content_block_stop", index: thinkingStarted ? 1 : 0 };
+    }
+    yield { type: "message_stop" };
+  } catch (error) {
+    if (signal?.aborted) throw new Error("Request was aborted.");
+    throw error;
+  }
+}
+class NvidiaAnthropicClient {
+  apiKey;
+  constructor(apiKey) {
+    if (!apiKey || !apiKey.startsWith("nvapi-")) {
+      throw new Error(
+        `Invalid NVIDIA NIM API key. Expected a key starting with "nvapi-".
+Set NVIDIA_API_KEY=nvapi-... or get a key at: https://build.nvidia.com`
+      );
+    }
+    this.apiKey = apiKey;
+  }
+  // Expose beta.messages using the same pattern as GeminiAnthropicClient
+  beta = {
+    messages: {
+      /**
+       * Streaming — returns a Stream<BetaRawMessageStreamEvent> with .controller.
+       * claude.ts calls: anthropic.beta.messages.stream(params, opts).withResponse()
+       * We return an object with [Symbol.asyncIterator] + controller so the
+       * for-await loop in claude.ts works, and withResponse() returns {data, request_id, response}.
+       */
+      stream: (params, options) => {
+        const self = this;
+        const signal = params.signal || options?.signal;
+        const generator = createNvidiaStream(
+          params.model,
+          params.system,
+          params.messages,
+          params.tools,
+          params.max_tokens,
+          params,
+          self.apiKey,
+          signal
+        );
+        const streamObj = {
+          [Symbol.asyncIterator]: () => generator,
+          controller: { abort: () => {
+          } },
+          withResponse: async () => ({
+            data: streamObj,
+            request_id: void 0,
+            response: new Response(null, { status: 200 })
+          })
+        };
+        return streamObj;
+      },
+      /** Non-streaming create — used by the fallback path in claude.ts */
+      create: async (params, options) => {
+        const nvidiaModel = NVIDIA_MODEL_MAP[params.model] || params.model;
+        const nvidiaTools = convertTools(params.tools);
+        const normalizedSystem = normalizeSystemPrompt(params.system);
+        const convertedMessages = convertMessages(params.messages);
+        const nvidiaMessages = normalizedSystem ? [{ role: "system", content: normalizedSystem }, ...convertedMessages] : convertedMessages;
+        const requestBody = {
+          model: nvidiaModel,
+          messages: nvidiaMessages,
+          max_tokens: params.max_tokens,
+          stream: false
+        };
+        applyNvidiaThinkingParams(requestBody, nvidiaModel, params);
+        if (nvidiaTools && nvidiaTools.length > 0) requestBody.tools = nvidiaTools;
+        const signal = params.signal || options?.signal;
+        const response = await fetch(`${getNvidiaApiUrl()}/chat/completions`, {
+          method: "POST",
+          headers: { "Authorization": `Bearer ${this.apiKey}`, "Content-Type": "application/json" },
+          body: JSON.stringify(requestBody),
+          signal
+        });
+        if (!response.ok) {
+          const error = await response.text();
+          throw new Error(formatNvidiaError(response.status, error, nvidiaModel));
+        }
+        const result = await response.json();
+        const message = result.choices?.[0]?.message;
+        const rawFinishReason = result.choices?.[0]?.finish_reason;
+        const content = [];
+        const reasoningText = message?.reasoning || message?.reasoning_content || "";
+        if (typeof reasoningText === "string" && reasoningText.trim()) {
+          content.push({
+            type: "thinking",
+            thinking: reasoningText,
+            signature: ""
+          });
+        }
+        const rawText = message?.content || "";
+        if (rawText) {
+          const llamaCall = parseLlamaToolCall(typeof rawText === "string" ? rawText.trim() : "");
+          if (llamaCall) {
+            content.push({
+              type: "tool_use",
+              id: `toolu_${randomUUID()}`,
+              name: llamaCall.name,
+              input: llamaCall.input
+            });
+            return {
+              id: result.id || `msg_${randomUUID()}`,
+              type: "message",
+              role: "assistant",
+              content,
+              model: params.model,
+              stop_reason: "tool_use",
+              stop_sequence: null,
+              usage: result.usage ? { input_tokens: result.usage.prompt_tokens, output_tokens: result.usage.completion_tokens } : void 0
+            };
+          }
+          if (typeof rawText === "string") {
+            for (const piece of splitThinkTags(rawText)) {
+              content.push(
+                piece.type === "thinking" ? { type: "thinking", thinking: piece.text, signature: "" } : { type: "text", text: stripRolePrefix(piece.text) }
+              );
+            }
+          } else if (Array.isArray(rawText)) {
+            for (const part of rawText) {
+              if (part.type === "text") content.push({ type: "text", text: part.text });
+            }
+          }
+        }
+        if (message?.tool_calls?.length > 0) {
+          for (const tc of message.tool_calls) {
+            content.push({
+              type: "tool_use",
+              id: tc.id,
+              name: tc.function.name,
+              input: parseToolArguments(tc.function.arguments)
+            });
+          }
+        }
+        return {
+          id: result.id || `msg_${randomUUID()}`,
+          type: "message",
+          role: "assistant",
+          content,
+          model: params.model,
+          stop_reason: message?.tool_calls?.length > 0 ? "tool_use" : finishReason(rawFinishReason),
+          stop_sequence: null,
+          usage: result.usage ? { input_tokens: result.usage.prompt_tokens, output_tokens: result.usage.completion_tokens } : void 0
+        };
+      }
+    }
+  };
+  // claude.ts uses both anthropic.beta.messages.* and anthropic.messages.*
+  // Keep messages as alias for beta.messages so both paths work
+  messages = this.beta.messages;
+}
+export {
+  NVIDIA_MODEL_MAP,
+  NvidiaAnthropicClient,
+  convertMessages,
+  convertTools,
+  stripRolePrefix
+};