@workglow/openai 0.3.38 → 0.3.39

package/dist/ai-runtime.js

@@ -6,8 +6,25 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
+// src/ai/common/OpenAI_CacheCheckpoint.ts
+import {
+  buildResponsesInput,
+  buildResponsesTools,
+  mapOpenAIResponsesUsage
+} from "@workglow/ai/provider-utils";
+import { promptToTailMessages, toOpenAIMessages } from "@workglow/ai/worker";
+
 // src/ai/common/OpenAI_Client.ts
+import { isModelEffort } from "@workglow/ai";
 import { isBrowserLike, resolveApiKey, validateProviderBaseUrl } from "@workglow/ai/provider-utils";
+var EFFORT_TO_OPENAI = {
+  none: "none",
+  low: "low",
+  medium: "medium",
+  high: "high",
+  extra: "xhigh",
+  ultra: "max"
+};
 var OPENAI_ALLOWED_HOSTS = ["api.openai.com", ".openai.azure.com"];
 var _loadPromise;
 async function loadOpenAISDK() {
@@ -17,7 +34,16 @@ async function loadOpenAISDK() {
   });
   return _loadPromise;
 }
+var _testClient;
+function setOpenAIClientForTests(client) {
+  _testClient = client;
+}
+var _testOnly = {
+  setOpenAIClientForTests
+};
 async function getClient(model) {
+  if (_testClient)
+    return _testClient;
   const OpenAI = await loadOpenAISDK();
   const config = model?.provider_config;
   const apiKey = resolveApiKey({
@@ -51,10 +77,13 @@ function getModelName(model) {
 }
 function getReasoningConfig(model) {
   const reasoning = model?.provider_config?.reasoning;
-  if (!reasoning || reasoning.effort === undefined && reasoning.mode === undefined) {
-    return;
+  if (reasoning && (reasoning.effort !== undefined || reasoning.mode !== undefined)) {
+    return reasoning;
+  }
+  if (isModelEffort(model?.effort)) {
+    return { effort: EFFORT_TO_OPENAI[model.effort] };
   }
-  return reasoning;
+  return;
 }
 function fnv1aHex(input) {
   let hash = 2166136261;
@@ -79,10 +108,54 @@ function finalizeResponsesRequest(model, params) {
   const reasoning = getReasoningConfig(model);
   if (reasoning !== undefined)
     params.reasoning = reasoning;
+  else if (params.temperature !== undefined)
+    params.reasoning = { effort: "none" };
   params.prompt_cache_key = resolvePromptCacheKey(model, params);
   return params;
 }
 
+// src/ai/common/OpenAI_CacheCheckpoint.ts
+function mergeOpenAICheckpointPrefix(session, input) {
+  const prefix = session?.prefix;
+  if (!prefix)
+    return;
+  const tail = Array.isArray(input.messages) && input.messages.length > 0 ? input.messages : promptToTailMessages(input.prompt);
+  return {
+    messages: [...prefix.messages ?? [], ...tail],
+    systemPrompt: input.systemPrompt || prefix.systemPrompt,
+    tools: input.tools && input.tools.length > 0 ? input.tools : prefix.tools
+  };
+}
+var OpenAI_CacheCheckpoint_Stream = async (_input, model, signal, emit, _outputSchema, session) => {
+  const prefix = session?.prefix ?? {};
+  const client = await getClient(model);
+  const messages = toOpenAIMessages({
+    messages: prefix.messages ?? [],
+    systemPrompt: prefix.systemPrompt,
+    prompt: ".",
+    tools: []
+  });
+  const { input: responsesInput, instructions } = buildResponsesInput({ messages });
+  const params = {
+    model: getModelName(model),
+    input: responsesInput,
+    max_output_tokens: 16
+  };
+  if (instructions !== undefined)
+    params.instructions = instructions;
+  if (prefix.tools && prefix.tools.length > 0) {
+    params.tools = buildResponsesTools(prefix.tools);
+  }
+  finalizeResponsesRequest(model, params);
+  const response = await client.responses.create(params, { signal });
+  const usage = mapOpenAIResponsesUsage(response?.usage);
+  emit({
+    type: "finish",
+    data: { checkpoint: session?.sessionId ?? "" },
+    ...usage ? { usage } : {}
+  });
+};
+
 // src/ai/registerOpenAiInline.ts
 import { registerProviderInline } from "@workglow/ai/provider-utils";
 
@@ -117,6 +190,7 @@ var OPENAI_IMAGE_EDITING = ["image.editing"];
 var OPENAI_COUNT_TOKENS = ["model.count-tokens"];
 var OPENAI_MODEL_SEARCH = ["model.search"];
 var OPENAI_MODEL_INFO = ["model.info"];
+var OPENAI_CACHE_CHECKPOINT = ["cache.checkpoint"];
 var OPENAI_CAPABILITY_SETS = [
   OPENAI_TEXT_GENERATION,
   OPENAI_TOOL_USE,
@@ -128,7 +202,8 @@ var OPENAI_CAPABILITY_SETS = [
   OPENAI_IMAGE_EDITING,
   OPENAI_COUNT_TOKENS,
   OPENAI_MODEL_SEARCH,
-  OPENAI_MODEL_INFO
+  OPENAI_MODEL_INFO,
+  OPENAI_CACHE_CHECKPOINT
 ];
 
 // src/ai/common/OpenAI_CountTokens.ts
@@ -348,13 +423,54 @@ var OPENAI_EMBEDDING_DIMENSIONS = {
   "text-embedding-3-large": { native_dimensions: 3072, mrl: true },
   "text-embedding-ada-002": { native_dimensions: 1536, mrl: false }
 };
-var OpenAI_ModelInfo_Stream = async (input, model, _signal, emit) => {
+function modelNameOf(model) {
+  const name = model?.provider_config?.model_name;
+  if (!name) {
+    throw new Error("Missing model name in provider_config.model_name.");
+  }
+  return name;
+}
+function isNotFoundError(err) {
+  if (!err || typeof err !== "object")
+    return false;
+  const status = err.status;
+  const code = err.code;
+  const statusCode = err.statusCode;
+  return status === 404 || statusCode === 404 || code === "model_not_found";
+}
+async function assertOpenAiModelExists(model, signal) {
+  const modelName = modelNameOf(model);
+  const client = await getClient(model);
+  try {
+    await client.models.retrieve(modelName, signal ? { signal } : undefined);
+  } catch (err) {
+    if (isNotFoundError(err)) {
+      throw new Error(`${OPENAI} model "${modelName}" was not found (provider API returned not found)`);
+    }
+    throw err;
+  }
+  return modelName;
+}
+function remoteInfoBase(input) {
+  return {
+    model: input.model,
+    is_local: false,
+    is_remote: true,
+    supports_browser: true,
+    supports_node: true,
+    is_cached: false,
+    is_loaded: false,
+    file_sizes: null
+  };
+}
+var OpenAI_ModelInfo_Stream = async (input, model, signal, emit) => {
+  const modelName = await assertOpenAiModelExists(model, signal);
+  const base = remoteInfoBase(input);
   if (input.detail === "dimensions") {
     const pc = model?.provider_config;
     let native_dimensions = typeof pc?.native_dimensions === "number" ? pc.native_dimensions : undefined;
     let mrl = typeof pc?.mrl === "boolean" ? pc.mrl : undefined;
     if (native_dimensions === undefined) {
-      const modelName = pc?.model_name ?? "";
       const known = OPENAI_EMBEDDING_DIMENSIONS[modelName];
       if (known) {
         native_dimensions = known.native_dimensions;
@@ -364,33 +480,14 @@ var OpenAI_ModelInfo_Stream = async (input, model, _signal, emit) => {
     emit({
       type: "finish",
       data: {
-        model: input.model,
-        is_local: false,
-        is_remote: true,
-        supports_browser: true,
-        supports_node: true,
-        is_cached: false,
-        is_loaded: false,
-        file_sizes: null,
+        ...base,
         ...native_dimensions !== undefined ? { native_dimensions } : {},
         ...mrl !== undefined ? { mrl } : {}
       }
     });
     return;
   }
-  emit({
-    type: "finish",
-    data: {
-      model: input.model,
-      is_local: false,
-      is_remote: true,
-      supports_browser: true,
-      supports_node: true,
-      is_cached: false,
-      is_loaded: false,
-      file_sizes: null
-    }
-  });
+  emit({ type: "finish", data: base });
 };
 
 // src/ai/common/OpenAI_ModelSearch.ts
@@ -468,8 +565,13 @@ var OpenAI_ModelSearch_Stream = async (input, _model, _signal, emit) => {
 };
 
 // src/ai/common/OpenAI_StructuredGeneration.ts
-import { firstNonStrictReason, isStrictCompatibleSchema } from "@workglow/ai/provider-utils";
-import { parsePartialJson } from "@workglow/util/worker";
+import {
+  createEstimatedOutputUsageReporter,
+  firstNonStrictReason,
+  isStrictCompatibleSchema,
+  mapOpenAIResponsesUsage as mapOpenAIResponsesUsage2
+} from "@workglow/ai/provider-utils";
+import { createPartialJsonStream } from "@workglow/util/worker";
 
 // src/ai/common/OpenAI_ResponsesWarnings.ts
 import { getLogger } from "@workglow/util/worker";
@@ -520,15 +622,20 @@ var OpenAI_StructuredGeneration_Stream = async (input, model, signal, emit, outp
   if (input.temperature !== undefined)
     params.temperature = input.temperature;
   finalizeResponsesRequest(model, params);
+  const provisionalUsage = createEstimatedOutputUsageReporter(emit);
+  provisionalUsage.onPrompt(typeof input.prompt === "string" ? input.prompt : "");
   const stream = await client.responses.create({ ...params, stream: true }, { signal });
-  let accumulatedJson = "";
+  const json = createPartialJsonStream();
   let refusal = "";
+  let usage;
   for await (const event of stream) {
-    if (event.type === "response.output_text.delta") {
+    if (event.type === "response.completed" || event.type === "response.incomplete" || event.type === "response.failed") {
+      usage = mapOpenAIResponsesUsage2(event.response?.usage) ?? usage;
+    } else if (event.type === "response.output_text.delta") {
       const delta = event.delta ?? "";
       if (delta) {
-        accumulatedJson += delta;
-        const partial = parsePartialJson(accumulatedJson);
+        provisionalUsage.onText(delta);
+        const partial = json.push(delta);
         if (partial !== undefined) {
           emit({ type: "object-delta", port: "object", objectDelta: partial });
         }
@@ -537,19 +644,19 @@ var OpenAI_StructuredGeneration_Stream = async (input, model, signal, emit, outp
       refusal += event.delta ?? "";
     }
   }
+  provisionalUsage.flush();
   if (refusal) {
     emit({ type: "refusal", refusal });
   }
-  let finalObject;
-  try {
-    finalObject = JSON.parse(accumulatedJson);
-  } catch {
-    finalObject = parsePartialJson(accumulatedJson) ?? {};
-  }
-  emit({ type: "finish", data: { object: finalObject } });
+  emit({
+    type: "finish",
+    data: { object: json.finishObject() },
+    usage
+  });
 };
 
 // src/ai/common/OpenAI_TextEmbedding.ts
+import { toUsageCount, usageOrUndefined } from "@workglow/ai/provider-utils";
 import { getLogger as getLogger2 } from "@workglow/util/worker";
 var OpenAI_TextEmbedding_Stream = async (input, model, signal, emit) => {
   const logger = getLogger2();
@@ -565,25 +672,41 @@ var OpenAI_TextEmbedding_Stream = async (input, model, signal, emit) => {
     const result = Array.isArray(input.text) ? {
       vector: response.data.map((item) => new Float32Array(item.embedding))
     } : { vector: new Float32Array(response.data[0].embedding) };
-    emit({ type: "finish", data: result });
+    const rawUsage = response.usage;
+    const usage = usageOrUndefined({
+      input: toUsageCount(rawUsage?.prompt_tokens),
+      output: undefined,
+      cached: undefined,
+      cacheWrite: undefined,
+      reasoning: undefined,
+      total: toUsageCount(rawUsage?.total_tokens),
+      extra: undefined
+    });
+    emit({ type: "finish", data: result, usage });
   } finally {
     logger.timeEnd(timerLabel, { model: getModelName(model) });
   }
 };
 
 // src/ai/common/OpenAI_TextGeneration.ts
-import { accumulateOpenAIResponsesStream, buildResponsesInput } from "@workglow/ai/provider-utils";
-import { toOpenAIMessages } from "@workglow/ai/worker";
+import {
+  accumulateOpenAIResponsesStream,
+  buildResponsesInput as buildResponsesInput2,
+  buildResponsesTools as buildResponsesTools2,
+  createEstimatedOutputUsageReporter as createEstimatedOutputUsageReporter2,
+  promptTextForResponsesUsageEstimate
+} from "@workglow/ai/provider-utils";
+import { toOpenAIMessages as toOpenAIMessages2 } from "@workglow/ai/worker";
 import { getLogger as getLogger3 } from "@workglow/util/worker";
 function buildResponsesParams(input, model) {
   const hasMessages = Array.isArray(input.messages) && input.messages.length > 0;
-  const messages = hasMessages ? toOpenAIMessages({
+  const messages = hasMessages ? toOpenAIMessages2({
     messages: input.messages,
     systemPrompt: input.systemPrompt,
     prompt: "",
     tools: []
   }) : undefined;
-  const { input: responsesInput, instructions } = buildResponsesInput({
+  const { input: responsesInput, instructions } = buildResponsesInput2({
     messages,
     prompt: hasMessages ? undefined : input.prompt,
     systemPrompt: hasMessages ? undefined : input.systemPrompt
@@ -609,23 +732,38 @@ function buildResponsesParams(input, model) {
   }
   return params;
 }
-var OpenAI_TextGeneration_Stream = async (input, model, signal, emit) => {
+var OpenAI_TextGeneration_Stream = async (input, model, signal, emit, _outputSchema, sessionContext) => {
   const logger = getLogger3();
   const timerLabel = `openai:TextGeneration:${getModelName(model)}`;
   logger.time(timerLabel, { model: getModelName(model) });
   try {
     const client = await getClient(model);
-    const params = finalizeResponsesRequest(model, buildResponsesParams(input, model));
+    const unified = input;
+    const merged = mergeOpenAICheckpointPrefix(sessionContext, unified);
+    const effective = merged ? { ...unified, messages: merged.messages, systemPrompt: merged.systemPrompt, prompt: "" } : unified;
+    const params = buildResponsesParams(effective, model);
+    if (merged?.tools && merged.tools.length > 0) {
+      params.tools = buildResponsesTools2(merged.tools);
+    }
+    finalizeResponsesRequest(model, params);
+    const promptText = promptTextForResponsesUsageEstimate(params);
+    createEstimatedOutputUsageReporter2(emit).onPrompt(promptText);
     const stream = await client.responses.create({ ...params, stream: true }, { signal });
-    await accumulateOpenAIResponsesStream(stream, emit);
-    emit({ type: "finish", data: {} });
+    const usage = await accumulateOpenAIResponsesStream(stream, emit, {
+      promptText
+    });
+    emit({ type: "finish", data: {}, usage });
   } finally {
     logger.timeEnd(timerLabel, { model: getModelName(model) });
   }
 };
 
 // src/ai/common/OpenAI_TextRewriter.ts
-import { accumulateOpenAIResponsesStream as accumulateOpenAIResponsesStream2 } from "@workglow/ai/provider-utils";
+import {
+  accumulateOpenAIResponsesStream as accumulateOpenAIResponsesStream2,
+  createEstimatedOutputUsageReporter as createEstimatedOutputUsageReporter3,
+  promptTextForResponsesUsageEstimate as promptTextForResponsesUsageEstimate2
+} from "@workglow/ai/provider-utils";
 var OpenAI_TextRewriter_Stream = async (input, model, signal, emit) => {
   const client = await getClient(model);
   const params = {
@@ -634,13 +772,21 @@ var OpenAI_TextRewriter_Stream = async (input, model, signal, emit) => {
     input: input.text
   };
   finalizeResponsesRequest(model, params);
+  const promptText = promptTextForResponsesUsageEstimate2(params);
+  createEstimatedOutputUsageReporter3(emit).onPrompt(promptText);
   const stream = await client.responses.create({ ...params, stream: true }, { signal });
-  await accumulateOpenAIResponsesStream2(stream, emit);
-  emit({ type: "finish", data: {} });
+  const usage = await accumulateOpenAIResponsesStream2(stream, emit, {
+    promptText
+  });
+  emit({ type: "finish", data: {}, usage });
 };
 
 // src/ai/common/OpenAI_TextSummary.ts
-import { accumulateOpenAIResponsesStream as accumulateOpenAIResponsesStream3 } from "@workglow/ai/provider-utils";
+import {
+  accumulateOpenAIResponsesStream as accumulateOpenAIResponsesStream3,
+  createEstimatedOutputUsageReporter as createEstimatedOutputUsageReporter4,
+  promptTextForResponsesUsageEstimate as promptTextForResponsesUsageEstimate3
+} from "@workglow/ai/provider-utils";
 var OpenAI_TextSummary_Stream = async (input, model, signal, emit) => {
   const client = await getClient(model);
   const params = {
@@ -649,25 +795,38 @@ var OpenAI_TextSummary_Stream = async (input, model, signal, emit) => {
     input: input.text
   };
   finalizeResponsesRequest(model, params);
+  const promptText = promptTextForResponsesUsageEstimate3(params);
+  createEstimatedOutputUsageReporter4(emit).onPrompt(promptText);
   const stream = await client.responses.create({ ...params, stream: true }, { signal });
-  await accumulateOpenAIResponsesStream3(stream, emit);
-  emit({ type: "finish", data: {} });
+  const usage = await accumulateOpenAIResponsesStream3(stream, emit, {
+    promptText
+  });
+  emit({ type: "finish", data: {}, usage });
 };
 
 // src/ai/common/OpenAI_ToolCalling.ts
 import {
   accumulateOpenAIResponsesStream as accumulateOpenAIResponsesStream4,
-  buildResponsesInput as buildResponsesInput2,
-  buildResponsesTools,
-  mapResponsesToolChoice
+  buildResponsesInput as buildResponsesInput3,
+  buildResponsesTools as buildResponsesTools3,
+  createEstimatedOutputUsageReporter as createEstimatedOutputUsageReporter5,
+  mapResponsesToolChoice,
+  promptTextForResponsesUsageEstimate as promptTextForResponsesUsageEstimate4
 } from "@workglow/ai/provider-utils";
-import { filterValidToolCalls, toOpenAIMessages as toOpenAIMessages2 } from "@workglow/ai/worker";
-var OpenAI_ToolCalling_Stream = async (input, model, signal, emit) => {
+import { filterValidToolCalls, toOpenAIMessages as toOpenAIMessages3 } from "@workglow/ai/worker";
+var OpenAI_ToolCalling_Stream = async (input, model, signal, emit, _outputSchema, sessionContext) => {
   const client = await getClient(model);
   const modelName = getModelName(model);
-  const tools = buildResponsesTools(input.tools);
-  const { input: responsesInput, instructions } = buildResponsesInput2({
-    messages: toOpenAIMessages2(input)
+  const merged = mergeOpenAICheckpointPrefix(sessionContext, input);
+  const toolDefinitions = merged?.tools ?? input.tools;
+  const tools = buildResponsesTools3(toolDefinitions);
+  const { input: responsesInput, instructions } = buildResponsesInput3({
+    messages: toOpenAIMessages3(merged ? {
+      ...input,
+      messages: merged.messages,
+      systemPrompt: merged.systemPrompt,
+      prompt: ""
+    } : input)
   });
   const toolChoice = mapResponsesToolChoice(input.toolChoice);
   const params = {
@@ -683,18 +842,20 @@ var OpenAI_ToolCalling_Stream = async (input, model, signal, emit) => {
   if (input.temperature !== undefined)
     params.temperature = input.temperature;
   finalizeResponsesRequest(model, params);
+  const promptText = promptTextForResponsesUsageEstimate4(params);
+  createEstimatedOutputUsageReporter5(emit).onPrompt(promptText);
   const stream = await client.responses.create({ ...params, stream: true }, { signal });
-  await accumulateOpenAIResponsesStream4(stream, (event) => {
+  const usage = await accumulateOpenAIResponsesStream4(stream, (event) => {
     if (event.type === "object-delta" && event.port === "toolCalls") {
-      const validated = filterValidToolCalls(event.objectDelta, input.tools);
+      const validated = filterValidToolCalls(event.objectDelta, toolDefinitions);
       if (validated.length > 0) {
         emit({ type: "object-delta", port: "toolCalls", objectDelta: validated });
       }
       return;
     }
     emit(event);
-  });
-  emit({ type: "finish", data: { text: "", toolCalls: [] } });
+  }, { promptText });
+  emit({ type: "finish", data: { text: "", toolCalls: [] }, usage });
 };
 
 // src/ai/common/OpenAI_JobRunFns.ts
@@ -709,7 +870,8 @@ var OPENAI_RUN_FNS = [
   { serves: OPENAI_IMAGE_EDITING, runFn: OpenAI_ImageEdit_Stream },
   { serves: OPENAI_COUNT_TOKENS, runFn: OpenAI_CountTokens_Stream },
   { serves: OPENAI_MODEL_SEARCH, runFn: OpenAI_ModelSearch_Stream },
-  { serves: OPENAI_MODEL_INFO, runFn: OpenAI_ModelInfo_Stream }
+  { serves: OPENAI_MODEL_INFO, runFn: OpenAI_ModelInfo_Stream },
+  { serves: OPENAI_CACHE_CHECKPOINT, runFn: OpenAI_CacheCheckpoint_Stream }
 ];
 var OPENAI_PREVIEW_TASKS = {
   CountTokensTask: OpenAI_CountTokens_Preview
@@ -742,6 +904,7 @@ function inferOpenAiCapabilities(model) {
       "text.summary",
       "tool-use",
       "json-mode",
+      "cache.checkpoint",
       "model.count-tokens",
       "model.info",
       "model.search"
@@ -803,12 +966,15 @@ export {
   resolvePromptCacheKey,
   registerOpenAiWorker,
   registerOpenAiInline,
+  mergeOpenAICheckpointPrefix,
   loadOpenAISDK,
   getReasoningConfig,
   getModelName,
   getClient,
   finalizeResponsesRequest,
+  _testOnly,
+  OpenAI_CacheCheckpoint_Stream,
   OPENAI_ALLOWED_HOSTS
 };
 
-//# debugId=9CC090871A0DB04F64756E2164756E21
+//# debugId=76D4D07BFEAF6C7464756E2164756E21