diff --git a/open-sse/executors/mimocode.ts b/open-sse/executors/mimocode.ts index 115e5a4bad..239dfc430d 100644 --- a/open-sse/executors/mimocode.ts +++ b/open-sse/executors/mimocode.ts @@ -100,6 +100,12 @@ interface AccountState { expiresAt: number; cooldownUntil: number; consecutiveFails: number; + /** + * #3837/#5521: the account's resolved proxy, or `null` when none is configured. + * Always present (never `undefined`) so callers can read `acct.proxy` directly — + * syncAccountsFromCredentials() writes it on every account on every sync. + */ + proxy: AccountProxyConfig["proxy"]; } function parseJwtExp(jwt: string): number { diff --git a/open-sse/executors/opencode.ts b/open-sse/executors/opencode.ts index 8180d43afe..7d1595bac4 100644 --- a/open-sse/executors/opencode.ts +++ b/open-sse/executors/opencode.ts @@ -338,13 +338,11 @@ export class OpencodeExecutor extends BaseExecutor { ) { delete (modifiedBody as Record).client_metadata; } - if ( - modifiedBody && - typeof modifiedBody === "object" && - Array.isArray(modifiedBody.tools) && - modifiedBody.tools.length > 128 - ) { - modifiedBody.tools = modifiedBody.tools.slice(0, 128); + if (modifiedBody && typeof modifiedBody === "object" && !Array.isArray(modifiedBody)) { + const mb = modifiedBody as Record; + if (Array.isArray(mb.tools) && mb.tools.length > 128) { + mb.tools = mb.tools.slice(0, 128); + } } if (modifiedBody && typeof modifiedBody === "object" && !Array.isArray(modifiedBody)) { const mb = modifiedBody as Record; diff --git a/open-sse/executors/zed-hosted.ts b/open-sse/executors/zed-hosted.ts index 3ad0cc8740..ef358ce217 100644 --- a/open-sse/executors/zed-hosted.ts +++ b/open-sse/executors/zed-hosted.ts @@ -117,8 +117,18 @@ function createErrorChunk(model: string, message: string): Record, "enqueue">; + function enqueueSseObject( - controller: ReadableStreamDefaultController, + controller: SseEnqueueTarget, encoder: TextEncoder, chunk: unknown ): void { @@ -202,7 +212,7 @@ function wrapZedCompletionStream( let buffer = ""; let done = false; - const finish = (controller: ReadableStreamDefaultController) => { + const finish = (controller: SseEnqueueTarget) => { if (done) return; const finalChunk = convertProviderEvent(provider, null, state); enqueueSseObject(controller, encoder, finalChunk); @@ -210,7 +220,7 @@ function wrapZedCompletionStream( done = true; }; - const processLine = (line: string, controller: ReadableStreamDefaultController) => { + const processLine = (line: string, controller: SseEnqueueTarget) => { if (done) return; const payload = unwrapZedLine(line); if (!payload) return; diff --git a/tests/unit/ts7-executor-shared-shapes.test.ts b/tests/unit/ts7-executor-shared-shapes.test.ts new file mode 100644 index 0000000000..98a2fdd077 --- /dev/null +++ b/tests/unit/ts7-executor-shared-shapes.test.ts @@ -0,0 +1,145 @@ +import { describe, it } from "node:test"; +import assert from "node:assert/strict"; + +const { OpencodeExecutor } = await import("../../open-sse/executors/opencode.ts"); +const { MimocodeExecutor } = await import("../../open-sse/executors/mimocode.ts"); + +/** + * Behavioral guards for the three type-only fixes in the TS 7 executor slice + * (see #8484). Each fix restored a type the code already depended on at runtime; + * these tests pin the runtime contracts so a future "simplification" of the + * annotations cannot silently change behavior. + * + * The zed-hosted `SseEnqueueTarget` fix is already covered end-to-end by + * `zed-hosted-think-close-marker.test.ts`, which drives the same TransformStream + * that failed to type-check — no duplicate added here. + */ + +describe("OpencodeExecutor — tools truncation survives the narrowing fix", () => { + const executor = new OpencodeExecutor("opencode-go"); + const CREDENTIALS = { apiKey: "k" } as Record; + + const tools = (n: number) => + Array.from({ length: n }, (_, i) => ({ + type: "function", + function: { name: `tool_${i}`, parameters: {} }, + })); + + function bodyWith(toolCount: number) { + return { + model: "oc/kimi-k2.6", + stream: true, + messages: [{ role: "user", content: "hi" }], + tools: tools(toolCount), + }; + } + + it("truncates an over-long tools array to 128 entries", () => { + const out = executor.transformRequest("oc/kimi-k2.6", bodyWith(200), true, CREDENTIALS) as { + tools: unknown[]; + }; + assert.equal(out.tools.length, 128, "upstream rejects more than 128 tools"); + assert.deepEqual( + (out.tools[127] as { function: { name: string } }).function.name, + "tool_127", + "truncation keeps the first 128 in order, not an arbitrary slice" + ); + }); + + it("leaves a within-limit tools array untouched", () => { + const out = executor.transformRequest("oc/kimi-k2.6", bodyWith(10), true, CREDENTIALS) as { + tools: unknown[]; + }; + assert.equal(out.tools.length, 10); + }); + + it("is a no-op when the body carries no tools", () => { + const body = { + model: "oc/kimi-k2.6", + stream: true, + messages: [{ role: "user", content: "hi" }], + }; + const out = executor.transformRequest("oc/kimi-k2.6", body, true, CREDENTIALS) as Record< + string, + unknown + >; + assert.equal("tools" in out, false); + assert.ok(Array.isArray(out.messages), "messages preserved"); + }); + + it("leaves an array-shaped body alone (pins the !Array.isArray guard)", () => { + // The pre-fix condition reached `.tools` on any object, arrays included, and + // relied on `Array.isArray(undefined)` short-circuiting. The explicit + // !Array.isArray() guard must keep that outcome identical. + const arrayBody = [{ role: "user", content: "hi" }] as unknown as Record; + const out = executor.transformRequest("oc/kimi-k2.6", arrayBody, true, CREDENTIALS); + assert.ok(Array.isArray(out), "array body must pass through as an array"); + assert.equal((out as unknown[]).length, 1); + }); +}); + +describe("MimocodeExecutor — AccountState.proxy is always present (#3837/#5521)", () => { + const FP = "fingerprint-1"; + + function accountsOf(exec: unknown): Array> { + return (exec as { accounts: Array> }).accounts; + } + + function sync(exec: unknown, credentials: unknown): void { + (exec as { syncAccountsFromCredentials(c: unknown): void }).syncAccountsFromCredentials( + credentials + ); + } + + it("defaults proxy to null — not undefined — when no accountProxies are configured", () => { + const exec = new MimocodeExecutor(); + accountsOf(exec).length = 0; + accountsOf(exec).push({ + fingerprint: FP, + jwt: "", + expiresAt: 0, + cooldownUntil: 0, + consecutiveFails: 0, + }); + + sync(exec, { providerSpecificData: {} }); + + const account = accountsOf(exec)[0]; + assert.ok("proxy" in account, "every account must expose a proxy key"); + assert.equal(account.proxy, null, "unconfigured proxy is null, never undefined"); + }); + + it("resolves a configured proxy onto the matching account", () => { + const exec = new MimocodeExecutor(); + accountsOf(exec).length = 0; + accountsOf(exec).push({ + fingerprint: FP, + jwt: "", + expiresAt: 0, + cooldownUntil: 0, + consecutiveFails: 0, + }); + + const proxy = { type: "http", host: "p1.example.com", port: 1080 }; + sync(exec, { providerSpecificData: { accountProxies: [{ fingerprint: FP, proxy }] } }); + + assert.deepEqual(accountsOf(exec)[0].proxy, proxy); + }); + + it("clears a previously-resolved proxy back to null when config drops it", () => { + const exec = new MimocodeExecutor(); + accountsOf(exec).length = 0; + accountsOf(exec).push({ + fingerprint: FP, + jwt: "", + expiresAt: 0, + cooldownUntil: 0, + consecutiveFails: 0, + proxy: { type: "http", host: "stale.example.com", port: 8080 }, + }); + + sync(exec, { providerSpecificData: { accountProxies: [] } }); + + assert.equal(accountsOf(exec)[0].proxy, null, "a removed proxy must not linger on the account"); + }); +});