plugin-ai-api 1.0.11 → 1.0.12

package/dist/server/routes/chat-completions.js

@@ -26,6 +26,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var chat_completions_exports = {};
 __export(chat_completions_exports, {
+  applyProviderRequestParameters: () => applyProviderRequestParameters,
+  getProviderRequestParameters: () => getProviderRequestParameters,
   handleChatCompletions: () => handleChatCompletions
 });
 module.exports = __toCommonJS(chat_completions_exports);
@@ -108,13 +110,15 @@ async function handleChatCompletions(ctx, plugin) {
       ctx.body = (0, import_openai_format.toOpenAIError)(500, `Provider '${service.provider}' not registered`, "server_error");
       return;
     }
+    const providerRequestParameters = getProviderRequestParameters(body);
     const modelOptions = {
       model: modelId,
       llmService: service.name
     };
     if (body.temperature !== void 0) modelOptions.temperature = body.temperature;
     if (body.top_p !== void 0) modelOptions.topP = body.top_p;
-    if (body.max_tokens !== void 0) modelOptions.maxTokens = body.max_tokens;
+    if (body.max_completion_tokens !== void 0) modelOptions.maxTokens = body.max_completion_tokens;
+    else if (body.max_tokens !== void 0) modelOptions.maxTokens = body.max_tokens;
     if (body.frequency_penalty !== void 0) modelOptions.frequencyPenalty = body.frequency_penalty;
     if (body.presence_penalty !== void 0) modelOptions.presencePenalty = body.presence_penalty;
     if (body.stop !== void 0) modelOptions.stop = body.stop;
@@ -166,11 +170,26 @@ async function handleChatCompletions(ctx, plugin) {
     });
     const completionId = (0, import_openai_format.generateCompletionId)();
     const baseModel = provider.createModel();
-    const chatModel = bindRequestTools(baseModel, body.tools, body.tool_choice);
+    applyProviderRequestParameters(baseModel, providerRequestParameters);
+    const chatModel = bindRequestTools(baseModel, body.tools, body.tool_choice, providerRequestParameters);
     if (stream) {
-      await handleStreamingCompletion(ctx, chatModel, langchainMessages, completionId, body.model);
+      await handleStreamingCompletion(
+        ctx,
+        chatModel,
+        langchainMessages,
+        completionId,
+        body.model,
+        providerRequestParameters
+      );
     } else {
-      await handleNonStreamingCompletion(ctx, chatModel, langchainMessages, completionId, body.model);
+      await handleNonStreamingCompletion(
+        ctx,
+        chatModel,
+        langchainMessages,
+        completionId,
+        body.model,
+        providerRequestParameters
+      );
     }
   } catch (err) {
     ctx.log.error("AI API chat completions error:", err);
@@ -180,8 +199,8 @@ async function handleChatCompletions(ctx, plugin) {
     }
   }
 }
