mirror of
https://github.com/openclaw/openclaw.git
synced 2026-04-29 04:57:09 +02:00
b64bfc5d9a
* fix(github-copilot): preserve all reasoning IDs and add gpt-5.3-codex support
The existing guard (8fd15ed0e5) only skipped rewriting reasoning item IDs
when encrypted_content was a non-null string. When gpt-5.3-codex is used
via GitHub Copilot, the model falls through to the forward-compat catch-all
with reasoning:false, so encrypted_content is never requested and arrives
as null — bypassing the guard and causing a rewrite. Copilot validates
reasoning item IDs server-side regardless of whether the client includes
encrypted_content, so the rewritten id triggers the 400 error.
Two changes:
1. connection-bound-ids.ts: skip ALL reasoning items unconditionally.
Reasoning items always reference server-side state bound to their
original ID; rewriting any of them breaks Copilot's lookup.
2. models.ts + index.ts: extend the forward-compat cloning logic to
cover gpt-5.3-codex (adds it to the template-target set and to
CODEX_TEMPLATE_MODEL_IDS so it can also serve as a template source
for gpt-5.4). Adds gpt-5.3-codex to COPILOT_XHIGH_MODEL_IDS for
the thinking profile.
Thanks @InvalidPandaa.
* docs(github-copilot): clarify gpt-5.3-codex is a no-op template for itself
https://claude.ai/code/session_01EAFmq4WyKkiUkVAqRXp4Bm
* fix(github-copilot): remove dead reasoning prefix branch in deriveReplacementId
https://claude.ai/code/session_01EAFmq4WyKkiUkVAqRXp4Bm
* fix(github-copilot): align reasoning id replay tests
* test(plugin-sdk): use cjs sidecar for require fast path
---------
Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: Peter Steinberger <steipete@gmail.com>
64 lines
2.9 KiB
TypeScript
64 lines
2.9 KiB
TypeScript
import { describe, expect, it } from "vitest";
|
|
import {
|
|
rewriteCopilotConnectionBoundResponseIds,
|
|
rewriteCopilotResponsePayloadConnectionBoundIds,
|
|
} from "./connection-bound-ids.js";
|
|
|
|
describe("github-copilot connection-bound response IDs", () => {
|
|
it("rewrites opaque message response item IDs deterministically", () => {
|
|
const originalId = Buffer.from(`message-${"x".repeat(24)}`).toString("base64");
|
|
const first = [{ id: originalId, type: "message" }];
|
|
const second = [{ id: originalId, type: "message" }];
|
|
|
|
expect(rewriteCopilotConnectionBoundResponseIds(first)).toBe(true);
|
|
expect(rewriteCopilotConnectionBoundResponseIds(second)).toBe(true);
|
|
expect(first[0]?.id).toMatch(/^msg_[a-f0-9]{16}$/);
|
|
expect(first[0]?.id).toBe(second[0]?.id);
|
|
});
|
|
|
|
it("uses response item type prefixes and preserves local IDs", () => {
|
|
const functionCallId = Buffer.from(`function-call-${"y".repeat(20)}`).toString("base64");
|
|
const messageId = Buffer.from(`message-${"z".repeat(24)}`).toString("base64");
|
|
const input = [
|
|
{ id: "rs_existing", type: "reasoning" },
|
|
{ id: "msg_existing", type: "message" },
|
|
{ id: "fc_existing", type: "function_call" },
|
|
{ id: functionCallId, type: "function_call" },
|
|
{ id: messageId, type: "message" },
|
|
];
|
|
|
|
expect(rewriteCopilotConnectionBoundResponseIds(input)).toBe(true);
|
|
expect(input[0]?.id).toBe("rs_existing");
|
|
expect(input[1]?.id).toBe("msg_existing");
|
|
expect(input[2]?.id).toBe("fc_existing");
|
|
expect(input[3]?.id).toMatch(/^fc_[a-f0-9]{16}$/);
|
|
expect(input[4]?.id).toMatch(/^msg_[a-f0-9]{16}$/);
|
|
});
|
|
|
|
it("preserves reasoning IDs regardless of encrypted_content", () => {
|
|
const withEncrypted = Buffer.from(`reasoning-${"e".repeat(24)}`).toString("base64");
|
|
const withNull = Buffer.from(`reasoning-${"n".repeat(24)}`).toString("base64");
|
|
const withoutField = Buffer.from(`reasoning-${"a".repeat(24)}`).toString("base64");
|
|
const input = [
|
|
{ id: withEncrypted, type: "reasoning", encrypted_content: "opaque-encrypted-payload" },
|
|
{ id: withNull, type: "reasoning", encrypted_content: null },
|
|
{ id: withoutField, type: "reasoning" },
|
|
];
|
|
|
|
expect(rewriteCopilotConnectionBoundResponseIds(input)).toBe(false);
|
|
expect(input[0]?.id).toBe(withEncrypted);
|
|
expect(input[1]?.id).toBe(withNull);
|
|
expect(input[2]?.id).toBe(withoutField);
|
|
});
|
|
|
|
it("patches response payload input arrays only", () => {
|
|
const messageId = Buffer.from(`message-${"m".repeat(24)}`).toString("base64");
|
|
const payload = { input: [{ id: messageId, type: "message" }] };
|
|
|
|
expect(rewriteCopilotResponsePayloadConnectionBoundIds(payload)).toBe(true);
|
|
expect(payload.input[0]?.id).toMatch(/^msg_[a-f0-9]{16}$/);
|
|
expect(rewriteCopilotResponsePayloadConnectionBoundIds(undefined)).toBe(false);
|
|
expect(rewriteCopilotResponsePayloadConnectionBoundIds({ input: "text" })).toBe(false);
|
|
});
|
|
});
|