@code-yeongyu/senpi-ai 2026.7.28 → 2026.7.29-4

package/dist/api/openai-client-auth.d.ts

@@ -0,0 +1,7 @@
+import type { ProviderHeaders } from "../types.ts";
+export interface OpenAIClientAuth {
+    apiKey: string;
+    headers?: ProviderHeaders;
+}
+export declare function resolveOpenAIClientAuth(provider: string, apiKey: string | undefined, headers: ProviderHeaders | undefined): OpenAIClientAuth;
+//# sourceMappingURL=openai-client-auth.d.ts.map

package/dist/api/openai-client-auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-client-auth.d.ts","sourceRoot":"","sources":["../../src/api/openai-client-auth.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD,MAAM,WAAW,gBAAgB;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,eAAe,CAAC;CAC1B;AAED,wBAAgB,uBAAuB,CACtC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,OAAO,EAAE,eAAe,GAAG,SAAS,GAClC,gBAAgB,CAUlB"}

package/dist/api/openai-client-auth.js

@@ -0,0 +1,15 @@
+import { hasCredentialHeaders, hasHeader } from "../auth/headers.js";
+export function resolveOpenAIClientAuth(provider, apiKey, headers) {
+    if (apiKey)
+        return { apiKey, headers };
+    if (!hasCredentialHeaders(headers))
+        throw new Error(`No API key for provider: ${provider}`);
+    if (hasHeader(headers, "authorization") || hasHeader(headers, "cf-aig-authorization")) {
+        return { apiKey: "unused", headers };
+    }
+    return {
+        apiKey: "unused",
+        headers: { Authorization: null, ...headers },
+    };
+}
+//# sourceMappingURL=openai-client-auth.js.map

package/dist/api/openai-client-auth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-client-auth.js","sourceRoot":"","sources":["../../src/api/openai-client-auth.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAQrE,MAAM,UAAU,uBAAuB,CACtC,QAAgB,EAChB,MAA0B,EAC1B,OAAoC;IAEpC,IAAI,MAAM;QAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;IACvC,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,4BAA4B,QAAQ,EAAE,CAAC,CAAC;IAC5F,IAAI,SAAS,CAAC,OAAO,EAAE,eAAe,CAAC,IAAI,SAAS,CAAC,OAAO,EAAE,sBAAsB,CAAC,EAAE,CAAC;QACvF,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC;IACtC,CAAC;IACD,OAAO;QACN,MAAM,EAAE,QAAQ;QAChB,OAAO,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,GAAG,OAAO,EAAE;KAC5C,CAAC;AACH,CAAC","sourcesContent":["import { hasCredentialHeaders, hasHeader } from \"../auth/headers.ts\";\nimport type { ProviderHeaders } from \"../types.ts\";\n\nexport interface OpenAIClientAuth {\n\tapiKey: string;\n\theaders?: ProviderHeaders;\n}\n\nexport function resolveOpenAIClientAuth(\n\tprovider: string,\n\tapiKey: string | undefined,\n\theaders: ProviderHeaders | undefined,\n): OpenAIClientAuth {\n\tif (apiKey) return { apiKey, headers };\n\tif (!hasCredentialHeaders(headers)) throw new Error(`No API key for provider: ${provider}`);\n\tif (hasHeader(headers, \"authorization\") || hasHeader(headers, \"cf-aig-authorization\")) {\n\t\treturn { apiKey: \"unused\", headers };\n\t}\n\treturn {\n\t\tapiKey: \"unused\",\n\t\theaders: { Authorization: null, ...headers },\n\t};\n}\n"]}