-async function handleNonStreamingCompletion(ctx, chatModel, messages, completionId, modelName) {
-  const result = await chatModel.invoke(messages);
+async function handleNonStreamingCompletion(ctx, chatModel, messages, completionId, modelName, providerRequestParameters) {
+  const result = await chatModel.invoke(messages, providerRequestParameters);
   let content = "";
   if (typeof result.content === "string") {
     content = result.content;
@@ -204,7 +223,7 @@ async function handleNonStreamingCompletion(ctx, chatModel, messages, completion
     toolCalls
   });
 }
-async function handleStreamingCompletion(ctx, chatModel, messages, completionId, modelName) {
+async function handleStreamingCompletion(ctx, chatModel, messages, completionId, modelName, providerRequestParameters) {
   ctx.set({
     "Content-Type": "text/event-stream",
     "Cache-Control": "no-cache",
@@ -227,7 +246,7 @@ async function handleStreamingCompletion(ctx, chatModel, messages, completionId,
   let usage;
   let finishReason = "stop";
   try {
-    const stream = await chatModel.stream(messages, { signal: requestAbort.signal });
+    const stream = await chatModel.stream(messages, { ...providerRequestParameters, signal: requestAbort.signal });
     for await (const chunk of stream) {
       if (requestAbort.signal.aborted) throw requestAbort.signal.reason;
       let content = "";
@@ -300,12 +319,41 @@ async function handleStreamingCompletion(ctx, chatModel, messages, completionId,
 function getErrorMessage(error, fallback) {
   return error instanceof Error && error.message ? error.message : fallback;
 }
-function bindRequestTools(chatModel, tools, toolChoice) {
+const GATEWAY_MANAGED_PARAMETERS = /* @__PURE__ */ new Set(["model", "messages", "tools", "tool_choice", "stream", "n"]);
+function getProviderRequestParameters(body) {
+  return Object.fromEntries(
+    Object.entries(body).filter(([name, value]) => !GATEWAY_MANAGED_PARAMETERS.has(name) && value !== void 0)
+  );
+}
+function applyProviderRequestParameters(chatModel, parameters) {
+  if (!chatModel || typeof chatModel !== "object") return;
+  const model = chatModel;
+  const modelKwargs = { ...model.modelKwargs ?? {} };
+  if (!Object.hasOwn(parameters, "response_format")) {
+    if (isDefaultTextResponseFormat(modelKwargs.response_format)) delete modelKwargs.response_format;
+    if (isDefaultResponsesTextFormat(modelKwargs.text)) delete modelKwargs.text;
+  }
+  model.modelKwargs = { ...modelKwargs, ...parameters };
+}
+function bindRequestTools(chatModel, tools, toolChoice, providerRequestParameters) {
   if (!Array.isArray(tools) || tools.length === 0) return chatModel;
   if (typeof chatModel.bindTools !== "function") {
     throw new Error("The selected LLM provider does not support tool calling");
   }
-  return chatModel.bindTools(tools, toolChoice === void 0 ? void 0 : { tool_choice: toolChoice });
+  return chatModel.bindTools(tools, {
+    ...providerRequestParameters,
+    ...toolChoice === void 0 ? {} : { tool_choice: toolChoice }
+  });
+}
+function isDefaultTextResponseFormat(value) {
+  return isRecord(value) && value.type === "text" && Object.keys(value).length === 1;
+}
+function isDefaultResponsesTextFormat(value) {
+  if (!isRecord(value) || !isRecord(value.format)) return false;
+  return value.format.type === "text" && Object.keys(value.format).length === 1 && Object.keys(value).length === 1;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function normalizeToolCalls(value) {
   if (!Array.isArray(value) || value.length === 0) return void 0;
@@ -340,5 +388,7 @@ function serializeToolArguments(value) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  applyProviderRequestParameters,
+  getProviderRequestParameters,
   handleChatCompletions
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plugin-ai-api",
-  "version": "1.0.11",
+  "version": "1.0.12",
   "main": "dist/server/index.js",
   "dependencies": {},
   "peerDependencies": {

package/src/server/__tests__/openai-format.test.ts

@@ -1,5 +1,6 @@
 import { toOpenAIResponse, toOpenAIStreamChunk } from '../utils/openai-format';
 import { isStreamingRequested } from '../utils/streaming';
+import { applyProviderRequestParameters, getProviderRequestParameters } from '../routes/chat-completions';
 
 describe('AI API OpenAI tool-call formatting', () => {
   it('streams by default and only disables streaming for an explicit false value', () => {
@@ -50,3 +51,58 @@ describe('AI API OpenAI tool-call formatting', () => {
     expect(chunk.choices[0].delta.tool_calls?.[0].function?.name).toBe('get_weather');
   });
 });
+
+describe('AI API provider parameter forwarding', () => {
+  it('forwards model and tool-call parameters not managed by the gateway', () => {
+    const parameters = getProviderRequestParameters({
+      model: 'service/model',
+      messages: [{ role: 'user', content: 'Use a tool' }],
+      tools: [{ type: 'function', function: { name: 'search' } }],
+      tool_choice: 'auto',
+      stream: true,
+      n: 1,
+      parallel_tool_calls: false,
+      reasoning_effort: 'medium',
+      max_completion_tokens: 4096,
+      seed: 7,
+      service_tier: 'default',
+    });
+
+    expect(parameters).toEqual({
+      parallel_tool_calls: false,
+      reasoning_effort: 'medium',
+      max_completion_tokens: 4096,
+      seed: 7,
+      service_tier: 'default',
+    });
+  });
+
+  it('merges passthrough parameters into model kwargs and removes the synthetic text response format', () => {
+    const model = {
+      modelKwargs: {
+        response_format: { type: 'text' },
+        existing_provider_option: true,
+      },
+    };
+
+    applyProviderRequestParameters(model, {
+      parallel_tool_calls: false,
+      reasoning_effort: 'high',
+    });
+
+    expect(model.modelKwargs).toEqual({
+      existing_provider_option: true,
+      parallel_tool_calls: false,
+      reasoning_effort: 'high',
+    });
+  });
+
+  it('preserves an explicitly requested response format', () => {
+    const model = { modelKwargs: { response_format: { type: 'text' } } };
+    const responseFormat = { type: 'json_schema', json_schema: { name: 'answer', schema: { type: 'object' } } };
+
+    applyProviderRequestParameters(model, { response_format: responseFormat });
+
+    expect(model.modelKwargs.response_format).toEqual(responseFormat);
+  });
+});

package/src/server/routes/chat-completions.ts

@@ -120,7 +120,8 @@ export async function handleChatCompletions(ctx: Context, plugin: PluginAiApiSer
       return;
     }
 
-    const modelOptions: Record<string, any> = {
+    const providerRequestParameters = getProviderRequestParameters(body);
+    const modelOptions: Record<string, unknown> = {
       model: modelId,
       llmService: service.name,
     };
@@ -128,7 +129,8 @@ export async function handleChatCompletions(ctx: Context, plugin: PluginAiApiSer
     // Pass through optional parameters
     if (body.temperature !== undefined) modelOptions.temperature = body.temperature;
     if (body.top_p !== undefined) modelOptions.topP = body.top_p;
-    if (body.max_tokens !== undefined) modelOptions.maxTokens = body.max_tokens;
+    if (body.max_completion_tokens !== undefined) modelOptions.maxTokens = body.max_completion_tokens;
+    else if (body.max_tokens !== undefined) modelOptions.maxTokens = body.max_tokens;
     if (body.frequency_penalty !== undefined) modelOptions.frequencyPenalty = body.frequency_penalty;
     if (body.presence_penalty !== undefined) modelOptions.presencePenalty = body.presence_penalty;
     if (body.stop !== undefined) modelOptions.stop = body.stop;
@@ -192,14 +194,29 @@ export async function handleChatCompletions(ctx: Context, plugin: PluginAiApiSer
 
     const completionId = generateCompletionId();
     const baseModel = provider.createModel();
-    const chatModel = bindRequestTools(baseModel, body.tools, body.tool_choice);
+    applyProviderRequestParameters(baseModel, providerRequestParameters);
+    const chatModel = bindRequestTools(baseModel, body.tools, body.tool_choice, providerRequestParameters);
 
     if (stream) {
       // ─── Streaming mode ───
-      await handleStreamingCompletion(ctx, chatModel, langchainMessages, completionId, body.model);
+      await handleStreamingCompletion(
+        ctx,
+        chatModel,
+        langchainMessages,
+        completionId,
+        body.model,
+        providerRequestParameters,
+      );
     } else {
       // ─── Non-streaming mode ───
-      await handleNonStreamingCompletion(ctx, chatModel, langchainMessages, completionId, body.model);
+      await handleNonStreamingCompletion(
+        ctx,
+        chatModel,
+        langchainMessages,
+        completionId,
+        body.model,
+        providerRequestParameters,
+      );
     }
   } catch (err) {
     ctx.log.error('AI API chat completions error:', err);
@@ -218,8 +235,9 @@ async function handleNonStreamingCompletion(
   messages: any[],
   completionId: string,
   modelName: string,
+  providerRequestParameters: Record<string, unknown>,
 ) {
-  const result = await chatModel.invoke(messages);
+  const result = await chatModel.invoke(messages, providerRequestParameters);
 
   let content = '';
   if (typeof result.content === 'string') {
@@ -258,6 +276,7 @@ async function handleStreamingCompletion(
   messages: any[],
   completionId: string,
   modelName: string,
+  providerRequestParameters: Record<string, unknown>,
 ) {
   // Set SSE headers
   ctx.set({
@@ -284,7 +303,7 @@ async function handleStreamingCompletion(
   let usage: { prompt_tokens: number; completion_tokens: number; total_tokens: number } | undefined;
   let finishReason = 'stop';
   try {
-    const stream = await chatModel.stream(messages, { signal: requestAbort.signal });
+    const stream = await chatModel.stream(messages, { ...providerRequestParameters, signal: requestAbort.signal });
 
     for await (const chunk of stream) {
       if (requestAbort.signal.aborted) throw requestAbort.signal.reason;
@@ -367,12 +386,62 @@ function getErrorMessage(error: unknown, fallback: string) {
   return error instanceof Error && error.message ? error.message : fallback;
 }
 
-function bindRequestTools(chatModel: any, tools: unknown, toolChoice: unknown) {
+const GATEWAY_MANAGED_PARAMETERS = new Set(['model', 'messages', 'tools', 'tool_choice', 'stream', 'n']);
+
+export function getProviderRequestParameters(body: Record<string, unknown>): Record<string, unknown> {
+  return Object.fromEntries(
+    Object.entries(body).filter(([name, value]) => !GATEWAY_MANAGED_PARAMETERS.has(name) && value !== undefined),
+  );
+}
+
+interface ModelWithKwargs {
+  modelKwargs?: Record<string, unknown>;
+}
+
+export function applyProviderRequestParameters(chatModel: unknown, parameters: Record<string, unknown>): void {
+  if (!chatModel || typeof chatModel !== 'object') return;
+
+  const model = chatModel as ModelWithKwargs;
+  const modelKwargs = { ...(model.modelKwargs ?? {}) };
+
+  // OpenAI providers currently install a synthetic text response format even when
+  // the client did not request one. Remove that default so LLM mode matches the
+  // original OpenAI-compatible request more closely.
+  if (!Object.hasOwn(parameters, 'response_format')) {
+    if (isDefaultTextResponseFormat(modelKwargs.response_format)) delete modelKwargs.response_format;
+    if (isDefaultResponsesTextFormat(modelKwargs.text)) delete modelKwargs.text;
+  }
+
+  model.modelKwargs = { ...modelKwargs, ...parameters };
+}
+
+function bindRequestTools(
+  chatModel: any,
+  tools: unknown,
+  toolChoice: unknown,
+  providerRequestParameters: Record<string, unknown>,
+) {
   if (!Array.isArray(tools) || tools.length === 0) return chatModel;
   if (typeof chatModel.bindTools !== 'function') {
     throw new Error('The selected LLM provider does not support tool calling');
   }
-  return chatModel.bindTools(tools, toolChoice === undefined ? undefined : { tool_choice: toolChoice });
+  return chatModel.bindTools(tools, {
+    ...providerRequestParameters,
+    ...(toolChoice === undefined ? {} : { tool_choice: toolChoice }),
+  });
+}
+
+function isDefaultTextResponseFormat(value: unknown): boolean {
+  return isRecord(value) && value.type === 'text' && Object.keys(value).length === 1;
+}
+
+function isDefaultResponsesTextFormat(value: unknown): boolean {
+  if (!isRecord(value) || !isRecord(value.format)) return false;
+  return value.format.type === 'text' && Object.keys(value.format).length === 1 && Object.keys(value).length === 1;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 
 function normalizeToolCalls(value: unknown): OpenAIToolCall[] | undefined {