@code-yeongyu/senpi 2026.7.20-2 → 2026.7.20

package/node_modules/@earendil-works/pi-ai/dist/api/anthropic-messages.js

@@ -144,20 +144,6 @@ const UNSUPPORTED_NATIVE_COMPUTER_TOOL_MODEL_MARKERS = [
     "opus-4-8",
     "opus-4.8",
 ];
-// A provider can reject its own empty signatures. Learn that capability for one
-// conversation without changing the shared model definition used by other sessions.
-const unsignedThinkingTextReplayFallbacks = new Set();
-function unsignedThinkingFallbackKey(model, sessionId) {
-    return sessionId === undefined ? undefined : `${sessionId}\u0000${model.baseUrl}\u0000${model.id}`;
-}
-function isInvalidUnsignedThinkingSignatureError(error) {
-    return (typeof error === "object" &&
-        error !== null &&
-        "status" in error &&
-        error.status === 400 &&
-        error instanceof Error &&
-        /Invalid signature in thinking block/i.test(error.message));
-}
 function getAnthropicCompat(model) {
     // Auto-detect session affinity and cache control support from provider
     const isFireworks = model.provider === "fireworks";
@@ -173,7 +159,6 @@ function getAnthropicCompat(model) {
         supportsToolChoice: model.compat?.supportsToolChoice ?? true,
         supportsForcedToolChoice: model.compat?.supportsForcedToolChoice ?? !CLAUDE_FABLE_OR_MYTHOS_MODEL_ID.test(model.id),
         allowEmptySignature: model.compat?.allowEmptySignature ?? false,
-        unsignedThinkingReplay: model.compat?.unsignedThinkingReplay ?? (model.compat?.allowEmptySignature ? "empty-signature" : "text"),
         supportsToolReferences: model.compat?.supportsToolReferences ?? defaultSupportsToolReferences(model),
         // Default: first-party Anthropic only. Anthropic-compatible providers
         // (kimi-coding, fireworks, copilot, gateways) may execute the server-side
@@ -672,57 +657,34 @@ export const stream = (model, context, options) => {
                 client = created.client;
                 isOAuth = created.isOAuthToken;
             }
-            const fallbackKey = unsignedThinkingFallbackKey(model, options?.sessionId);
-            let unsignedThinkingReplay = fallbackKey && unsignedThinkingTextReplayFallbacks.has(fallbackKey)
-                ? "text"
-                : getAnthropicCompat(model).unsignedThinkingReplay;
-            const createRequest = async () => {
-                let params = buildParams(model, context, isOAuth, options, unsignedThinkingReplay);
-                const nextParams = await options?.onPayload?.(params, model);
-                if (nextParams !== undefined) {
-                    params = nextParams;
-                }
-                params = sanitizeAdaptiveThinkingPayload(model, params, options);
-                params = sanitizeUnsupportedNativeTools(model, params);
-                const payloadRequestMetadata = extractPayloadRequestMetadata(params);
-                params = payloadRequestMetadata.params;
-                const requestOptions = {
-                    ...(options?.signal ? { signal: options.signal } : {}),
-                    ...(options?.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
-                    maxRetries: options?.maxRetries ?? 0,
-                    ...(payloadRequestMetadata.headers ? { headers: payloadRequestMetadata.headers } : {}),
-                };
-                try {
-                    const response = await client.messages.create({ ...params, stream: true }, requestOptions).asResponse();
-                    return { params, response };
-                }
-                catch (error) {
-                    if (isForcedToolChoiceUnsupportedError(error, isForcedAnthropicToolChoice(params.tool_choice))) {
-                        params = omitToolChoiceParam(params);
-                        const response = await client.messages
-                            .create({ ...params, stream: true }, requestOptions)
-                            .asResponse();
-                        return { params, response };
-                    }
-                    throw error;
-                }
+            let params = buildParams(model, context, isOAuth, options);
+            const nextParams = await options?.onPayload?.(params, model);
+            if (nextParams !== undefined) {
+                params = nextParams;
+            }
+            params = sanitizeAdaptiveThinkingPayload(model, params, options);
+            params = sanitizeUnsupportedNativeTools(model, params);
+            const payloadRequestMetadata = extractPayloadRequestMetadata(params);
+            params = payloadRequestMetadata.params;
+            const requestOptions = {
+                ...(options?.signal ? { signal: options.signal } : {}),
+                ...(options?.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
+                maxRetries: options?.maxRetries ?? 0,
+                ...(payloadRequestMetadata.headers ? { headers: payloadRequestMetadata.headers } : {}),
             };
-            let request;
+            let response;
             try {
-                request = await createRequest();
+                response = await client.messages.create({ ...params, stream: true }, requestOptions).asResponse();
             }
             catch (error) {
-                if (unsignedThinkingReplay !== "text" && isInvalidUnsignedThinkingSignatureError(error)) {
-                    unsignedThinkingReplay = "text";
-                    if (fallbackKey)
-                        unsignedThinkingTextReplayFallbacks.add(fallbackKey);
-                    request = await createRequest();
+                if (isForcedToolChoiceUnsupportedError(error, isForcedAnthropicToolChoice(params.tool_choice))) {
+                    params = omitToolChoiceParam(params);
+                    response = await client.messages.create({ ...params, stream: true }, requestOptions).asResponse();
                 }
                 else {
                     throw error;
                 }
             }
-            const { response } = request;
             await options?.onResponse?.({ status: response.status, headers: headersToRecord(response.headers) }, model);
             stream.push({ type: "start", partial: output });
             const blocks = output.content;
@@ -902,9 +864,6 @@ export const stream = (model, context, options) => {
                         if (stopReasonResult.errorMessage) {
                             output.errorMessage = stopReasonResult.errorMessage;
                         }
-                        if (stopReasonResult.stopDetails) {
-                            output.stopDetails = stopReasonResult.stopDetails;
-                        }
                     }
                     // Only update usage fields if present (not null).
                     // Preserves input_tokens from message_start when proxies omit it in message_delta.
@@ -1130,7 +1089,7 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
     });
     return { client, isOAuthToken: false };
 }
-function buildParams(model, context, isOAuthToken, options, unsignedThinkingReplay = getAnthropicCompat(model).unsignedThinkingReplay) {
+function buildParams(model, context, isOAuthToken, options) {
     const compat = getAnthropicCompat(model);
     const { cacheControl } = getCacheControl(model, options?.cacheRetention ?? model.cacheRetention, options?.env);
     const transformedMessages = transformMessages(context.messages, model, normalizeToolCallId, {
@@ -1153,7 +1112,7 @@ function buildParams(model, context, isOAuthToken, options, unsignedThinkingRepl
     const deferredToolNames = new Set(deferredTools.map((tool) => normalizeToolName(tool.name)));
     const params = {
         model: model.id,
-        messages: convertMessages(transformedMessages, model, isOAuthToken, cacheControl, unsignedThinkingReplay, deferredToolNames, normalizeToolName),
+        messages: convertMessages(transformedMessages, model, isOAuthToken, cacheControl, compat.allowEmptySignature, deferredToolNames, normalizeToolName),
         max_tokens: options?.maxTokens ?? model.maxTokens,
         stream: true,
     };
@@ -1291,7 +1250,7 @@ function convertToolResult(msg, isOAuthToken, deferredToolNames, loadedToolNames
                 : convertedContent,
     };
 }
-function convertMessages(transformedMessages, model, isOAuthToken, cacheControl, unsignedThinkingReplay = "text", deferredToolNames = new Set(), normalizeToolName = (name) => name) {
+function convertMessages(transformedMessages, model, isOAuthToken, cacheControl, allowEmptySignature = false, deferredToolNames = new Set(), normalizeToolName = (name) => name) {
     const params = [];
     const loadedToolNames = new Set();
     // Tool calls from a declined pre-fallback attempt are dropped from their
@@ -1401,7 +1360,7 @@ function convertMessages(transformedMessages, model, isOAuthToken, cacheControl,
                     // convert to plain text for Anthropic. Some compatible providers emit
                     // and accept empty signatures, so let marked models preserve the block.
                     if (!hasThinkingSignature) {
-                        blocks.push(unsignedThinkingReplay === "empty-signature"
+                        blocks.push(allowEmptySignature
                             ? {
                                 type: "thinking",
                                 thinking: sanitizeSurrogates(block.thinking),
@@ -1515,7 +1474,6 @@ function convertTools(tools, isOAuthToken, supportsEagerToolInputStreaming, cach
     });
 }
 function mapStopReason(reason, stopDetails) {
-    const explanation = stopDetails?.explanation;
     switch (reason) {
         case "end_turn":
             return { stopReason: "stop" };
@@ -1526,15 +1484,14 @@ function mapStopReason(reason, stopDetails) {
         case "refusal":
             return {
                 stopReason: "error",
-                errorMessage: explanation || `The model refused to complete the request`,
-                stopDetails: explanation == null ? { type: "refusal" } : { type: "refusal", explanation },
+                errorMessage: stopDetails?.explanation || `The model refused to complete the request`,
             };
         case "pause_turn": // Stop is good enough -> resubmit
             return { stopReason: "stop" };
         case "stop_sequence":
             return { stopReason: "stop" }; // We don't supply stop sequences, so this should never happen
         case "sensitive": // Content flagged by safety filters (not yet in SDK types)
-            return { stopReason: "error", stopDetails: { type: "sensitive" } };
+            return { stopReason: "error" };
         default:
             // Handle unknown stop reasons gracefully (API may add new values)
             throw new Error(`Unhandled stop reason: ${reason}`);