🤖 feat: add per-model provider modelParameters overrides

src/common/config/schemas/index.ts

@@ -1,4 +1,5 @@
 export * from "./appConfigOnDisk";
+export * from "./modelParameters";
 export * from "./providersConfig";
 export * from "./configOperations";
 export * from "./taskSettings";

src/common/config/schemas/modelParameters.ts

@@ -0,0 +1,43 @@
+import type { CallSettings } from "ai";
+import { z } from "zod";
+
+const STANDARD_MODEL_PARAMETER_SHAPE = {
+  max_output_tokens: z.number().int().positive().optional(),
+  temperature: z.number().min(0).max(2).optional(),
+  top_p: z.number().min(0).max(1).optional(),
+  top_k: z.number().int().positive().optional(),
+  seed: z.number().int().optional(),
+  frequency_penalty: z.number().optional(),
+  presence_penalty: z.number().optional(),
+} as const;
+
+export const StandardModelParameterOverridesSchema = z.object(STANDARD_MODEL_PARAMETER_SHAPE);
+
+// Single runtime mapping source of truth (snake_case config -> AI SDK CallSettings keys)
+export const STANDARD_MODEL_PARAMETER_TO_CALL_SETTING = {
+  max_output_tokens: "maxOutputTokens",
+  temperature: "temperature",
+  top_p: "topP",
+  top_k: "topK",
+  seed: "seed",
+  frequency_penalty: "frequencyPenalty",
+  presence_penalty: "presencePenalty",
+} as const satisfies Record<keyof typeof STANDARD_MODEL_PARAMETER_SHAPE, keyof CallSettings>;
+
+export const ModelParameterOverridesSchema = StandardModelParameterOverridesSchema.passthrough();
+
+export const ModelParametersByModelSchema = z.record(
+  z.string().min(1),
+  ModelParameterOverridesSchema
+);
+
+export type ModelParameterOverrides = z.infer<typeof ModelParameterOverridesSchema>;
+export type StandardModelParameterOverrides = z.infer<typeof StandardModelParameterOverridesSchema>;
+
+// Downstream type for call settings forwarding — derived from AI SDK CallSettings
+export type ResolvedCallSettingsOverrides = Partial<
+  Pick<
+    CallSettings,
+    (typeof STANDARD_MODEL_PARAMETER_TO_CALL_SETTING)[keyof typeof STANDARD_MODEL_PARAMETER_TO_CALL_SETTING]
+  >
+>;

src/common/config/schemas/providersConfig.test.ts

@@ -42,4 +42,82 @@ describe("ProvidersConfigSchema", () => {
 
     expect(ProvidersConfigSchema.safeParse(invalid).success).toBe(false);
   });
+
+  describe("modelParameters", () => {
+    it("accepts valid per-model and wildcard overrides", () => {
+      const valid = {
+        openai: {
+          modelParameters: {
+            "gpt-5": { max_output_tokens: 1024, temperature: 0.4 },
+            "*": { top_p: 0.9 },
+          },
+        },
+      };
+
+      expect(ProvidersConfigSchema.safeParse(valid).success).toBe(true);
+    });
+
+    it("rejects negative max_output_tokens", () => {
+      const invalid = {
+        openai: {
+          modelParameters: {
+            "gpt-5": { max_output_tokens: -1 },
+          },
+        },
+      };
+
+      expect(ProvidersConfigSchema.safeParse(invalid).success).toBe(false);
+    });
+
+    it("rejects temperature values above 2", () => {
+      const invalid = {
+        openai: {
+          modelParameters: {
+            "gpt-5": { temperature: 3 },
+          },
+        },
+      };
+
+      expect(ProvidersConfigSchema.safeParse(invalid).success).toBe(false);
+    });
+
+    it("rejects top_p values above 1", () => {
+      const invalid = {
+        openai: {
+          modelParameters: {
+            "gpt-5": { top_p: 1.5 },
+          },
+        },
+      };
+
+      expect(ProvidersConfigSchema.safeParse(invalid).success).toBe(false);
+    });
+
+    it("passes through unknown override keys", () => {
+      const valid = {
+        openai: {
+          modelParameters: {
+            "gpt-5": { transforms: ["middle-out"] },
+          },
+        },
+      };
+
+      const parsed = ProvidersConfigSchema.safeParse(valid);
+
+      expect(parsed.success).toBe(true);
+      if (parsed.success) {
+        expect(parsed.data.openai?.modelParameters?.["gpt-5"]).toEqual({
+          transforms: ["middle-out"],
+        });
+      }
+    });
+
+    it("allows provider configs without modelParameters", () => {
+      const valid = {
+        openai: { apiKey: "sk-openai-123" },
+      };
+
+      expect(ProvidersConfigSchema.safeParse(valid).success).toBe(true);
+    });
+  });
 });

src/common/config/schemas/providersConfig.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 
+import { ModelParametersByModelSchema } from "./modelParameters";
 import { ProviderModelEntrySchema } from "./providerModelEntry";
 
 export const CacheTtlSchema = z.enum(["5m", "1h"]);
@@ -15,6 +16,7 @@ export const BaseProviderConfigSchema = z
     headers: z.record(z.string(), z.string()).optional(),
     enabled: z.boolean().optional(),
     models: z.array(ProviderModelEntrySchema).optional(),
+    modelParameters: ModelParametersByModelSchema.optional(),
   })
   .passthrough();