@kenkaiiii/gg-ai 4.3.32 → 4.3.34

package/dist/index.cjs

@@ -498,6 +498,7 @@ function streamAnthropic(options) {
 async function* runStream(options) {
   const client = createClient(options);
   const isOAuth = options.apiKey?.startsWith("sk-ant-oat");
+  const useStreaming = options.streaming !== false;
   const cacheControl = toAnthropicCacheControl(options.cacheRetention, options.baseUrl);
   const { system: rawSystem, messages } = toAnthropicMessages(options.messages, cacheControl);
   const system = isOAuth ? [
@@ -543,7 +544,7 @@ async function* runStream(options) {
       ];
       return contextEdits.length ? { context_management: { edits: contextEdits } } : {};
     })(),
-    stream: true
+    stream: useStreaming
   };
   const hasAdaptiveThinking = options.model.includes("opus-4-7") || options.model.includes("opus-4.7") || options.model.includes("opus-4-6") || options.model.includes("opus-4.6") || options.model.includes("sonnet-4-6") || options.model.includes("sonnet-4.6");
   const betaHeaders = [
@@ -553,10 +554,23 @@ async function* runStream(options) {
     "fine-grained-tool-streaming-2025-05-14",
     ...!hasAdaptiveThinking ? ["interleaved-thinking-2025-05-14"] : []
   ];
-  const stream2 = client.messages.stream(params, {
+  const requestOptions = {
     signal: options.signal ?? void 0,
     ...betaHeaders.length ? { headers: { "anthropic-beta": betaHeaders.join(",") } } : {}
-  });
+  };
+  if (!useStreaming) {
+    try {
+      const message = await client.messages.create(
+        { ...params, stream: false },
+        requestOptions
+      );
+      yield* synthesizeEventsFromMessage(message);
+      return messageToResponse(message);
+    } catch (err) {
+      throw toError(err);
+    }
+  }
+  const stream2 = client.messages.stream(params, requestOptions);
   const contentParts = [];
   const blocks = /* @__PURE__ */ new Map();
   let inputTokens = 0;
@@ -749,6 +763,105 @@ async function* runStream(options) {
   yield { type: "done", stopReason: normalizedStop };
   return response;
 }
+function* synthesizeEventsFromMessage(message) {
+  for (const block of message.content) {
+    const blk = block;
+    const type = blk.type;
+    if (type === "text") {
+      const text = blk.text;
+      if (text) yield { type: "text_delta", text };
+    } else if (type === "thinking") {
+      const text = blk.thinking;
+      if (text) yield { type: "thinking_delta", text };
+    } else if (type === "tool_use") {
+      const argsJson = JSON.stringify(blk.input ?? {});
+      yield {
+        type: "toolcall_delta",
+        id: blk.id,
+        name: blk.name,
+        argsJson
+      };
+      yield {
+        type: "toolcall_done",
+        id: blk.id,
+        name: blk.name,
+        args: blk.input ?? {}
+      };
+    } else if (type === "server_tool_use") {
+      yield {
+        type: "server_toolcall",
+        id: blk.id,
+        name: blk.name,
+        input: blk.input
+      };
+    } else if (type === "web_search_tool_result") {
+      yield {
+        type: "server_toolresult",
+        toolUseId: blk.tool_use_id,
+        resultType: type,
+        data: blk
+      };
+    }
+  }
+  yield { type: "done", stopReason: normalizeAnthropicStopReason(message.stop_reason) };
+}
+function messageToResponse(message) {
+  const contentParts = [];
+  for (const block of message.content) {
+    const blk = block;
+    const type = blk.type;
+    if (type === "text") {
+      contentParts.push({ type: "text", text: blk.text });
+    } else if (type === "thinking") {
+      contentParts.push({
+        type: "thinking",
+        text: blk.thinking,
+        signature: blk.signature ?? ""
+      });
+    } else if (type === "tool_use") {
+      contentParts.push({
+        type: "tool_call",
+        id: blk.id,
+        name: blk.name,
+        args: blk.input ?? {}
+      });
+    } else if (type === "server_tool_use") {
+      contentParts.push({
+        type: "server_tool_call",
+        id: blk.id,
+        name: blk.name,
+        input: blk.input
+      });
+    } else if (type === "web_search_tool_result") {
+      contentParts.push({
+        type: "server_tool_result",
+        toolUseId: blk.tool_use_id,
+        resultType: type,
+        data: blk
+      });
+    } else {
+      contentParts.push({ type: "raw", data: blk });
+    }
+  }
+  const usage = message.usage;
+  const inputTokens = usage.input_tokens ?? 0;
+  const outputTokens = usage.output_tokens ?? 0;
+  const cacheRead = usage.cache_read_input_tokens;
+  const cacheWrite = usage.cache_creation_input_tokens;
+  return {
+    message: {
+      role: "assistant",
+      content: contentParts.length > 0 ? contentParts : ""
+    },
+    stopReason: normalizeAnthropicStopReason(message.stop_reason),
+    usage: {
+      inputTokens,
+      outputTokens,
+      ...cacheRead != null && { cacheRead },
+      ...cacheWrite != null && { cacheWrite }
+    }
+  };
+}
 function toError(err) {
   if (err instanceof import_sdk.default.APIError) {
     return new ProviderError("anthropic", err.message, {
@@ -776,6 +889,7 @@ function streamOpenAI(options) {
 }
 async function* runStream2(options) {
   const providerName = options.provider ?? "openai";
+  const useStreaming = options.streaming !== false;
   const client = createClient2(options);
   const usesThinkingParam = options.provider === "glm" || options.provider === "moonshot" || options.provider === "xiaomi";
   const messages = toOpenAIMessages(options.messages, {
@@ -787,7 +901,7 @@ async function* runStream2(options) {
   const params = {
     model: options.model,
     messages,
-    stream: true,
+    stream: useStreaming,
     ...options.maxTokens ? { max_completion_tokens: options.maxTokens } : {},
     ...effectiveTemp != null && !options.thinking ? { temperature: effectiveTemp } : {},
     ...options.topP != null ? { top_p: options.topP } : {},
@@ -795,7 +909,7 @@ async function* runStream2(options) {
     ...options.thinking && !usesThinkingParam ? { reasoning_effort: toOpenAIReasoningEffort(options.thinking) } : {},
     ...options.tools?.length ? { tools: toOpenAITools(options.tools) } : {},
     ...options.toolChoice && options.tools?.length ? { tool_choice: toOpenAIToolChoice(options.toolChoice) } : {},
-    stream_options: { include_usage: true }
+    ...useStreaming ? { stream_options: { include_usage: true } } : {}
   };
   if (options.provider === "openai" || options.provider === "moonshot") {
     const paramsAny = params;
@@ -823,6 +937,17 @@ async function* runStream2(options) {
 `
     );
   }
+  if (!useStreaming) {
+    try {
+      const completion = await client.chat.completions.create(params, {
+        signal: options.signal ?? void 0
+      });
+      yield* synthesizeEventsFromCompletion(completion, !!options.thinking);
+      return completionToResponse(completion);
+    } catch (err) {
+      throw toError2(err, providerName);
+    }
+  }
   let stream2;
   try {
     stream2 = await client.chat.completions.create(params, {
@@ -932,6 +1057,102 @@ async function* runStream2(options) {
   yield { type: "done", stopReason };
   return response;
 }
+function* synthesizeEventsFromCompletion(completion, thinkingEnabled) {
+  const choice = completion.choices?.[0];
+  if (!choice) {
+    yield { type: "done", stopReason: normalizeOpenAIStopReason(null) };
+    return;
+  }
+  const msg = choice.message;
+  const reasoning = msg.reasoning_content;
+  if (typeof reasoning === "string" && reasoning && thinkingEnabled) {
+    yield { type: "thinking_delta", text: reasoning };
+  }
+  if (typeof msg.content === "string" && msg.content) {
+    yield { type: "text_delta", text: msg.content };
+  }
+  const toolCalls = msg.tool_calls;
+  if (toolCalls) {
+    for (const tc of toolCalls) {
+      const argsJson = tc.function?.arguments ?? "";
+      if (argsJson) {
+        yield {
+          type: "toolcall_delta",
+          id: tc.id,
+          name: tc.function?.name ?? "",
+          argsJson
+        };
+      }
+      let args = {};
+      try {
+        args = JSON.parse(argsJson);
+      } catch {
+      }
+      yield {
+        type: "toolcall_done",
+        id: tc.id,
+        name: tc.function?.name ?? "",
+        args
+      };
+    }
+  }
+  yield { type: "done", stopReason: normalizeOpenAIStopReason(choice.finish_reason ?? null) };
+}
+function completionToResponse(completion) {
+  const choice = completion.choices?.[0];
+  const contentParts = [];
+  let textAccum = "";
+  if (choice) {
+    const msg = choice.message;
+    const reasoning = msg.reasoning_content;
+    if (typeof reasoning === "string" && reasoning) {
+      contentParts.push({ type: "thinking", text: reasoning });
+    }
+    if (typeof msg.content === "string" && msg.content) {
+      textAccum = msg.content;
+      contentParts.push({ type: "text", text: msg.content });
+    }
+    const toolCalls = msg.tool_calls;
+    if (toolCalls) {
+      for (const tc of toolCalls) {
+        let args = {};
+        try {
+          args = JSON.parse(tc.function?.arguments ?? "{}");
+        } catch {
+        }
+        const toolCall = {
+          type: "tool_call",
+          id: tc.id,
+          name: tc.function?.name ?? "",
+          args
+        };
+        contentParts.push(toolCall);
+      }
+    }
+  }
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let cacheRead = 0;
+  if (completion.usage) {
+    outputTokens = completion.usage.completion_tokens;
+    const details = completion.usage.prompt_tokens_details;
+    if (details?.cached_tokens) cacheRead = details.cached_tokens;
+    const usageAny = completion.usage;
+    if (!cacheRead && typeof usageAny.cached_tokens === "number" && usageAny.cached_tokens > 0) {
+      cacheRead = usageAny.cached_tokens;
+    }
+    inputTokens = completion.usage.prompt_tokens - cacheRead;
+  }
+  const stopReason = normalizeOpenAIStopReason(choice?.finish_reason ?? null);
+  return {
+    message: {
+      role: "assistant",
+      content: contentParts.length > 0 ? contentParts : textAccum
+    },
+    stopReason,
+    usage: { inputTokens, outputTokens, ...cacheRead > 0 && { cacheRead } }
+  };
+}
 function toError2(err, provider = "openai") {
   if (err instanceof import_openai.default.APIError) {
     let msg = err.message;