@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
101 lines (94 loc) • 5.4 kB
text/typescript
/**
* Devin reasoning signatures across turns.
*
* GetChatMessage returns the turn's reasoning attestation as `delta_signature`
* (#10) together with `delta_signature_type` (#21) in the same frame, and the
* native client replays both on the assistant prompt as #12 and #18. Measured
* live on swe-2-high the pair arrives AFTER the visible answer (reasoning, text,
* then signature), so the Responses layer stores it as its own signature-only
* reasoning item behind the thinking-text item. GPT and Gemini rows stream no
* thinking text at all, only the signature.
*
* The type is carried inside the stored signature because the reasoning
* envelope that round-trips through the client keeps a single signature string.
* A signature stored before this prefix existed replays without a type.
*/
import type { OcxAssistantMessage } from "../../types";
import { isProviderIssuedThinkingSignature } from "../../responses/reasoning-envelope";
const TYPED_SIGNATURE_PREFIX = "devin-sig1:";
export function encodeDevinSignature(signature: string, signatureType: string | undefined): string {
return signatureType && !signatureType.includes(":")
? `${TYPED_SIGNATURE_PREFIX}${signatureType}:${signature}`
: signature;
}
export function decodeDevinSignature(stored: string): { signature: string; signatureType?: string } {
if (!stored.startsWith(TYPED_SIGNATURE_PREFIX)) return { signature: stored };
const rest = stored.slice(TYPED_SIGNATURE_PREFIX.length);
const colon = rest.indexOf(":");
if (colon <= 0) return { signature: stored };
return { signature: rest.slice(colon + 1), signatureType: rest.slice(0, colon) };
}
/**
* The assistant turn's reasoning for ChatMessagePrompt #11/#12/#18.
*
* All of the turn's thinking text is replayed. A signature rides along only
* when it covers exactly that text:
* - one thinking block carrying its own issued signature (a stray
* signature-only block does not displace it);
* - at most one unsigned thinking block plus exactly one signature-only block,
* which is how a single Devin turn arrives once its late #10 frame has been
* split into its own reasoning item. With no thinking block at all this is a
* GPT or Gemini row, where the signature is the only reasoning there is.
* Any other mix (two signed blocks, a signed block beside unsigned text) has no
* single attestation for the joined text, so the turn is replayed unsigned.
*
* `withholdAnthropic` drops an Anthropic signature and keeps the text: the
* fallback for a Claude turn Cognition refused (see hasAnthropicSignature).
*/
export function devinAssistantReasoning(
message: OcxAssistantMessage,
modelId = "",
withholdAnthropic = false,
): { thinking?: string; signature?: string; signature_type?: string } {
const blocks = message.content.filter(
(part): part is Extract<typeof part, { type: "thinking" }> => part.type === "thinking",
);
const textBlocks = blocks.filter(part => Boolean(part.thinking));
const signatureOnly = blocks.filter(part => !part.thinking && isProviderIssuedThinkingSignature(part.signature));
const text = textBlocks.map(part => part.thinking).join("\n");
let stored: string | undefined;
if (textBlocks.length === 1 && isProviderIssuedThinkingSignature(textBlocks[0]!.signature)) {
stored = textBlocks[0]!.signature;
} else if (textBlocks.length === 0 && signatureOnly.length === 1) {
stored = signatureOnly[0]!.signature;
} else if (textBlocks.length === 1 && signatureOnly.length === 1) {
// Only the late trailer shape attests this text. The Responses parser can
// fold reasoning around a call into one assistant message, so counting
// blocks without checking their position can attach an unrelated signature.
const textIndex = message.content.indexOf(textBlocks[0]!);
if (message.content[textIndex + 1] === signatureOnly[0]) stored = signatureOnly[0]!.signature;
}
let decoded = stored ? decodeDevinSignature(stored) : undefined;
if (decoded && withholdAnthropic && signatureTypeFor(decoded, modelId) === "anthropic") decoded = undefined;
return {
...(text ? { thinking: text } : {}),
...(decoded ? { signature: decoded.signature } : {}),
...(decoded?.signatureType ? { signature_type: decoded.signatureType } : {}),
};
}
/** A stored signature from before its type was recorded falls back to the model being called. */
function signatureTypeFor(decoded: { signatureType?: string }, modelId: string): string | undefined {
return decoded.signatureType ?? (/claude/i.test(modelId) ? "anthropic" : undefined);
}
/**
* True when the mapped history replays a Claude signature. Cognition streams
* Claude's thinking as a summary while the signature covers the original, so
* the pair can fail validation: live on claude-opus-5-5 a signed replay of a
* visible-thinking turn was refused with `invalid_argument` in 5 of 6 tries and
* a text-only one in none, while a signed replay that is accepted is what lets
* the model recall its earlier reasoning. The adapter therefore sends the
* signature and retries a refusal once without it.
*/
export function hasAnthropicSignature(items: ReadonlyArray<{ signature?: string; signature_type?: string }>, modelId: string): boolean {
return items.some(item => Boolean(item.signature) && signatureTypeFor({ signatureType: item.signature_type }, modelId) === "anthropic");
}