cat-shark/pi-commandcode-provider
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

style: configure prettier (no semicolons, trailing commas)

Browse Source
This commit is contained in:
Patrick Wozniak
2026-05-05 14:02:41 +02:00
parent e9853eb4a4
commit af2b316d84
14 changed files with 1247 additions and 1446 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/test-stream.ts
+129 -159
View File
@@ -3,10 +3,10 @@
* Command Code server. No real API key or pi runtime required.
*/
import assert from "node:assert/strict";
import { after, before, beforeEach, describe, it } from "node:test";
import assert from "node:assert/strict"
import { after, before, beforeEach, describe, it } from "node:test"
import type { AssistantMessageEvent } from "../src/core.ts";
import type { AssistantMessageEvent } from "../src/core.ts"
import {
collectEvents,
createTestDeps,
@@ -15,24 +15,24 @@ import {
objectAt,
startMockCommandCodeServer,
type MockCommandCodeServer,
} from "./helpers.ts";
} from "./helpers.ts"
let server: MockCommandCodeServer;
let server: MockCommandCodeServer
before(async () => {
server = await startMockCommandCodeServer();
});
server = await startMockCommandCodeServer()
})
after(async () => {
await server.close();
});
await server.close()
})
beforeEach(() => {
server.reset();
});
server.reset()
})
function eventTypes(events: readonly AssistantMessageEvent[]): string[] {
return events.map((event) => event.type);
return events.map((event) => event.type)
}
describe("streamCommandCode — auth", () => {
@@ -41,39 +41,34 @@ describe("streamCommandCode — auth", () => {
apiBase: server.baseUrl(),
env: {},
authPaths: [],
});
})
const stream = streamCommandCode(makeModel(), makeContext(), {
apiKey: "",
});
const events = await collectEvents(stream);
})
const events = await collectEvents(stream)
assert.deepEqual(eventTypes(events), ["error"]);
assert.equal(events[0].type, "error");
assert.equal(events[0].reason, "error");
assert.match(events[0].error.errorMessage ?? "", /No Command Code API key/);
assert.equal(server.requestCount(), 0);
});
assert.deepEqual(eventTypes(events), ["error"])
assert.equal(events[0].type, "error")
assert.equal(events[0].reason, "error")
assert.match(events[0].error.errorMessage ?? "", /No Command Code API key/)
assert.equal(server.requestCount(), 0)
})
it("uses options.apiKey in the Authorization header", async () => {
server.mockResponse({
type: "success",
events: [JSON.stringify({ type: "finish", finishReason: "stop" })],
});
})
const { streamCommandCode } = createTestDeps({
apiBase: server.baseUrl(),
env: { COMMANDCODE_API_KEY: "env-key" },
});
})
await collectEvents(
streamCommandCode(makeModel(), makeContext(), { apiKey: "option-key" }),
);
await collectEvents(streamCommandCode(makeModel(), makeContext(), { apiKey: "option-key" }))
assert.equal(
server.lastRequestHeaders().authorization,
"Bearer option-key",
);
});
});
assert.equal(server.lastRequestHeaders().authorization, "Bearer option-key")
})
})
describe("streamCommandCode — successful streams", () => {
it("emits start → text events → done and accumulates usage", async () => {
@@ -92,14 +87,14 @@ describe("streamCommandCode — successful streams", () => {
},
}),
],
});
})
const { streamCommandCode, calculatedUsages } = createTestDeps({
apiBase: server.baseUrl(),
});
})
const events = await collectEvents(
streamCommandCode(makeModel(), makeContext(), { apiKey: "mock-key" }),
);
)
assert.deepEqual(eventTypes(events), [
"start",
@@ -108,21 +103,19 @@ describe("streamCommandCode — successful streams", () => {
"text_delta",
"text_end",
"done",
]);
const done = events.at(-1);
assert.equal(done?.type, "done");
if (done?.type !== "done") throw new Error("expected done");
assert.equal(done.reason, "stop");
assert.equal(done.message.content[0]?.type, "text");
])
const done = events.at(-1)
assert.equal(done?.type, "done")
if (done?.type !== "done") throw new Error("expected done")
assert.equal(done.reason, "stop")
assert.equal(done.message.content[0]?.type, "text")
assert.equal(
done.message.content[0]?.type === "text"
? done.message.content[0].text
: "",
done.message.content[0]?.type === "text" ? done.message.content[0].text : "",
"Hello",
);
assert.equal(done.message.usage.totalTokens, 11);
assert.equal(calculatedUsages.length, 1);
});
)
assert.equal(done.message.usage.totalTokens, 11)
assert.equal(calculatedUsages.length, 1)
})
it("ends on finish without waiting for an open upstream connection", async () => {
server.mockResponse({
@@ -132,21 +125,18 @@ describe("streamCommandCode — successful streams", () => {
JSON.stringify({ type: "finish", finishReason: "stop" }),
],
hangAfterLast: true,
});
const { streamCommandCode } = createTestDeps({ apiBase: server.baseUrl() });
})
const { streamCommandCode } = createTestDeps({ apiBase: server.baseUrl() })
const events = await collectEvents(
streamCommandCode(makeModel(), makeContext(), { apiKey: "mock-key" }),
500,
);
)
assert.equal(events.at(-1)?.type, "done");
await new Promise((resolve) => setTimeout(resolve, 50));
assert.ok(
server.responseClosedBeforeEnd(),
"client should cancel the still-open response body",
);
});
assert.equal(events.at(-1)?.type, "done")
await new Promise((resolve) => setTimeout(resolve, 50))
assert.ok(server.responseClosedBeforeEnd(), "client should cancel the still-open response body")
})
it("emits reasoning and tool-call blocks in order", async () => {
server.mockResponse({
@@ -163,12 +153,12 @@ describe("streamCommandCode — successful streams", () => {
}),
JSON.stringify({ type: "finish", finishReason: "tool-calls" }),
],
});
const { streamCommandCode } = createTestDeps({ apiBase: server.baseUrl() });
})
const { streamCommandCode } = createTestDeps({ apiBase: server.baseUrl() })
const events = await collectEvents(
streamCommandCode(makeModel(), makeContext(), { apiKey: "mock-key" }),
);
)
assert.deepEqual(eventTypes(events), [
"start",
@@ -181,20 +171,17 @@ describe("streamCommandCode — successful streams", () => {
"toolcall_start",
"toolcall_end",
"done",
]);
const done = events.at(-1);
if (done?.type !== "done") throw new Error("expected done");
assert.equal(done.reason, "toolUse");
])
const done = events.at(-1)
if (done?.type !== "done") throw new Error("expected done")
assert.equal(done.reason, "toolUse")
assert.deepEqual(
done.message.content.map((content) => content.type),
["thinking", "text", "toolCall"],
);
const toolCall = done.message.content[2];
assert.equal(
toolCall?.type === "toolCall" ? toolCall.name : "",
"read_file",
);
});
)
const toolCall = done.message.content[2]
assert.equal(toolCall?.type === "toolCall" ? toolCall.name : "", "read_file")
})
it("flushes reasoning if finish arrives without reasoning-end", async () => {
server.mockResponse({
@@ -203,26 +190,26 @@ describe("streamCommandCode — successful streams", () => {
JSON.stringify({ type: "reasoning-delta", text: "unfinished thought" }),
JSON.stringify({ type: "finish", finishReason: "stop" }),
],
});
const { streamCommandCode } = createTestDeps({ apiBase: server.baseUrl() });
})
const { streamCommandCode } = createTestDeps({ apiBase: server.baseUrl() })
const events = await collectEvents(
streamCommandCode(makeModel(), makeContext(), { apiKey: "mock-key" }),
);
)
const done = events.at(-1);
if (done?.type !== "done") throw new Error("expected done");
assert.equal(done.message.content[0]?.type, "thinking");
});
});
const done = events.at(-1)
if (done?.type !== "done") throw new Error("expected done")
assert.equal(done.message.content[0]?.type, "thinking")
})
})
describe("streamCommandCode — request serialization", () => {
it("sends the expected request body and default headers", async () => {
server.mockResponse({
type: "success",
events: [JSON.stringify({ type: "finish", finishReason: "stop" })],
});
const { streamCommandCode } = createTestDeps({ apiBase: server.baseUrl() });
})
const { streamCommandCode } = createTestDeps({ apiBase: server.baseUrl() })
const context = makeContext({
messages: [
{ role: "user", content: "first" },
@@ -242,52 +229,40 @@ describe("streamCommandCode — request serialization", () => {
},
},
],
});
})
await collectEvents(
streamCommandCode(makeModel(), context, {
apiKey: "mock-key",
maxTokens: 500,
}),
);
)
const body = server.lastRequestBody();
assert.equal(objectAt(body, ["config", "workingDir"]), "/repo");
assert.equal(objectAt(body, ["config", "date"]), "2026-05-05");
assert.equal(
objectAt(body, ["params", "model"]),
"deepseek/deepseek-v4-flash",
);
assert.equal(objectAt(body, ["params", "stream"]), true);
assert.equal(objectAt(body, ["params", "max_tokens"]), 500);
assert.equal(
objectAt(body, ["params", "system"]),
"You are a test assistant.",
);
const body = server.lastRequestBody()
assert.equal(objectAt(body, ["config", "workingDir"]), "/repo")
assert.equal(objectAt(body, ["config", "date"]), "2026-05-05")
assert.equal(objectAt(body, ["params", "model"]), "deepseek/deepseek-v4-flash")
assert.equal(objectAt(body, ["params", "stream"]), true)
assert.equal(objectAt(body, ["params", "max_tokens"]), 500)
assert.equal(objectAt(body, ["params", "system"]), "You are a test assistant.")
assert.equal(
objectAt(body, ["params", "messages", "1", "content", "0", "text"]),
"first response",
);
assert.equal(
objectAt(body, ["params", "tools", "0", "name"]),
"get_weather",
);
)
assert.equal(objectAt(body, ["params", "tools", "0", "name"]), "get_weather")
const headers = server.lastRequestHeaders();
assert.equal(headers.authorization, "Bearer mock-key");
assert.equal(headers["x-command-code-version"], "0.24.1");
assert.equal(
headers["x-session-id"],
"00000000-0000-4000-8000-000000000000",
);
});
const headers = server.lastRequestHeaders()
assert.equal(headers.authorization, "Bearer mock-key")
assert.equal(headers["x-command-code-version"], "0.24.1")
assert.equal(headers["x-session-id"], "00000000-0000-4000-8000-000000000000")
})
it("caps maxTokens and passes custom headers", async () => {
server.mockResponse({
type: "success",
events: [JSON.stringify({ type: "finish", finishReason: "stop" })],
});
const { streamCommandCode } = createTestDeps({ apiBase: server.baseUrl() });
})
const { streamCommandCode } = createTestDeps({ apiBase: server.baseUrl() })
await collectEvents(
streamCommandCode(makeModel({ maxTokens: 500_000 }), makeContext(), {
@@ -295,53 +270,50 @@ describe("streamCommandCode — request serialization", () => {
maxTokens: 500_000,
headers: { "x-custom": "value" },
}),
);
)
assert.equal(
objectAt(server.lastRequestBody(), ["params", "max_tokens"]),
200_000,
);
assert.equal(server.lastRequestHeaders()["x-custom"], "value");
});
assert.equal(objectAt(server.lastRequestBody(), ["params", "max_tokens"]), 200_000)
assert.equal(server.lastRequestHeaders()["x-custom"], "value")
})
it("runs onPayload and onResponse hooks", async () => {
server.mockResponse({
type: "success",
events: [JSON.stringify({ type: "finish", finishReason: "stop" })],
});
const { streamCommandCode } = createTestDeps({ apiBase: server.baseUrl() });
let responseStatus = 0;
})
const { streamCommandCode } = createTestDeps({ apiBase: server.baseUrl() })
let responseStatus = 0
await collectEvents(
streamCommandCode(makeModel(), makeContext(), {
apiKey: "mock-key",
onPayload: () => ({ replaced: true }),
onResponse: (response) => {
responseStatus = response.status;
responseStatus = response.status
},
}),
);
)
assert.equal(objectAt(server.lastRequestBody(), ["replaced"]), true);
assert.equal(responseStatus, 200);
});
});
assert.equal(objectAt(server.lastRequestBody(), ["replaced"]), true)
assert.equal(responseStatus, 200)
})
})
describe("streamCommandCode — upstream errors and malformed streams", () => {
it("emits error for HTTP failures", async () => {
server.mockResponse({ type: "error", status: 429, body: "rate limited" });
const { streamCommandCode } = createTestDeps({ apiBase: server.baseUrl() });
server.mockResponse({ type: "error", status: 429, body: "rate limited" })
const { streamCommandCode } = createTestDeps({ apiBase: server.baseUrl() })
const events = await collectEvents(
streamCommandCode(makeModel(), makeContext(), { apiKey: "mock-key" }),
);
)
assert.deepEqual(eventTypes(events), ["start", "error"]);
const error = events.at(-1);
assert.equal(error?.type, "error");
if (error?.type !== "error") throw new Error("expected error");
assert.match(error.error.errorMessage ?? "", /429/);
});
assert.deepEqual(eventTypes(events), ["start", "error"])
const error = events.at(-1)
assert.equal(error?.type, "error")
if (error?.type !== "error") throw new Error("expected error")
assert.match(error.error.errorMessage ?? "", /429/)
})
it("emits error for provider error events", async () => {
server.mockResponse({
@@ -352,25 +324,25 @@ describe("streamCommandCode — upstream errors and malformed streams", () => {
error: { message: "provider failed" },
}),
],
});
const { streamCommandCode } = createTestDeps({ apiBase: server.baseUrl() });
})
const { streamCommandCode } = createTestDeps({ apiBase: server.baseUrl() })
const events = await collectEvents(
streamCommandCode(makeModel(), makeContext(), { apiKey: "mock-key" }),
);
)
const error = events.at(-1);
assert.equal(error?.type, "error");
if (error?.type !== "error") throw new Error("expected error");
assert.equal(error.error.errorMessage, "provider failed");
});
const error = events.at(-1)
assert.equal(error?.type, "error")
if (error?.type !== "error") throw new Error("expected error")
assert.equal(error.error.errorMessage, "provider failed")
})
it("handles SSE lines, malformed lines, split chunks, and final line without newline", async () => {
const textEvent = `data: ${JSON.stringify({ type: "text-delta", text: "split" })}\n`;
const textEvent = `data: ${JSON.stringify({ type: "text-delta", text: "split" })}\n`
const finishEvent = JSON.stringify({
type: "finish",
finishReason: "max_tokens",
});
})
server.mockResponse({
type: "success",
chunks: [
@@ -381,21 +353,19 @@ describe("streamCommandCode — upstream errors and malformed streams", () => {
"data: [DONE]\n",
finishEvent,
],
});
const { streamCommandCode } = createTestDeps({ apiBase: server.baseUrl() });
})
const { streamCommandCode } = createTestDeps({ apiBase: server.baseUrl() })
const events = await collectEvents(
streamCommandCode(makeModel(), makeContext(), { apiKey: "mock-key" }),
);
)
const done = events.at(-1);
if (done?.type !== "done") throw new Error("expected done");
assert.equal(done.reason, "length");
const done = events.at(-1)
if (done?.type !== "done") throw new Error("expected done")
assert.equal(done.reason, "length")
assert.equal(
done.message.content[0]?.type === "text"
? done.message.content[0].text
: "",
done.message.content[0]?.type === "text" ? done.message.content[0].text : "",
"split",
);
});
});
)
})
})