package/dist/api/openai-completions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openai-completions.d.ts","sourceRoot":"","sources":["../../src/api/openai-completions.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,QAAQ,CAAC;AAC5B,OAAO,KAAK,EAOX,0BAA0B,EAI1B,MAAM,sCAAsC,CAAC;AAG9C,OAAO,KAAK,EAIX,OAAO,EAGP,KAAK,EAIL,mBAAmB,EAEnB,cAAc,EACd,aAAa,EAMb,MAAM,aAAa,CAAC;AAMrB,OAAO,EAEN,KAAK,+BAA+B,EACpC,MAAM,8BAA8B,CAAC;AA2BtC,OAAO,EACN,0BAA0B,IAAI,SAAS,EACvC,KAAK,+BAA+B,GACpC,MAAM,8BAA8B,CAAC;AA2NtC,MAAM,WAAW,wBAAyB,SAAQ,aAAa;IAC9D,UAAU,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,8BAA8B,CAAC;IACpE,eAAe,CAAC,EAAE,SAAS,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK,CAAC;CAC1E;AAED,MAAM,WAAW,iCAAiC;IACjD,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,0BAA0B,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACzD;AAwCD,eAAO,MAAM,MAAM,EAAE,cAAc,CAAC,oBAAoB,EAAE,wBAAwB,CAgbjF,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,cAAc,CAAC,oBAAoB,EAAE,mBAAmB,CAyBlF,CAAC;AA8XF,wBAAgB,eAAe,CAC9B,KAAK,EAAE,KAAK,CAAC,oBAAoB,CAAC,EAClC,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,+BAA+B,EACvC,OAAO,GAAE,iCAAsC,GAC7C,0BAA0B,EAAE,CAgS9B"}
+{"version":3,"file":"openai-completions.d.ts","sourceRoot":"","sources":["../../src/api/openai-completions.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,QAAQ,CAAC;AAC5B,OAAO,KAAK,EAOX,0BAA0B,EAI1B,MAAM,sCAAsC,CAAC;AAG9C,OAAO,KAAK,EAIX,OAAO,EAGP,KAAK,EAIL,mBAAmB,EAEnB,cAAc,EACd,aAAa,EAMb,MAAM,aAAa,CAAC;AAMrB,OAAO,EAEN,KAAK,+BAA+B,EACpC,MAAM,8BAA8B,CAAC;AA4BtC,OAAO,EACN,0BAA0B,IAAI,SAAS,EACvC,KAAK,+BAA+B,GACpC,MAAM,8BAA8B,CAAC;AA4MtC,MAAM,WAAW,wBAAyB,SAAQ,aAAa;IAC9D,UAAU,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,8BAA8B,CAAC;IACpE,eAAe,CAAC,EAAE,SAAS,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK,CAAC;CAC1E;AAED,MAAM,WAAW,iCAAiC;IACjD,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,0BAA0B,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACzD;AAwCD,eAAO,MAAM,MAAM,EAAE,cAAc,CAAC,oBAAoB,EAAE,wBAAwB,CA0fjF,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,cAAc,CAAC,oBAAoB,EAAE,mBAAmB,CAyBlF,CAAC;AA8XF,wBAAgB,eAAe,CAC9B,KAAK,EAAE,KAAK,CAAC,oBAAoB,CAAC,EAClC,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,+BAA+B,EACvC,OAAO,GAAE,iCAAsC,GAC7C,0BAA0B,EAAE,CAgS9B"}

package/dist/api/openai-completions.js

@@ -13,6 +13,7 @@ import { isForcedToolChoiceUnsupportedError, omitToolChoiceParam } from "../util
 import { normalizeToolParametersForMoonshot, normalizeToolParametersForOpenAICompat, } from "../utils/tool-schema-compat.js";
 import { appendGrammarToolInputJsonDelta, createGrammarToolInputProperties, getGrammarToolInput, resolveGrammarConstrainedSampling, resolveJsonSchemaStrictSampling, } from "./constrained-sampling.js";
 import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
+import { resolveOpenAIClientAuth } from "./openai-client-auth.js";
 import { clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
 import { applyExtraBody, buildBaseOptions, clampMaxForOpenAI, OPENAI_COMPLETIONS_RESERVED_BODY_KEYS, } from "./simple-options.js";
 import { transformMessages } from "./transform-messages.js";
@@ -103,23 +104,6 @@ function resolveReasoningEffort(thinkingLevelMap, effort) {
  * This is needed because Anthropic (via proxy) requires the tools param
  * to be present when messages include tool_calls or tool role messages.
  */
-function hasHeader(headers, name) {
-    if (!headers)
-        return false;
-    const expected = name.toLowerCase();
-    for (const [key, value] of Object.entries(headers)) {
-        if (key.toLowerCase() === expected && value !== null && value.trim().length > 0)
-            return true;
-    }
-    return false;
-}
-function getClientApiKey(provider, apiKey, headers) {
-    if (apiKey)
-        return apiKey;
-    if (hasHeader(headers, "authorization") || hasHeader(headers, "cf-aig-authorization"))
-        return "unused";
-    throw new Error(`No API key for provider: ${provider}`);
-}
 function hasToolHistory(messages) {
     for (const msg of messages) {
         if (msg.role === "toolResult") {
@@ -217,12 +201,12 @@ export const stream = (model, context, options) => {
             timestamp: Date.now(),
         };
         try {
-            const apiKey = getClientApiKey(model.provider, options?.apiKey, options?.headers);
+            const clientAuth = resolveOpenAIClientAuth(model.provider, options?.apiKey, options?.headers);
             const compat = getCompat(model);
             const grammarToolInputProperties = createGrammarToolInputProperties(context.tools, compat.supportsOpenAIGrammarTools);
             const cacheRetention = resolveCacheRetention(options?.cacheRetention ?? model.cacheRetention, options?.env);
             const cacheSessionId = cacheRetention === "none" ? undefined : options?.sessionId;
-            const client = createClient(model, context, apiKey, options?.headers, cacheSessionId, compat);
+            const client = createClient(model, context, clientAuth.apiKey, clientAuth.headers, cacheSessionId, compat);
             let params = buildParams(model, context, options, compat, cacheRetention, grammarToolInputProperties);
             const nextParams = await options?.onPayload?.(params, model);
             if (nextParams !== undefined) {
@@ -256,7 +240,12 @@ export const stream = (model, context, options) => {
             stream.push({ type: "start", partial: output });
             let textBlock = null;
             let thinkingBlock = null;
+            let activeBlock = null;
+            let deferMixedEvents = false;
             let hasFinishReason = false;
+            const deferredTextDeltas = [];
+            const deferredThinkingDeltas = [];
+            const deferredToolCallDeltas = new Map();
             const toolCallBlocksByIndex = new Map();
             const toolCallBlocksById = new Map();
             const pendingReasoningDetailsByToolCallId = new Map();
@@ -326,23 +315,47 @@ export const stream = (model, context, options) => {
                     });
                 }
             };
+            const finishActiveBlock = () => {
+                if (!activeBlock)
+                    return;
+                finishBlock(activeBlock);
+                activeBlock = null;
+            };
             const ensureTextBlock = () => {
                 if (!textBlock) {
+                    if (!deferMixedEvents) {
+                        finishActiveBlock();
+                        thinkingBlock = null;
+                    }
                     textBlock = { type: "text", text: "" };
                     blocks.push(textBlock);
-                    stream.push({ type: "text_start", contentIndex: getContentIndex(textBlock), partial: output });
+                    if (!deferMixedEvents) {
+                        activeBlock = textBlock;
+                        stream.push({ type: "text_start", contentIndex: getContentIndex(textBlock), partial: output });
+                    }
                 }
                 return textBlock;
             };
             const ensureThinkingBlock = (thinkingSignature) => {
                 if (!thinkingBlock) {
+                    if (!deferMixedEvents) {
+                        finishActiveBlock();
+                        textBlock = null;
+                    }
                     thinkingBlock = {
                         type: "thinking",
                         thinking: "",
                         thinkingSignature,
                     };
                     blocks.push(thinkingBlock);
-                    stream.push({ type: "thinking_start", contentIndex: getContentIndex(thinkingBlock), partial: output });
+                    if (!deferMixedEvents) {
+                        activeBlock = thinkingBlock;
+                        stream.push({
+                            type: "thinking_start",
+                            contentIndex: getContentIndex(thinkingBlock),
+                            partial: output,
+                        });
+                    }
                 }
                 return thinkingBlock;
             };
@@ -364,6 +377,11 @@ export const stream = (model, context, options) => {
                     block = toolCallBlocksById.get(toolCall.id);
                 }
                 if (!block) {
+                    if (!deferMixedEvents) {
+                        finishActiveBlock();
+                        textBlock = null;
+                        thinkingBlock = null;
+                    }
                     // Note: the "input" fallback here should/must not be taken.  in case the LLM makes up
                     // a tool we don't knwo about, we at least have a place to stash our stuff.
                     const customInputProperty = toolCall.custom
@@ -388,11 +406,14 @@ export const stream = (model, context, options) => {
                         toolCallBlocksById.set(toolCall.id, block);
                     }
                     blocks.push(block);
-                    stream.push({
-                        type: "toolcall_start",
-                        contentIndex: getContentIndex(block),
-                        partial: output,
-                    });
+                    if (!deferMixedEvents) {
+                        activeBlock = block;
+                        stream.push({
+                            type: "toolcall_start",
+                            contentIndex: getContentIndex(block),
+                            partial: output,
+                        });
+                    }
                 }
                 if (streamIndex !== undefined && block.streamIndex === undefined) {
                     block.streamIndex = streamIndex;
@@ -416,6 +437,30 @@ export const stream = (model, context, options) => {
                 applyPendingReasoningDetail(block);
                 return block;
             };
+            const flushDeferredBlocks = () => {
+                for (const block of blocks) {
+                    const contentIndex = getContentIndex(block);
+                    if (block.type === "text") {
+                        stream.push({ type: "text_start", contentIndex, partial: output });
+                        for (const delta of deferredTextDeltas) {
+                            stream.push({ type: "text_delta", contentIndex, delta, partial: output });
+                        }
+                    }
+                    else if (block.type === "thinking") {
+                        stream.push({ type: "thinking_start", contentIndex, partial: output });
+                        for (const delta of deferredThinkingDeltas) {
+                            stream.push({ type: "thinking_delta", contentIndex, delta, partial: output });
+                        }
+                    }
+                    else {
+                        stream.push({ type: "toolcall_start", contentIndex, partial: output });
+                        for (const delta of deferredToolCallDeltas.get(block) ?? []) {
+                            stream.push({ type: "toolcall_delta", contentIndex, delta, partial: output });
+                        }
+                    }
+                    finishBlock(block);
+                }
+            };
             for await (const chunk of openaiStream) {
                 if (!chunk || typeof chunk !== "object")
                     continue;
@@ -446,22 +491,9 @@ export const stream = (model, context, options) => {
                     hasFinishReason = true;
                 }
                 if (choice.delta) {
-                    if (choice.delta.content !== null &&
-                        choice.delta.content !== undefined &&
-                        choice.delta.content.length > 0) {
-                        const block = ensureTextBlock();
-                        block.text += choice.delta.content;
-                        stream.push({
-                            type: "text_delta",
-                            contentIndex: getContentIndex(block),
-                            delta: choice.delta.content,
-                            partial: output,
-                        });
-                    }
-                    // Some endpoints return reasoning in reasoning_content (llama.cpp),
-                    // or reasoning (other openai compatible endpoints)
-                    // Use the first non-empty reasoning field to avoid duplication
-                    // (e.g., chutes.ai returns both reasoning_content and reasoning with same content)
+                    const contentDelta = typeof choice.delta.content === "string" && choice.delta.content.length > 0
+                        ? choice.delta.content
+                        : null;
                     const reasoningFields = ["reasoning_content", "reasoning", "reasoning_text"];
                     const deltaFields = choice.delta;
                     let foundReasoningField = null;
@@ -472,6 +504,28 @@ export const stream = (model, context, options) => {
                             break;
                         }
                     }
+                    if (blocks.length === 0 && contentDelta && foundReasoningField) {
+                        deferMixedEvents = true;
+                    }
+                    if (contentDelta) {
+                        const block = ensureTextBlock();
+                        block.text += contentDelta;
+                        if (deferMixedEvents) {
+                            deferredTextDeltas.push(contentDelta);
+                        }
+                        else {
+                            stream.push({
+                                type: "text_delta",
+                                contentIndex: getContentIndex(block),
+                                delta: contentDelta,
+                                partial: output,
+                            });
+                        }
+                    }
+                    // Some endpoints return reasoning in reasoning_content (llama.cpp),
+                    // or reasoning (other openai compatible endpoints)
+                    // Use the first non-empty reasoning field to avoid duplication
+                    // (e.g., chutes.ai returns both reasoning_content and reasoning with same content)
                     if (foundReasoningField) {
                         const delta = deltaFields[foundReasoningField];
                         if (typeof delta === "string" && delta.length > 0) {
@@ -480,12 +534,17 @@ export const stream = (model, context, options) => {
                                 : foundReasoningField;
                             const block = ensureThinkingBlock(thinkingSignature);
                             block.thinking += delta;
-                            stream.push({
-                                type: "thinking_delta",
-                                contentIndex: getContentIndex(block),
-                                delta,
-                                partial: output,
-                            });
+                            if (deferMixedEvents) {
+                                deferredThinkingDeltas.push(delta);
+                            }
+                            else {
+                                stream.push({
+                                    type: "thinking_delta",
+                                    contentIndex: getContentIndex(block),
+                                    delta,
+                                    partial: output,
+                                });
+                            }
                         }
                     }
                     if (choice?.delta?.tool_calls) {
@@ -509,12 +568,19 @@ export const stream = (model, context, options) => {
                                 const nextInput = getCustomToolCallInput(block) + toolCall.custom.input;
                                 delta = appendCustomToolCallInput(block, nextInput, false) ?? "";
                             }
-                            stream.push({
-                                type: "toolcall_delta",
-                                contentIndex: getContentIndex(block),
-                                delta,
-                                partial: output,
-                            });
+                            if (deferMixedEvents) {
+                                const deltas = deferredToolCallDeltas.get(block) ?? [];
+                                deltas.push(delta);
+                                deferredToolCallDeltas.set(block, deltas);
+                            }
+                            else {
+                                stream.push({
+                                    type: "toolcall_delta",
+                                    contentIndex: getContentIndex(block),
+                                    delta,
+                                    partial: output,
+                                });
+                            }
                         }
                     }
                     const reasoningDetails = choice.delta.reasoning_details;
@@ -534,9 +600,10 @@ export const stream = (model, context, options) => {
                     }
                 }
             }
-            for (const block of blocks) {
-                finishBlock(block);
-            }
+            if (deferMixedEvents)
+                flushDeferredBlocks();
+            else
+                finishActiveBlock();
             if (options?.signal?.aborted) {
                 throw new Error("Request was aborted");
             }
@@ -577,7 +644,7 @@ export const stream = (model, context, options) => {
     return stream;
 };
 export const streamSimple = (model, context, options) => {
-    getClientApiKey(model.provider, options?.apiKey, options?.headers);
+    resolveOpenAIClientAuth(model.provider, options?.apiKey, options?.headers);
     const base = buildBaseOptions(model, context, options, options?.apiKey);
     const compat = getCompat(model);
     const thinkingLevelMap = getThinkingLevelMap(model, compat);