@workglow/openai 0.3.24 → 0.3.26

package/dist/ai.js

@@ -49,6 +49,39 @@ function getModelName(model) {
   }
   return name;
 }
+function getReasoningConfig(model) {
+  const reasoning = model?.provider_config?.reasoning;
+  if (!reasoning || reasoning.effort === undefined && reasoning.mode === undefined) {
+    return;
+  }
+  return reasoning;
+}
+function fnv1aHex(input) {
+  let hash = 2166136261;
+  for (let i = 0;i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function resolvePromptCacheKey(model, params) {
+  const override = model?.provider_config?.prompt_cache_key;
+  if (override)
+    return override;
+  const material = JSON.stringify([
+    params.model ?? "",
+    params.instructions ?? "",
+    params.tools ?? null
+  ]);
+  return `wg-${fnv1aHex(material)}`;
+}
+function finalizeResponsesRequest(model, params) {
+  const reasoning = getReasoningConfig(model);
+  if (reasoning !== undefined)
+    params.reasoning = reasoning;
+  params.prompt_cache_key = resolvePromptCacheKey(model, params);
+  return params;
+}
 // src/ai/common/OpenAI_Constants.ts
 var OPENAI = "OPENAI";
 // src/ai/common/OpenAI_ImageValidation.ts
@@ -101,6 +134,28 @@ var OpenAiModelSchema = {
         organization: {
           type: "string",
           description: "OpenAI organization ID (optional)."
+        },
+        prompt_cache_key: {
+          type: "string",
+          description: "Overrides the auto-derived Responses prompt_cache_key. Requests sharing a key share a cached prefix; leave unset to derive a stable key from the model + system instructions + tools.",
+          "x-ui-hidden": true
+        },
+        reasoning: {
+          type: "object",
+          description: "Reasoning controls for reasoning-capable models (e.g. the GPT-5.6 sol/terra/luna family), sent on the Responses API.",
+          properties: {
+            effort: {
+              type: "string",
+              enum: ["none", "minimal", "low", "medium", "high", "xhigh", "max"],
+              description: "Reasoning effort. Higher effort trades latency and cost for quality."
+            },
+            mode: {
+              type: "string",
+              enum: ["pro"],
+              description: "Set to 'pro' for the quality-first pro configuration on supported models."
+            }
+          },
+          additionalProperties: false
         }
       },
       required: ["model_name"],
@@ -133,6 +188,10 @@ import { filterLabeledModelsByQuery } from "@workglow/ai/provider-utils";
 var OPENAI_FALLBACK = [
   { label: "gpt-image-2", value: "gpt-image-2" },
   { label: "dall-e-3", value: "dall-e-3" },
+  { label: "gpt-5.6", value: "gpt-5.6" },
+  { label: "gpt-5.6-sol", value: "gpt-5.6-sol" },
+  { label: "gpt-5.6-terra", value: "gpt-5.6-terra" },
+  { label: "gpt-5.6-luna", value: "gpt-5.6-luna" },
   { label: "gpt-5.5", value: "gpt-5.5" },
   { label: "gpt-5.4-mini", value: "gpt-5.4-mini" },
   { label: "gpt-5.4-nano", value: "gpt-5.4-nano" },
@@ -550,37 +609,49 @@ var OpenAI_ModelInfo_Stream = async (input, model, _signal, emit) => {
 };
 
 // src/ai/common/OpenAI_StructuredGeneration.ts
+import { isStrictCompatibleSchema } from "@workglow/ai/provider-utils";
 import { parsePartialJson } from "@workglow/util/worker";
 var OpenAI_StructuredGeneration_Stream = async (input, model, signal, emit, outputSchema) => {
   const client = await getClient(model);
   const modelName = getModelName(model);
   const schema = input.outputSchema ?? outputSchema;
-  const stream = await client.chat.completions.create({
+  const params = {
     model: modelName,
-    messages: [{ role: "user", content: input.prompt }],
-    response_format: {
-      type: "json_schema",
-      json_schema: {
+    input: input.prompt,
+    text: {
+      format: {
+        type: "json_schema",
         name: "structured_output",
         schema,
-        strict: true
+        strict: isStrictCompatibleSchema(schema)
       }
-    },
-    max_completion_tokens: input.maxTokens,
-    temperature: input.temperature,
-    stream: true
-  }, { signal });
+    }
+  };
+  if (input.maxTokens !== undefined)
+    params.max_output_tokens = input.maxTokens;
+  if (input.temperature !== undefined)
+    params.temperature = input.temperature;
+  finalizeResponsesRequest(model, params);
+  const stream = await client.responses.create({ ...params, stream: true }, { signal });
   let accumulatedJson = "";
-  for await (const chunk of stream) {
-    const delta = chunk.choices[0]?.delta?.content ?? "";
-    if (delta) {
-      accumulatedJson += delta;
-      const partial = parsePartialJson(accumulatedJson);
-      if (partial !== undefined) {
-        emit({ type: "object-delta", port: "object", objectDelta: partial });
+  let refusal = "";
+  for await (const event of stream) {
+    if (event.type === "response.output_text.delta") {
+      const delta = event.delta ?? "";
+      if (delta) {
+        accumulatedJson += delta;
+        const partial = parsePartialJson(accumulatedJson);
+        if (partial !== undefined) {
+          emit({ type: "object-delta", port: "object", objectDelta: partial });
+        }
       }
+    } else if (event.type === "response.refusal.delta") {
+      refusal += event.delta ?? "";
     }
   }
+  if (refusal) {
+    emit({ type: "refusal", refusal });
+  }
   let finalObject;
   try {
     finalObject = JSON.parse(accumulatedJson);
@@ -613,30 +684,34 @@ var OpenAI_TextEmbedding_Stream = async (input, model, signal, emit) => {
 };
 
 // src/ai/common/OpenAI_TextGeneration.ts
+import { accumulateOpenAIResponsesStream, buildResponsesInput } from "@workglow/ai/provider-utils";
 import { toOpenAIMessages } from "@workglow/ai/worker";
 import { getLogger as getLogger2 } from "@workglow/util/worker";
-function buildChatParams(input, model) {
+function buildResponsesParams(input, model) {
   const hasMessages = Array.isArray(input.messages) && input.messages.length > 0;
   const messages = hasMessages ? toOpenAIMessages({
     messages: input.messages,
     systemPrompt: input.systemPrompt,
     prompt: "",
     tools: []
-  }) : [{ role: "user", content: input.prompt }];
+  }) : undefined;
+  const { input: responsesInput, instructions } = buildResponsesInput({
+    messages,
+    prompt: hasMessages ? undefined : input.prompt,
+    systemPrompt: hasMessages ? undefined : input.systemPrompt
+  });
   const params = {
     model: getModelName(model),
-    messages
+    input: responsesInput
   };
+  if (instructions !== undefined)
+    params.instructions = instructions;
   if (input.maxTokens !== undefined)
-    params.max_completion_tokens = input.maxTokens;
+    params.max_output_tokens = input.maxTokens;
   if (input.temperature !== undefined)
     params.temperature = input.temperature;
   if (input.topP !== undefined)
     params.top_p = input.topP;
-  if (input.frequencyPenalty !== undefined)
-    params.frequency_penalty = input.frequencyPenalty;
-  if (input.presencePenalty !== undefined)
-    params.presence_penalty = input.presencePenalty;
   return params;
 }
 var OpenAI_TextGeneration_Stream = async (input, model, signal, emit) => {
@@ -645,14 +720,9 @@ var OpenAI_TextGeneration_Stream = async (input, model, signal, emit) => {
   logger.time(timerLabel, { model: getModelName(model) });
   try {
     const client = await getClient(model);
-    const params = buildChatParams(input, model);
-    const stream = await client.chat.completions.create({ ...params, stream: true }, { signal });
-    for await (const chunk of stream) {
-      const delta = chunk.choices?.[0]?.delta?.content ?? "";
-      if (delta) {
-        emit({ type: "text-delta", port: "text", textDelta: delta });
-      }
-    }
+    const params = finalizeResponsesRequest(model, buildResponsesParams(input, model));
+    const stream = await client.responses.create({ ...params, stream: true }, { signal });
+    await accumulateOpenAIResponsesStream(stream, emit);
     emit({ type: "finish", data: {} });
   } finally {
     logger.timeEnd(timerLabel, { model: getModelName(model) });
@@ -660,70 +730,66 @@ var OpenAI_TextGeneration_Stream = async (input, model, signal, emit) => {
 };
 
 // src/ai/common/OpenAI_TextRewriter.ts
+import { accumulateOpenAIResponsesStream as accumulateOpenAIResponsesStream2 } from "@workglow/ai/provider-utils";
 var OpenAI_TextRewriter_Stream = async (input, model, signal, emit) => {
   const client = await getClient(model);
-  const modelName = getModelName(model);
-  const stream = await client.chat.completions.create({
-    model: modelName,
-    messages: [
-      { role: "system", content: input.prompt },
-      { role: "user", content: input.text }
-    ],
-    stream: true
-  }, { signal });
-  for await (const chunk of stream) {
-    const delta = chunk.choices[0]?.delta?.content ?? "";
-    if (delta) {
-      emit({ type: "text-delta", port: "text", textDelta: delta });
-    }
-  }
+  const params = {
+    model: getModelName(model),
+    instructions: input.prompt,
+    input: input.text
+  };
+  finalizeResponsesRequest(model, params);
+  const stream = await client.responses.create({ ...params, stream: true }, { signal });
+  await accumulateOpenAIResponsesStream2(stream, emit);
   emit({ type: "finish", data: {} });
 };
 
 // src/ai/common/OpenAI_TextSummary.ts
+import { accumulateOpenAIResponsesStream as accumulateOpenAIResponsesStream3 } from "@workglow/ai/provider-utils";
 var OpenAI_TextSummary_Stream = async (input, model, signal, emit) => {
   const client = await getClient(model);
-  const modelName = getModelName(model);
-  const stream = await client.chat.completions.create({
-    model: modelName,
-    messages: [
-      { role: "system", content: "Summarize the following text concisely." },
-      { role: "user", content: input.text }
-    ],
-    stream: true
-  }, { signal });
-  for await (const chunk of stream) {
-    const delta = chunk.choices[0]?.delta?.content ?? "";
-    if (delta) {
-      emit({ type: "text-delta", port: "text", textDelta: delta });
-    }
-  }
+  const params = {
+    model: getModelName(model),
+    instructions: "Summarize the following text concisely.",
+    input: input.text
+  };
+  finalizeResponsesRequest(model, params);
+  const stream = await client.responses.create({ ...params, stream: true }, { signal });
+  await accumulateOpenAIResponsesStream3(stream, emit);
   emit({ type: "finish", data: {} });
 };
 
 // src/ai/common/OpenAI_ToolCalling.ts
 import {
-  accumulateOpenAIStream,
-  buildOpenAITools,
-  mapOpenAIToolChoice
+  accumulateOpenAIResponsesStream as accumulateOpenAIResponsesStream4,
+  buildResponsesInput as buildResponsesInput2,
+  buildResponsesTools,
+  mapResponsesToolChoice
 } from "@workglow/ai/provider-utils";
 import { filterValidToolCalls, toOpenAIMessages as toOpenAIMessages2 } from "@workglow/ai/worker";
 var OpenAI_ToolCalling_Stream = async (input, model, signal, emit) => {
   const client = await getClient(model);
   const modelName = getModelName(model);
-  const tools = buildOpenAITools(input.tools);
-  const messages = toOpenAIMessages2(input);
-  const toolChoice = mapOpenAIToolChoice(input.toolChoice, true);
-  const stream = await client.chat.completions.create({
+  const tools = buildResponsesTools(input.tools);
+  const { input: responsesInput, instructions } = buildResponsesInput2({
+    messages: toOpenAIMessages2(input)
+  });
+  const toolChoice = mapResponsesToolChoice(input.toolChoice);
+  const params = {
     model: modelName,
-    messages,
-    max_completion_tokens: input.maxTokens,
-    temperature: input.temperature,
-    stream: true,
+    input: responsesInput,
     tools,
     tool_choice: toolChoice
-  }, { signal });
-  await accumulateOpenAIStream(stream, (event) => {
+  };
+  if (instructions !== undefined)
+    params.instructions = instructions;
+  if (input.maxTokens !== undefined)
+    params.max_output_tokens = input.maxTokens;
+  if (input.temperature !== undefined)
+    params.temperature = input.temperature;
+  finalizeResponsesRequest(model, params);
+  const stream = await client.responses.create({ ...params, stream: true }, { signal });
+  await accumulateOpenAIResponsesStream4(stream, (event) => {
     if (event.type === "object-delta" && event.port === "toolCalls") {
       const validated = filterValidToolCalls(event.objectDelta, input.tools);
       if (validated.length > 0) {
@@ -758,7 +824,10 @@ var OPENAI_PREVIEW_TASKS = {
 var _testOnly = {
   OpenAiQueuedProvider,
   OPENAI_RUN_FN_SPECS,
-  OPENAI_RUN_FNS
+  OPENAI_RUN_FNS,
+  getReasoningConfig,
+  resolvePromptCacheKey,
+  isStrictCompatibleSchema
 };
 export {
   registerOpenAiImageValidator,
@@ -772,4 +841,4 @@ export {
   OPENAI
 };
 
-//# debugId=5A2D4E4E752494BC64756E2164756E21
+//# debugId=D935DEB21E5CE83764756E2164756E21