@elizaos/plugin-elizacloud 2.0.3-beta.2 → 2.0.3-beta.4

package/src/models/text.ts

@@ -348,6 +348,18 @@ function isReasoningModel(modelName: string): boolean {
   return REASONING_MODEL_PATTERNS.some((pattern) => lower.includes(pattern));
 }
 
+/**
+ * True when the Cloud gateway routes this model to Cerebras (the gpt-oss
+ * family). Cerebras's OpenAI-compatible endpoint rejects
+ * `response_format: { type: "json_schema", ... }` with a 400, so structured
+ * output for these models must fall back to `{ type: "json_object" }`.
+ * Mirrors plugin-openai's `isCerebrasMode` json_object scrub, detected by
+ * model name here because one Cloud key serves many providers.
+ */
+function isCerebrasServedModel(modelName: string): boolean {
+  return modelName.toLowerCase().includes("gpt-oss");
+}
+
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -509,7 +521,7 @@ export function normalizeNativeTools(tools: unknown): unknown[] | undefined {
   return normalized.length > 0 ? normalized : undefined;
 }
 
-function normalizeNativeToolChoice(toolChoice: unknown): unknown {
+export function normalizeNativeToolChoice(toolChoice: unknown): unknown {
   if (!toolChoice) {
     return undefined;
   }
@@ -523,7 +535,17 @@ function normalizeNativeToolChoice(toolChoice: unknown): unknown {
 
   const choice = asRecord(toolChoice);
   if (choice.type === "function") {
-    return toolChoice;
+    const functionChoice = recordAt(choice, "function");
+    const toolName = firstString(functionChoice.name, choice.name, choice.toolName);
+    return toolName
+      ? {
+          type: "function",
+          function: {
+            ...functionChoice,
+            name: toolName,
+          },
+        }
+      : undefined;
   }
   if (choice.type === "tool") {
     const toolName = firstString(choice.toolName, choice.name);
@@ -535,11 +557,17 @@ function normalizeNativeToolChoice(toolChoice: unknown): unknown {
   return toolName ? { type: "function", function: { name: toolName } } : toolChoice;
 }
 
-function buildNativeResponseFormat(responseSchema: unknown): unknown {
+function buildNativeResponseFormat(responseSchema: unknown, modelName: string): unknown {
   if (!responseSchema) {
     return undefined;
   }
 
+  // Cerebras-served models (gpt-oss) 400 on `response_format: json_schema`, so
+  // emit `json_object` and rely on the schema embedded in the prompt body.
+  if (isCerebrasServedModel(modelName)) {
+    return { type: "json_object" };
+  }
+
   const schemaRecord = asRecord(responseSchema);
   if (schemaRecord.responseFormat) {
     return schemaRecord.responseFormat;
@@ -653,16 +681,34 @@ function buildNativeRequestBody(
   const promptCacheKey = providerOptions ? resolvePromptCacheKey(providerOptions) : undefined;
   const tools = normalizeNativeTools(params.tools);
   const toolChoice = normalizeNativeToolChoice(params.toolChoice);
-  const responseFormat = buildNativeResponseFormat(params.responseSchema);
+  const responseFormat = buildNativeResponseFormat(params.responseSchema, modelName);
   const requestBody: Record<string, unknown> = {
     model: modelName,
     messages: buildNativeMessages(params, promptText, systemPrompt),
-    max_tokens: params.maxTokens ?? 8192,
   };
+  // Omit the cap entirely when the caller opted out (direct-channel Stage-1):
+  // a hardcoded max_tokens 400s on a model whose real limit differs. Every other
+  // caller keeps the 8192 default so it stays bounded.
+  if (!params.omitMaxTokens) {
+    requestBody.max_tokens = params.maxTokens ?? 8192;
+  }
 
   if (!isReasoningModel(modelName) && typeof params.temperature === "number") {
     requestBody.temperature = params.temperature;
   }
+  // cerebras gpt-oss runs a hidden-reasoning pass before answering even when the
+  // caller wants none — measured ~4s/call vs ~0.7s with reasoning suppressed. The
+  // runtime signals "don't reason" via providerOptions.eliza.thinking="off" (e.g.
+  // the Stage-1 RESPONSE_HANDLER formatting call), but resolveNativeProviderOptions
+  // drops the eliza block, so it never reached the wire. Honor it as cerebras's
+  // reasoning_effort:"low". Cerebras-gated (the plugin's isReasoningModel does NOT
+  // match gpt-oss); other providers ignore the field.
+  if (
+    isCerebrasServedModel(modelName) &&
+    recordAt(asRecord(params.providerOptions), "eliza").thinking === "off"
+  ) {
+    requestBody.reasoning_effort = "low";
+  }
   if (tools) {
     requestBody.tools = tools;
   }
@@ -924,8 +970,10 @@ async function generateTextWithModel(
   const requestBody: Record<string, unknown> = {
     model: modelName,
     input,
-    max_output_tokens: params.maxTokens ?? 8192,
   };
+  if (!params.omitMaxTokens) {
+    requestBody.max_output_tokens = params.maxTokens ?? 8192;
+  }
   if (!reasoning && typeof params.temperature === "number") {
     requestBody.temperature = params.temperature;
   }