@traceai/cohere 0.1.0 → 0.1.1

package/dist/src/__tests__/sdk.test.js

@@ -0,0 +1,883 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_http_1 = require("node:http");
+const sdk_trace_node_1 = require("@opentelemetry/sdk-trace-node");
+const sdk_trace_base_1 = require("@opentelemetry/sdk-trace-base");
+const fi_semantic_conventions_1 = require("@traceai/fi-semantic-conventions");
+const instrumentation_1 = require("../instrumentation");
+const api_1 = require("@opentelemetry/api");
+const core_1 = require("@opentelemetry/core");
+const exporter_trace_otlp_http_1 = require("@opentelemetry/exporter-trace-otlp-http");
+// Real SDK serializers and transports, with an offline localhost API double.
+const sdk8 = require("cohere-ai");
+const sdk7 = require("cohere-ai-v7");
+const exporter = new sdk_trace_base_1.InMemorySpanExporter();
+const provider = new sdk_trace_node_1.NodeTracerProvider({ spanProcessors: [new sdk_trace_base_1.SimpleSpanProcessor(exporter)] });
+let server;
+let url;
+let response;
+let contentType = "application/json";
+let status = 200;
+let received = [];
+let wire = [];
+let instrumentation;
+const v1Response = { text: "hello", generation_id: "generation", meta: { tokens: { input_tokens: 5, output_tokens: 2 } } };
+const v2Response = { id: "generation", finish_reason: "COMPLETE", message: { role: "assistant", content: [{ type: "text", text: "hello" }] }, usage: { tokens: { input_tokens: 5, output_tokens: 2 } } };
+beforeAll(() => __awaiter(void 0, void 0, void 0, function* () {
+    provider.register();
+    server = (0, node_http_1.createServer)((request, reply) => {
+        const chunks = [];
+        request.on("data", (chunk) => chunks.push(chunk));
+        request.on("end", () => {
+            const body = JSON.parse(Buffer.concat(chunks).toString() || "{}");
+            if (request.url === "/v1/traces") {
+                wire.push(body);
+                reply.setHeader("Content-Type", "application/json");
+                reply.end("{}");
+                return;
+            }
+            received.push({ path: request.url, body, headers: request.headers });
+            reply.statusCode = status;
+            reply.setHeader("Content-Type", contentType);
+            reply.end(typeof response === "string" ? response : JSON.stringify(response));
+        });
+    });
+    yield new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+    url = `http://127.0.0.1:${server.address().port}`;
+}));
+beforeEach(() => {
+    exporter.reset();
+    wire = [];
+    received = [];
+    status = 200;
+    contentType = "application/json";
+    instrumentation = new instrumentation_1.CohereInstrumentation();
+    instrumentation.setTracerProvider(provider);
+});
+afterEach(() => instrumentation.disable());
+afterAll(() => __awaiter(void 0, void 0, void 0, function* () {
+    yield new Promise((resolve) => server.close(() => resolve()));
+    yield provider.shutdown();
+}));
+it("traces CohereClientV2's generated v2 client", () => __awaiter(void 0, void 0, void 0, function* () {
+    instrumentation.manuallyInstrument(sdk8);
+    response = v2Response;
+    const client = new sdk8.CohereClientV2({ token: "offline-placeholder", environment: url });
+    const result = yield client.chat({ model: "command-test", messages: [{ role: "user", content: "question" }] });
+    expect(result.message.content[0].text).toBe("hello");
+    expect(exporter.getFinishedSpans()).toHaveLength(1);
+    expect(exporter.getFinishedSpans()[0].attributes[fi_semantic_conventions_1.SemanticConventions.LLM_TOKEN_COUNT_PROMPT]).toBe(5);
+}));
+it.each([["7.0.0", sdk7], ["8.3.0", sdk8]])("reads the real %s SDK camelCase chat history", (_version, sdk) => __awaiter(void 0, void 0, void 0, function* () {
+    instrumentation.manuallyInstrument(sdk);
+    response = v1Response;
+    const client = new sdk.CohereClient({ token: "offline-placeholder", environment: url });
+    yield client.chat({ model: "command-test", message: "question", chatHistory: [{ role: "USER", message: "earlier" }] });
+    expect(exporter.getFinishedSpans()).toHaveLength(1);
+    expect(exporter.getFinishedSpans()[0].attributes[fi_semantic_conventions_1.SemanticConventions.LLM_INPUT_MESSAGES]).toContain("earlier");
+}));
+function clientFor(sdk, v2 = false) {
+    instrumentation.manuallyInstrument(sdk);
+    return new (v2 ? sdk.CohereClientV2 : sdk.CohereClient)({ token: "offline-placeholder", environment: url });
+}
+const request = { model: "command-test", message: "question" };
+const requestV2 = { model: "command-test", messages: [{ role: "user", content: "question" }] };
+function streamResponse(v2) {
+    const events = v2 ? [
+        { type: "content-delta", index: 0, delta: { message: { content: { text: "hel" } } } },
+        { type: "content-delta", index: 0, delta: { message: { content: { text: "lo" } } } },
+        { type: "tool-call-start", index: 0, delta: { message: { tool_calls: { id: "call-1", type: "function", function: { name: "lookup", arguments: "{\"key\":" } } } } },
+        { type: "tool-call-delta", index: 0, delta: { message: { tool_calls: { function: { arguments: "\"value\"}" } } } } },
+        { type: "message-end", delta: { finish_reason: "COMPLETE", usage: { tokens: { input_tokens: 5, output_tokens: 2 } } } },
+    ] : [
+        { event_type: "text-generation", text: "hel" },
+        { event_type: "text-generation", text: "lo" },
+        { event_type: "stream-end", finish_reason: "COMPLETE", response: v1Response },
+    ];
+    contentType = v2 ? "text/event-stream" : "application/x-ndjson";
+    response = events.map((event) => v2 ? `data: ${JSON.stringify(event)}\n\n` : `${JSON.stringify(event)}\n`).join("");
+    return events;
+}
+it.each([false, true])("traces real v2=%s SDK streaming through terminal usage and preserves helpers", (v2) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, e_1, _b, _c;
+    const client = clientFor(sdk8, v2);
+    const expected = streamResponse(v2);
+    const pending = client.chatStream(v2 ? requestV2 : request);
+    expect(typeof pending.withRawResponse).toBe("function");
+    const { data: stream, rawResponse } = yield pending.withRawResponse();
+    expect(rawResponse.status).toBe(200);
+    expect(yield pending).toBe(stream);
+    expect(stream.controller).toBeInstanceOf(AbortController);
+    expect(exporter.getFinishedSpans()).toHaveLength(0);
+    const events = [];
+    try {
+        for (var _d = true, stream_1 = __asyncValues(stream), stream_1_1; stream_1_1 = yield stream_1.next(), _a = stream_1_1.done, !_a; _d = true) {
+            _c = stream_1_1.value;
+            _d = false;
+            const event = _c;
+            events.push(event);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (!_d && !_a && (_b = stream_1.return)) yield _b.call(stream_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    expect(events).toHaveLength(expected.length);
+    const spans = exporter.getFinishedSpans();
+    expect(spans).toHaveLength(1);
+    expect(spans[0].attributes[fi_semantic_conventions_1.SemanticConventions.OUTPUT_VALUE]).toBe("hello");
+    expect(spans[0].attributes[fi_semantic_conventions_1.SemanticConventions.LLM_TOKEN_COUNT_PROMPT]).toBe(5);
+    expect(spans[0].attributes[fi_semantic_conventions_1.SemanticConventions.LLM_TOKEN_COUNT_COMPLETION]).toBe(2);
+    expect(spans[0].status.code).toBe(api_1.SpanStatusCode.OK);
+    if (v2) {
+        const messages = JSON.parse(spans[0].attributes[fi_semantic_conventions_1.SemanticConventions.LLM_OUTPUT_MESSAGES]);
+        expect(messages[0].tool_calls[0]).toEqual({ id: "call-1", type: "function", function: { name: "lookup", arguments: '{"key":"value"}' } });
+    }
+}));
+it.each([false, true])("closes a real v2=%s SDK stream when the consumer breaks early", (v2) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, e_2, _b, _c;
+    const client = clientFor(sdk8, v2);
+    streamResponse(v2);
+    const stream = yield client.chatStream(v2 ? requestV2 : request);
+    try {
+        for (var _d = true, stream_2 = __asyncValues(stream), stream_2_1; stream_2_1 = yield stream_2.next(), _a = stream_2_1.done, !_a; _d = true) {
+            _c = stream_2_1.value;
+            _d = false;
+            const _event = _c;
+            break;
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (!_d && !_a && (_b = stream_2.return)) yield _b.call(stream_2);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    expect(exporter.getFinishedSpans()).toHaveLength(1);
+    expect(exporter.getFinishedSpans()[0].attributes["cohere.stream.cancelled"]).toBe(true);
+    expect(exporter.getFinishedSpans()[0].attributes[fi_semantic_conventions_1.SemanticConventions.OUTPUT_VALUE]).toBe("hel");
+    expect(exporter.getFinishedSpans()[0].status.code).toBe(api_1.SpanStatusCode.UNSET);
+}));
+it("finalizes on abort before iteration, without consuming events", () => __awaiter(void 0, void 0, void 0, function* () {
+    const client = clientFor(sdk8, true);
+    streamResponse(true);
+    const stream = yield client.chatStream(requestV2);
+    stream.controller.abort();
+    expect(exporter.getFinishedSpans()).toHaveLength(1);
+    expect(exporter.getFinishedSpans()[0].attributes["cohere.stream.cancelled"]).toBe(true);
+}));
+it("finalizes on return before first next", () => __awaiter(void 0, void 0, void 0, function* () {
+    const client = clientFor(sdk8, true);
+    streamResponse(true);
+    const stream = yield client.chatStream(requestV2);
+    yield stream[Symbol.asyncIterator]().return();
+    expect(exporter.getFinishedSpans()).toHaveLength(1);
+}));
+it("records SDK stream parser errors and preserves the rejection", () => __awaiter(void 0, void 0, void 0, function* () {
+    const client = clientFor(sdk8, true);
+    contentType = "text/event-stream";
+    response = "data: not-json\n\n";
+    const stream = yield client.chatStream(requestV2);
+    yield expect(stream[Symbol.asyncIterator]().next()).rejects.toBeInstanceOf(Error);
+    expect(exporter.getFinishedSpans()).toHaveLength(1);
+    expect(exporter.getFinishedSpans()[0].status.code).toBe(api_1.SpanStatusCode.ERROR);
+}));
+it.each([["7.0.0", sdk7], ["8.3.0", sdk8]])("preserves real %s SDK embeddings and reranker types", (_version, sdk) => __awaiter(void 0, void 0, void 0, function* () {
+    const client = clientFor(sdk);
+    response = { id: "embedding", response_type: "embeddings_floats", texts: ["document"], embeddings: [[0.1, 0.2]], meta: { billed_units: { input_tokens: 3 } } };
+    yield client.embed({ texts: ["document"], model: "embed-test", inputType: "search_document" });
+    response = { id: "rerank", results: [{ index: 0, relevance_score: 0.9, document: { text: "document" } }] };
+    const result = yield client.rerank({ model: "rerank-test", query: "query", documents: [{ text: "document" }], topN: 1 });
+    expect(result.results[0].relevanceScore).toBe(0.9);
+    const spans = exporter.getFinishedSpans();
+    expect(spans).toHaveLength(2);
+    expect(spans[0].attributes[fi_semantic_conventions_1.SemanticConventions.FI_SPAN_KIND]).toBe("EMBEDDING");
+    expect(spans[0].attributes[`${fi_semantic_conventions_1.SemanticConventions.EMBEDDING_EMBEDDINGS}.0.${fi_semantic_conventions_1.SemanticConventions.EMBEDDING_VECTOR}`]).toEqual([0.1, 0.2]);
+    expect(spans[1].attributes[fi_semantic_conventions_1.SemanticConventions.FI_SPAN_KIND]).toBe("RERANKER");
+    expect(spans[1].attributes["cohere.rerank.results.0.relevance_score"]).toBe(0.9);
+    expect(spans[1].attributes["cohere.rerank.top_n"]).toBe(1);
+    expect(received[1].body.top_n).toBe(1);
+}));
+it("instruments v2 embeddings, rerank and client.v2 without duplicate spans", () => __awaiter(void 0, void 0, void 0, function* () {
+    const client = clientFor(sdk8, true);
+    response = { id: "embedding", texts: ["document"], embeddings: { float: [[0.1, 0.2]] }, meta: { billed_units: { input_tokens: 3 } } };
+    yield client.embed({ texts: ["document"], model: "embed-test", inputType: "search_document", embeddingTypes: ["float"] });
+    response = { id: "rerank", results: [{ index: 0, relevance_score: 0.9 }] };
+    yield client.rerank({ model: "rerank-test", query: "query", documents: ["document"] });
+    response = v2Response;
+    const v1 = new sdk8.CohereClient({ token: "offline-placeholder", environment: url });
+    const pending = v1.v2.chat(requestV2, { headers: { "X-Test-Forwarded": "yes" } });
+    const raw = yield pending.withRawResponse();
+    expect(raw.data).toBe(yield pending);
+    expect(raw.rawResponse.status).toBe(200);
+    expect(received[2].headers).toMatchObject({ "x-test-forwarded": "yes" });
+    const spans = exporter.getFinishedSpans();
+    expect(spans).toHaveLength(3);
+    expect(spans.map((span) => span.attributes[fi_semantic_conventions_1.SemanticConventions.FI_SPAN_KIND])).toEqual(["EMBEDDING", "RERANKER", "LLM"]);
+    expect(spans[0].attributes[fi_semantic_conventions_1.SemanticConventions.LLM_TOKEN_COUNT_PROMPT]).toBe(3);
+}));
+it("does not invent a model name when the caller leaves it to Cohere", () => __awaiter(void 0, void 0, void 0, function* () {
+    const client = clientFor(sdk7);
+    response = v1Response;
+    yield client.chat({ message: "question" });
+    expect(exporter.getFinishedSpans()[0].attributes[fi_semantic_conventions_1.SemanticConventions.LLM_MODEL_NAME]).toBeUndefined();
+}));
+it("supports multiple SDK copies, idempotent manual patching and enable/disable", () => __awaiter(void 0, void 0, void 0, function* () {
+    const client7 = clientFor(sdk7);
+    const client8 = clientFor(sdk8, true);
+    instrumentation.manuallyInstrument(sdk8);
+    expect((0, instrumentation_1.isPatched)()).toBe(true);
+    response = v1Response;
+    yield client7.chat(request);
+    response = v2Response;
+    yield client8.chat(requestV2);
+    expect(exporter.getFinishedSpans()).toHaveLength(2);
+    instrumentation.disable();
+    expect((0, instrumentation_1.isPatched)()).toBe(false);
+    yield client8.chat(requestV2); // already-bound method must respect disable
+    instrumentation.enable();
+    yield client8.chat(requestV2);
+    const newClient8 = clientFor(sdk8, true);
+    yield newClient8.chat(requestV2);
+    expect(exporter.getFinishedSpans()).toHaveLength(4);
+}));
+it("does not let a second instrumentor unwrap another owner's methods", () => __awaiter(void 0, void 0, void 0, function* () {
+    const client = clientFor(sdk8, true);
+    const other = new instrumentation_1.CohereInstrumentation();
+    other.setTracerProvider(provider);
+    other.manuallyInstrument(sdk8);
+    other.disable();
+    response = v2Response;
+    yield client.chat(requestV2);
+    expect(exporter.getFinishedSpans()).toHaveLength(1);
+}));
+it("honors suppression and propagates the parent across concurrent SDK calls", () => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const client = clientFor(sdk8, true);
+    response = v2Response;
+    yield api_1.context.with((0, core_1.suppressTracing)(api_1.context.active()), () => client.chat(requestV2));
+    expect(exporter.getFinishedSpans()).toHaveLength(0);
+    const parent = provider.getTracer("parent").startSpan("parent");
+    yield api_1.context.with(api_1.trace.setSpan(api_1.context.active(), parent), () => Promise.all([client.chat(requestV2), client.chat(requestV2)]));
+    parent.end();
+    const children = exporter.getFinishedSpans().filter((span) => span.name !== "parent");
+    expect(children).toHaveLength(2);
+    for (const child of children)
+        expect((_a = child.parentSpanContext) === null || _a === void 0 ? void 0 : _a.spanId).toBe(parent.spanContext().spanId);
+    expect(api_1.trace.getActiveSpan()).toBeUndefined();
+}));
+it.each(["normal", "raw", "stream"])("records real SDK HTTP errors using the %s path once", (mode) => __awaiter(void 0, void 0, void 0, function* () {
+    const client = clientFor(sdk8, true);
+    status = 400;
+    response = { message: "fixture-error" };
+    const pending = mode === "stream" ? client.chatStream(requestV2) : client.chat(requestV2);
+    yield expect(mode === "raw" ? pending.withRawResponse() : pending).rejects.toBeInstanceOf(sdk8.CohereError);
+    expect(exporter.getFinishedSpans()).toHaveLength(1);
+    expect(exporter.getFinishedSpans()[0].status.code).toBe(api_1.SpanStatusCode.ERROR);
+}));
+it.each(["content", "hidden", "vectors"])("exports correct shape and %s privacy over actual OTLP/HTTP", (mode) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, e_3, _b, _c;
+    instrumentation.disable();
+    const wireProvider = new sdk_trace_node_1.NodeTracerProvider({ spanProcessors: [new sdk_trace_base_1.SimpleSpanProcessor(new exporter_trace_otlp_http_1.OTLPTraceExporter({ url: `${url}/v1/traces` }))] });
+    instrumentation = new instrumentation_1.CohereInstrumentation({ traceConfig: mode === "hidden" ? { hideInputs: true, hideOutputs: true } : { hideEmbeddingVectors: mode === "vectors" } });
+    instrumentation.setTracerProvider(wireProvider);
+    try {
+        const client = clientFor(sdk8, true);
+        response = { id: "embedding", texts: ["secret-input"], embeddings: { float: [[0.123456789]] } };
+        yield client.embed({ texts: ["secret-input"], model: "embed-test", inputType: "search_document", embeddingTypes: ["float"] });
+        response = { id: "rerank", results: [{ index: 0, relevance_score: 0.9, document: { text: "secret-output" } }] };
+        yield client.rerank({ model: "rerank-test", query: "secret-input", documents: ["secret-input"], topN: 1 });
+        streamResponse(true);
+        response = String(response).replaceAll("hel", "secret-output");
+        const stream = yield client.chatStream(Object.assign(Object.assign({}, requestV2), { messages: [{ role: "user", content: "secret-input" }], tools: [{ type: "function", function: { name: "tool-secret-input", description: "secret-input", parameters: {} } }] }));
+        try {
+            for (var _d = true, stream_3 = __asyncValues(stream), stream_3_1; stream_3_1 = yield stream_3.next(), _a = stream_3_1.done, !_a; _d = true) {
+                _c = stream_3_1.value;
+                _d = false;
+                const _event = _c;
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = stream_3.return)) yield _b.call(stream_3);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        status = 400;
+        response = { message: "secret-input secret-output" };
+        yield expect(client.chat(requestV2)).rejects.toBeInstanceOf(Error);
+        yield wireProvider.forceFlush();
+        const encoded = JSON.stringify(wire);
+        const spans = wire.flatMap((batch) => batch.resourceSpans.flatMap((resource) => resource.scopeSpans.flatMap((scope) => scope.spans)));
+        expect(spans).toHaveLength(4);
+        const attrs = (span) => Object.fromEntries(span.attributes.map((item) => [item.key, Object.values(item.value)[0]]));
+        expect(attrs(spans[0])[fi_semantic_conventions_1.SemanticConventions.FI_SPAN_KIND]).toBe("EMBEDDING");
+        expect(attrs(spans[1])[fi_semantic_conventions_1.SemanticConventions.FI_SPAN_KIND]).toBe("RERANKER");
+        expect(attrs(spans[2])[fi_semantic_conventions_1.SemanticConventions.LLM_TOKEN_COUNT_PROMPT]).toBe(5);
+        expect(spans[3].status.code).toBe(api_1.SpanStatusCode.ERROR);
+        if (mode === "hidden") {
+            expect(encoded).not.toContain("secret-input");
+            expect(encoded).not.toContain("secret-output");
+            expect(encoded).not.toContain("0.123456789");
+        }
+        else {
+            expect(encoded).toContain("secret-input");
+            expect(encoded).toContain("secret-output");
+        }
+        if (mode === "vectors")
+            expect(encoded).not.toContain("0.123456789");
+    }
+    finally {
+        yield wireProvider.shutdown();
+    }
+}));
+it.each([[false, false], [false, true], [true, false], [true, true]])("marks premature EOF as incomplete (v2=%s, empty=%s) without changing SDK iteration", (v2, empty) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, e_4, _b, _c;
+    const client = clientFor(sdk8, v2);
+    const events = streamResponse(v2);
+    response = empty ? "" : (v2 ? `data: ${JSON.stringify(events[0])}\n\n` : `${JSON.stringify(events[0])}\n`);
+    const delivered = [];
+    try {
+        for (var _d = true, _e = __asyncValues(yield client.chatStream(v2 ? requestV2 : request)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+            _c = _f.value;
+            _d = false;
+            const event = _c;
+            delivered.push(event);
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    expect(delivered).toHaveLength(empty ? 0 : 1);
+    const spans = exporter.getFinishedSpans();
+    expect(spans).toHaveLength(1);
+    expect(spans[0].status.code).toBe(api_1.SpanStatusCode.ERROR);
+    expect(spans[0].status.message).toBe("Cohere stream ended without a terminal event");
+    expect(spans[0].attributes[fi_semantic_conventions_1.SemanticConventions.OUTPUT_VALUE]).toBe(empty ? "" : "hel");
+    expect(spans[0].attributes[fi_semantic_conventions_1.SemanticConventions.LLM_TOKEN_COUNT_PROMPT]).toBeUndefined();
+}));
+const privacyClients = [
+    ["7.0.0 v1", sdk7, false], ["8.3.0 v1", sdk8, false], ["8.3.0 v2", sdk8, true],
+];
+describe.each(privacyClients)("%s response privacy", (_label, sdk, v2) => {
+    it.each(["hideInputs", "hideInputMessages", "hideInputText", "hideInputImages"])("removes response-side input echoes with %s but retains generated output on the OTLP wire", (flag) => __awaiter(void 0, void 0, void 0, function* () {
+        instrumentation.disable();
+        const exporter = new sdk_trace_base_1.InMemorySpanExporter();
+        const wireProvider = new sdk_trace_node_1.NodeTracerProvider({ spanProcessors: [
+                new sdk_trace_base_1.SimpleSpanProcessor(exporter),
+                new sdk_trace_base_1.SimpleSpanProcessor(new exporter_trace_otlp_http_1.OTLPTraceExporter({ url: `${url}/v1/traces` })),
+            ] });
+        instrumentation = new instrumentation_1.CohereInstrumentation({ traceConfig: { [flag]: true } });
+        instrumentation.setTracerProvider(wireProvider);
+        try {
+            const client = clientFor(sdk, v2);
+            response = v2 ? Object.assign(Object.assign({}, v2Response), { message: { role: "assistant", content: [{ type: "text", text: "generated-answer" }],
+                    citations: [{ start: 0, end: 6, text: "generated-answer", sources: [{ type: "document", id: "doc", document: { text: "private-input-marker" } }] }] } }) : Object.assign(Object.assign({}, v1Response), { text: "generated-answer", chat_history: [
+                    { role: "USER", message: "private-input-marker" },
+                    { role: "CHATBOT", message: "private-input-marker-previous-answer" },
+                    { role: "CHATBOT", message: "generated-answer" },
+                ] });
+            const result = yield client.chat(v2 ? Object.assign(Object.assign({}, requestV2), { messages: [{ role: "user", content: "private-input-marker" }] }) : Object.assign(Object.assign({}, request), { message: "private-input-marker" }));
+            expect(v2 ? result.message.content[0].text : result.text).toBe("generated-answer");
+            // Sanitizing telemetry must not alter the SDK's response object.
+            expect(JSON.stringify(result)).toContain("private-input-marker");
+            response = { id: "embedding", response_type: "embeddings_floats", texts: ["private-input-marker"], embeddings: v2 ? { float: [[0.123456789]] } : [[0.123456789]] };
+            yield client.embed(Object.assign({ texts: ["private-input-marker"], model: "embed-test", inputType: "search_document" }, (v2 ? { embeddingTypes: ["float"] } : {})));
+            response = { id: "rerank", results: [{ index: 0, relevance_score: 0.9, document: { text: "private-input-marker" } }] };
+            yield client.rerank({ model: "rerank-test", query: "private-input-marker", documents: v2 ? ["private-input-marker"] : [{ text: "private-input-marker" }] });
+            yield wireProvider.forceFlush();
+            const spans = exporter.getFinishedSpans();
+            expect(spans).toHaveLength(3);
+            expect(JSON.stringify(spans.map(span => span.attributes))).not.toContain("private-input-marker");
+            expect(JSON.stringify(wire)).not.toContain("private-input-marker");
+            expect(JSON.stringify(wire)).toContain("generated-answer");
+            expect(spans[0].attributes[fi_semantic_conventions_1.SemanticConventions.OUTPUT_VALUE]).toBe("generated-answer");
+            expect(spans[0].attributes[fi_semantic_conventions_1.SemanticConventions.LLM_TOKEN_COUNT_PROMPT]).toBe(5);
+            expect(spans[1].attributes[`${fi_semantic_conventions_1.SemanticConventions.EMBEDDING_EMBEDDINGS}.0.${fi_semantic_conventions_1.SemanticConventions.EMBEDDING_VECTOR}`]).toEqual([0.123456789]);
+            expect(spans[2].attributes["cohere.rerank.results.0.relevance_score"]).toBe(0.9);
+        }
+        finally {
+            yield wireProvider.shutdown();
+        }
+    }));
+    it.each(["hideOutputs", "hideOutputMessages", "hideOutputText"])("keeps inputs visible when only %s is set", (flag) => __awaiter(void 0, void 0, void 0, function* () {
+        instrumentation.disable();
+        instrumentation = new instrumentation_1.CohereInstrumentation({ traceConfig: { [flag]: true } });
+        instrumentation.setTracerProvider(provider);
+        const client = clientFor(sdk, v2);
+        response = v2 ? v2Response : v1Response;
+        yield client.chat(v2 ? requestV2 : request);
+        const attrs = exporter.getFinishedSpans()[0].attributes;
+        expect(attrs[fi_semantic_conventions_1.SemanticConventions.INPUT_VALUE]).toContain("question");
+        expect(attrs[fi_semantic_conventions_1.SemanticConventions.RAW_OUTPUT]).toBeUndefined();
+        expect(attrs[fi_semantic_conventions_1.SemanticConventions.OUTPUT_VALUE]).toBeUndefined();
+        expect(attrs[fi_semantic_conventions_1.SemanticConventions.LLM_TOKEN_COUNT_PROMPT]).toBe(5);
+    }));
+});
+it("hides v1 terminal stream response echoes without losing generated text", () => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, e_5, _b, _c;
+    instrumentation.disable();
+    instrumentation = new instrumentation_1.CohereInstrumentation({ traceConfig: { hideInputs: true } });
+    instrumentation.setTracerProvider(provider);
+    const client = clientFor(sdk8);
+    contentType = "application/x-ndjson";
+    response = JSON.stringify({ event_type: "stream-end", finish_reason: "COMPLETE", response: Object.assign(Object.assign({}, v1Response), { chat_history: [{ role: "USER", message: "private-input-marker" }] }) }) + "\n";
+    try {
+        for (var _d = true, _e = __asyncValues(yield client.chatStream(Object.assign(Object.assign({}, request), { message: "private-input-marker" }))), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+            _c = _f.value;
+            _d = false;
+            const _event = _c;
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    const spans = exporter.getFinishedSpans();
+    expect(spans).toHaveLength(1);
+    expect(JSON.stringify(spans[0].attributes)).not.toContain("private-input-marker");
+    expect(spans[0].attributes[fi_semantic_conventions_1.SemanticConventions.OUTPUT_VALUE]).toBe("hello");
+    expect(spans[0].status.code).toBe(api_1.SpanStatusCode.OK);
+}));
+// Connector authentication is not user content and must never enter telemetry.
+describe.each(["capture", "hideOutputs", "hideInputs"])("8.3.0 connector credentials (%s)", (mode) => {
+    it.each([false, true])("keeps credentials on the vendor request only (stream=%s)", (streaming) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, e_6, _b, _c;
+        instrumentation.disable();
+        const captured = new sdk_trace_base_1.InMemorySpanExporter();
+        const wireProvider = new sdk_trace_node_1.NodeTracerProvider({ spanProcessors: [
+                new sdk_trace_base_1.SimpleSpanProcessor(captured),
+                new sdk_trace_base_1.SimpleSpanProcessor(new exporter_trace_otlp_http_1.OTLPTraceExporter({ url: `${url}/v1/traces` })),
+            ] });
+        instrumentation = new instrumentation_1.CohereInstrumentation({ traceConfig: mode === "capture" ? {} : { [mode]: true } });
+        instrumentation.setTracerProvider(wireProvider);
+        try {
+            const client = clientFor(sdk8);
+            const connector = Object.freeze({ id: "fixture-connector", userAccessToken: "synthetic-connector-credential", continueOnFailure: true, options: { site: "example.test" } });
+            const input = Object.freeze(Object.assign(Object.assign({}, request), { connectors: Object.freeze([connector]) }));
+            if (streaming) {
+                streamResponse(false);
+                try {
+                    for (var _d = true, _e = __asyncValues(yield client.chatStream(input)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                        _c = _f.value;
+                        _d = false;
+                        const _event = _c;
+                    }
+                }
+                catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                    }
+                    finally { if (e_6) throw e_6.error; }
+                }
+            }
+            else {
+                response = v1Response;
+                yield client.chat(input);
+            }
+            yield wireProvider.forceFlush();
+            expect(received).toHaveLength(1);
+            expect(received[0].body.connectors[0].user_access_token).toBe(connector.userAccessToken);
+            expect(input.connectors[0]).toBe(connector);
+            expect(input.connectors[0].userAccessToken).toBe("synthetic-connector-credential");
+            const spans = captured.getFinishedSpans();
+            expect(spans).toHaveLength(1);
+            expect(JSON.stringify(spans[0].attributes)).not.toContain(connector.userAccessToken);
+            expect(wire).not.toHaveLength(0);
+            expect(JSON.stringify(wire)).not.toContain(connector.userAccessToken);
+            if (mode === "hideInputs") {
+                expect(spans[0].attributes[fi_semantic_conventions_1.SemanticConventions.RAW_INPUT]).toBeUndefined();
+            }
+            else {
+                expect(JSON.parse(spans[0].attributes[fi_semantic_conventions_1.SemanticConventions.RAW_INPUT]).connectors).toEqual([
+                    { id: connector.id, continueOnFailure: true, options: { site: "example.test" } },
+                ]);
+            }
+        }
+        finally {
+            yield wireProvider.shutdown();
+        }
+    }));
+});
+const finishCases = [
+    ...[false, true].flatMap(v2 => [false, true].flatMap(streaming => (v2 ? ["COMPLETE", "STOP_SEQUENCE", "MAX_TOKENS", "TOOL_CALL", "ERROR", "TIMEOUT"]
+        : ["COMPLETE", "STOP_SEQUENCE", "MAX_TOKENS", "ERROR", "ERROR_TOXIC", "ERROR_LIMIT", "TIMEOUT", "USER_CANCEL"])
+        .map(reason => ({ label: `8.3.0 v${v2 ? 2 : 1}`, sdk: sdk8, v2, streaming, reason })))),
+];
+describe.each([false, true])("finish reasons with hideOutputs=%s", (hideOutputs) => {
+    it.each(finishCases)("classifies $label stream=$streaming $reason without changing SDK results", (_a) => __awaiter(void 0, [_a], void 0, function* ({ sdk, v2, streaming, reason }) {
+        var _b, e_7, _c, _d;
+        instrumentation.disable();
+        instrumentation = new instrumentation_1.CohereInstrumentation({ traceConfig: { hideOutputs } });
+        instrumentation.setTracerProvider(provider);
+        const client = clientFor(sdk, v2);
+        const failed = ["ERROR", "ERROR_TOXIC", "ERROR_LIMIT", "TIMEOUT"].includes(reason);
+        const cancelled = reason === "USER_CANCEL";
+        if (streaming) {
+            const events = streamResponse(v2);
+            if (v2)
+                events[events.length - 1].delta.finish_reason = reason;
+            else
+                events[events.length - 1].finish_reason = reason;
+            response = events.map(event => v2 ? `data: ${JSON.stringify(event)}\n\n` : `${JSON.stringify(event)}\n`).join("");
+            const delivered = [];
+            try {
+                for (var _e = true, _f = __asyncValues(yield client.chatStream(v2 ? requestV2 : request)), _g; _g = yield _f.next(), _b = _g.done, !_b; _e = true) {
+                    _d = _g.value;
+                    _e = false;
+                    const event = _d;
+                    delivered.push(event);
+                }
+            }
+            catch (e_7_1) { e_7 = { error: e_7_1 }; }
+            finally {
+                try {
+                    if (!_e && !_b && (_c = _f.return)) yield _c.call(_f);
+                }
+                finally { if (e_7) throw e_7.error; }
+            }
+            expect(delivered).toHaveLength(events.length);
+            const last = delivered[delivered.length - 1];
+            expect(v2 ? last.delta.finishReason : last.finishReason).toBe(reason);
+        }
+        else {
+            response = Object.assign(Object.assign({}, (v2 ? v2Response : v1Response)), { finish_reason: reason });
+            const pending = client.chat(v2 ? requestV2 : request);
+            const result = yield pending;
+            expect(result.finishReason).toBe(reason);
+            expect(v2 ? result.message.content[0].text : result.text).toBe("hello");
+            expect((yield pending.withRawResponse()).data).toBe(result);
+        }
+        const spans = exporter.getFinishedSpans();
+        expect(spans).toHaveLength(1);
+        expect(spans[0].status.code).toBe(failed ? api_1.SpanStatusCode.ERROR : cancelled ? api_1.SpanStatusCode.UNSET : api_1.SpanStatusCode.OK);
+        expect(spans[0].attributes[streaming ? "cohere.stream.cancelled" : "cohere.request.cancelled"]).toBe(cancelled ? true : undefined);
+        expect(spans[0].events.filter(event => event.name === "exception")).toHaveLength(failed ? 1 : 0);
+        expect(spans[0].attributes[fi_semantic_conventions_1.SemanticConventions.OUTPUT_VALUE]).toBe(hideOutputs ? undefined : "hello");
+        expect(spans[0].attributes[fi_semantic_conventions_1.SemanticConventions.LLM_TOKEN_COUNT_PROMPT]).toBe(5);
+    }));
+});
+it.each(["complete", "start-only", "cancelled", "eof"])("captures v2 content-start text for %s streams", (mode) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, e_8, _b, _c;
+    const client = clientFor(sdk8, true);
+    const events = [{ type: "content-start", index: 0, delta: { message: { content: { type: "text", text: "initial-" } } } }];
+    if (mode === "complete")
+        events.push({ type: "content-delta", index: 0, delta: { message: { content: { text: "final" } } } });
+    if (mode !== "eof")
+        events.push({ type: "message-end", delta: { finish_reason: "COMPLETE" } });
+    contentType = "text/event-stream";
+    response = events.map(event => `data: ${JSON.stringify(event)}\n\n`).join("");
+    const delivered = [];
+    try {
+        for (var _d = true, _e = __asyncValues(yield client.chatStream(requestV2)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+            _c = _f.value;
+            _d = false;
+            const event = _c;
+            delivered.push(event);
+            if (mode === "cancelled")
+                break;
+        }
+    }
+    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+    finally {
+        try {
+            if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+        }
+        finally { if (e_8) throw e_8.error; }
+    }
+    expect(delivered[0].delta.message.content.text).toBe("initial-");
+    expect(delivered).toHaveLength(mode === "cancelled" ? 1 : events.length);
+    const spans = exporter.getFinishedSpans();
+    expect(spans).toHaveLength(1);
+    const text = mode === "complete" ? "initial-final" : "initial-";
+    expect(spans[0].attributes[fi_semantic_conventions_1.SemanticConventions.OUTPUT_VALUE]).toBe(text);
+    expect(JSON.parse(spans[0].attributes[fi_semantic_conventions_1.SemanticConventions.LLM_OUTPUT_MESSAGES])[0].content).toEqual([{ type: "text", text }]);
+    expect(JSON.parse(spans[0].attributes[fi_semantic_conventions_1.SemanticConventions.RAW_OUTPUT]).text).toBe(text);
+    expect(spans[0].status.code).toBe(mode === "eof" ? api_1.SpanStatusCode.ERROR : mode === "cancelled" ? api_1.SpanStatusCode.UNSET : api_1.SpanStatusCode.OK);
+}));
+// Generated reasoning and partial tool arguments are output, not input echoes.
+const outputModes = ["capture", "hideInputs", "hideOutputs", "hideOutputMessages", "hideOutputText"];
+describe.each(outputModes)("generated content with %s", (mode) => {
+    const hidden = mode.startsWith("hideOutput");
+    function captureOutput(action) {
+        return __awaiter(this, void 0, void 0, function* () {
+            instrumentation.disable();
+            const captured = new sdk_trace_base_1.InMemorySpanExporter();
+            const wireProvider = new sdk_trace_node_1.NodeTracerProvider({ spanProcessors: [
+                    new sdk_trace_base_1.SimpleSpanProcessor(captured),
+                    new sdk_trace_base_1.SimpleSpanProcessor(new exporter_trace_otlp_http_1.OTLPTraceExporter({ url: `${url}/v1/traces` })),
+                ] });
+            instrumentation = new instrumentation_1.CohereInstrumentation({ traceConfig: mode === "capture" ? {} : { [mode]: true } });
+            instrumentation.setTracerProvider(wireProvider);
+            try {
+                yield action(captured);
+                yield wireProvider.forceFlush();
+                expect(wire).not.toHaveLength(0);
+                expect(JSON.stringify(wire).includes("synthetic-generated-")).toBe(!hidden);
+            }
+            finally {
+                yield wireProvider.shutdown();
+            }
+        });
+    }
+    it.each(["chat", "complete", "cancelled", "eof", "start-only"])("preserves v2 reasoning blocks (%s)", (ending) => __awaiter(void 0, void 0, void 0, function* () {
+        yield captureOutput((captured) => __awaiter(void 0, void 0, void 0, function* () {
+            var _a, e_9, _b, _c;
+            const client = clientFor(sdk8, true);
+            const thinking = "synthetic-generated-reasoning-";
+            const blocks = [
+                { type: "thinking", thinking: thinking + (ending === "start-only" ? "" : "continued") },
+                { type: "text", text: "visible-answer" },
+                { type: "thinking", thinking: "second-thought" },
+            ];
+            if (ending === "chat") {
+                response = Object.assign(Object.assign({}, v2Response), { message: { role: "assistant", content: blocks } });
+                const result = yield client.chat(Object.assign(Object.assign({}, requestV2), { thinking: { type: "enabled" } }));
+                expect(result.message.content).toEqual(blocks);
+            }
+            else {
+                const events = [
+                    { type: "content-start", index: 0, delta: { message: { content: { type: "thinking", thinking } } } },
+                ];
+                if (ending !== "start-only")
+                    events.push({ type: "content-delta", index: 0, delta: { message: { content: { thinking: "continued" } } } }, { type: "content-end", index: 0 }, { type: "content-start", index: 1, delta: { message: { content: blocks[1] } } }, 
+                    // A delta without a start must also retain its generated content.
+                    { type: "content-delta", index: 2, delta: { message: { content: { thinking: "second-thought" } } } });
+                if (ending === "complete")
+                    events.push({ type: "message-end", delta: { finish_reason: "COMPLETE" } });
+                contentType = "text/event-stream";
+                response = events.map(event => `data: ${JSON.stringify(event)}\n\n`).join("");
+                const delivered = [];
+                try {
+                    for (var _d = true, _e = __asyncValues(yield client.chatStream(Object.assign(Object.assign({}, requestV2), { thinking: { type: "enabled" } }))), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                        _c = _f.value;
+                        _d = false;
+                        const event = _c;
+                        delivered.push(event);
+                        if (ending === "cancelled" && delivered.length === 2)
+                            break;
+                    }
+                }
+                catch (e_9_1) { e_9 = { error: e_9_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                    }
+                    finally { if (e_9) throw e_9.error; }
+                }
+                expect(delivered[0].delta.message.content.thinking).toBe(thinking);
+                expect(delivered).toHaveLength(ending === "cancelled" ? 2 : events.length);
+            }
+            const spans = captured.getFinishedSpans();
+            expect(spans).toHaveLength(1);
+            const attrs = spans[0].attributes;
+            expect(spans[0].status.code).toBe(ending === "cancelled" ? api_1.SpanStatusCode.UNSET : ["eof", "start-only"].includes(ending) ? api_1.SpanStatusCode.ERROR : api_1.SpanStatusCode.OK);
+            if (hidden) {
+                expect(attrs[fi_semantic_conventions_1.SemanticConventions.LLM_OUTPUT_MESSAGES]).toBeUndefined();
+                expect(attrs[fi_semantic_conventions_1.SemanticConventions.RAW_OUTPUT]).toBeUndefined();
+                expect(JSON.stringify(attrs)).not.toContain(thinking);
+            }
+            else {
+                const expectedBlocks = ["cancelled", "start-only"].includes(ending) ? blocks.slice(0, 1) : blocks;
+                expect(JSON.parse(attrs[fi_semantic_conventions_1.SemanticConventions.LLM_OUTPUT_MESSAGES])[0].content).toEqual(expectedBlocks);
+                expect(JSON.parse(attrs[fi_semantic_conventions_1.SemanticConventions.RAW_OUTPUT]).message.content).toEqual(expectedBlocks);
+                expect(attrs[fi_semantic_conventions_1.SemanticConventions.OUTPUT_VALUE]).toBe(expectedBlocks.length === 1 ? "" : "visible-answer");
+            }
+        }));
+    }));
+    it.each(["chat", "complete", "cancelled", "eof"])("retains v2 generated tool plans (%s)", (ending) => __awaiter(void 0, void 0, void 0, function* () {
+        yield captureOutput((captured) => __awaiter(void 0, void 0, void 0, function* () {
+            var _a, e_10, _b, _c;
+            const client = clientFor(sdk8, true);
+            const plan = "synthetic-generated-tool-plan-continued";
+            if (ending === "chat") {
+                response = Object.assign(Object.assign({}, v2Response), { message: { role: "assistant", tool_plan: plan, tool_calls: [{ id: "call-1", type: "function", function: { name: "lookup", arguments: "{}" } }] } });
+                const result = yield client.chat(requestV2);
+                expect(result.message.toolPlan).toBe(plan);
+            }
+            else {
+                const events = [
+                    { type: "tool-plan-delta", delta: { message: { tool_plan: "synthetic-generated-tool-plan-" } } },
+                    { type: "tool-plan-delta", delta: { message: { tool_plan: "continued" } } },
+                    { type: "tool-call-start", index: 0, delta: { message: { tool_calls: { id: "call-1", type: "function", function: { name: "lookup", arguments: "{}" } } } } },
+                ];
+                if (ending === "complete")
+                    events.push({ type: "message-end", delta: { finish_reason: "TOOL_CALL" } });
+                contentType = "text/event-stream";
+                response = events.map(event => `data: ${JSON.stringify(event)}\n\n`).join("");
+                const delivered = [];
+                try {
+                    for (var _d = true, _e = __asyncValues(yield client.chatStream(requestV2)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                        _c = _f.value;
+                        _d = false;
+                        const event = _c;
+                        delivered.push(event);
+                        if (ending === "cancelled" && delivered.length === 3)
+                            break;
+                    }
+                }
+                catch (e_10_1) { e_10 = { error: e_10_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                    }
+                    finally { if (e_10) throw e_10.error; }
+                }
+                expect(delivered[0].delta.message.toolPlan).toBe("synthetic-generated-tool-plan-");
+            }
+            const spans = captured.getFinishedSpans();
+            expect(spans).toHaveLength(1);
+            const attrs = spans[0].attributes;
+            expect(spans[0].status.code).toBe(ending === "cancelled" ? api_1.SpanStatusCode.UNSET : ending === "eof" ? api_1.SpanStatusCode.ERROR : api_1.SpanStatusCode.OK);
+            if (hidden) {
+                expect(attrs[fi_semantic_conventions_1.SemanticConventions.LLM_OUTPUT_MESSAGES]).toBeUndefined();
+                expect(attrs[fi_semantic_conventions_1.SemanticConventions.RAW_OUTPUT]).toBeUndefined();
+                expect(JSON.stringify(attrs)).not.toContain("synthetic-generated-");
+            }
+            else {
+                expect(JSON.parse(attrs[fi_semantic_conventions_1.SemanticConventions.RAW_OUTPUT]).message.toolPlan).toBe(plan);
+                expect(JSON.parse(attrs[fi_semantic_conventions_1.SemanticConventions.LLM_OUTPUT_MESSAGES])[0].tool_plan).toBe(plan);
+                expect(attrs[fi_semantic_conventions_1.SemanticConventions.OUTPUT_VALUE]).not.toContain(plan);
+            }
+        }));
+    }));
+    it.each(["cancelled", "eof", "terminal", "generation"])("retains v1 generated tool plans (%s)", (ending) => __awaiter(void 0, void 0, void 0, function* () {
+        yield captureOutput((captured) => __awaiter(void 0, void 0, void 0, function* () {
+            var _a, e_11, _b, _c;
+            const client = clientFor(sdk8);
+            const partial = "synthetic-generated-tool-plan-continued";
+            const events = [
+                { event_type: "tool-calls-chunk", tool_call_delta: { index: 0, text: "synthetic-generated-tool-plan-", name: "lookup", parameters: "{}" } },
+                { event_type: "tool-calls-chunk", tool_call_delta: { index: 0, text: "continued" } },
+            ];
+            if (ending === "generation")
+                events.push({ event_type: "tool-calls-generation", text: partial, tool_calls: [{ name: "lookup", parameters: {} }] });
+            if (ending === "terminal")
+                events.push({ event_type: "stream-end", finish_reason: "COMPLETE", response: { text: partial, tool_calls: [{ name: "lookup", parameters: {} }] } });
+            contentType = "application/x-ndjson";
+            response = events.map(event => `${JSON.stringify(event)}\n`).join("");
+            const delivered = [];
+            try {
+                for (var _d = true, _e = __asyncValues(yield client.chatStream(request)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                    _c = _f.value;
+                    _d = false;
+                    const event = _c;
+                    delivered.push(event);
+                    if (ending === "cancelled" && delivered.length === 2)
+                        break;
+                }
+            }
+            catch (e_11_1) { e_11 = { error: e_11_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                }
+                finally { if (e_11) throw e_11.error; }
+            }
+            expect(delivered[0].toolCallDelta.text).toBe("synthetic-generated-tool-plan-");
+            const spans = captured.getFinishedSpans();
+            expect(spans).toHaveLength(1);
+            const attrs = spans[0].attributes;
+            expect(spans[0].status.code).toBe(ending === "terminal" ? api_1.SpanStatusCode.OK : ending === "cancelled" ? api_1.SpanStatusCode.UNSET : api_1.SpanStatusCode.ERROR);
+            if (hidden) {
+                expect(attrs[fi_semantic_conventions_1.SemanticConventions.LLM_OUTPUT_MESSAGES]).toBeUndefined();
+                expect(attrs[fi_semantic_conventions_1.SemanticConventions.RAW_OUTPUT]).toBeUndefined();
+                expect(JSON.stringify(attrs)).not.toContain("synthetic-generated-");
+            }
+            else {
+                expect(JSON.parse(attrs[fi_semantic_conventions_1.SemanticConventions.RAW_OUTPUT]).message.toolPlan).toBe(partial);
+                expect(JSON.parse(attrs[fi_semantic_conventions_1.SemanticConventions.LLM_OUTPUT_MESSAGES])[0].tool_plan).toBe(partial);
+            }
+        }));
+    }));
+    it.each(["cancelled", "eof", "terminal", "generation"])("preserves v1 tool chunks (%s)", (ending) => __awaiter(void 0, void 0, void 0, function* () {
+        yield captureOutput((captured) => __awaiter(void 0, void 0, void 0, function* () {
+            var _a, e_12, _b, _c;
+            const client = clientFor(sdk8);
+            // Interleave calls and leave one argument incomplete: telemetry must not
+            // require JSON parsing, mix call indices, or quote an already-raw string.
+            const events = [
+                { event_type: "tool-calls-chunk", tool_call_delta: { index: 1, name: "second", parameters: '{"synthetic-generated-second":' } },
+                { event_type: "tool-calls-chunk", tool_call_delta: { index: 0, name: "lookup", parameters: '{"synthetic-generated-key":' } },
+                { event_type: "tool-calls-chunk", tool_call_delta: { index: 0, parameters: '"value"}' } },
+            ];
+            const finalCalls = [{ name: "authoritative", parameters: { "synthetic-generated-final": true } }];
+            if (ending === "terminal")
+                events.push({ event_type: "stream-end", finish_reason: "COMPLETE", response: { text: "", tool_calls: finalCalls } });
+            if (ending === "generation")
+                events.push({ event_type: "tool-calls-generation", tool_calls: finalCalls });
+            contentType = "application/x-ndjson";
+            response = events.map(event => `${JSON.stringify(event)}\n`).join("");
+            const delivered = [];
+            try {
+                for (var _d = true, _e = __asyncValues(yield client.chatStream(request)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                    _c = _f.value;
+                    _d = false;
+                    const event = _c;
+                    delivered.push(event);
+                    if (ending === "cancelled" && delivered.length === 3)
+                        break;
+                }
+            }
+            catch (e_12_1) { e_12 = { error: e_12_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                }
+                finally { if (e_12) throw e_12.error; }
+            }
+            expect(delivered[1].toolCallDelta.name).toBe("lookup");
+            expect(delivered[2].toolCallDelta.parameters).toBe('"value"}');
+            expect(delivered).toHaveLength(events.length);
+            const spans = captured.getFinishedSpans();
+            expect(spans).toHaveLength(1);
+            const attrs = spans[0].attributes;
+            expect(spans[0].status.code).toBe(ending === "terminal" ? api_1.SpanStatusCode.OK : ending === "cancelled" ? api_1.SpanStatusCode.UNSET : api_1.SpanStatusCode.ERROR);
+            if (hidden) {
+                expect(attrs[fi_semantic_conventions_1.SemanticConventions.LLM_OUTPUT_MESSAGES]).toBeUndefined();
+                expect(attrs[fi_semantic_conventions_1.SemanticConventions.RAW_OUTPUT]).toBeUndefined();
+                expect(JSON.stringify(attrs)).not.toContain("synthetic-generated-");
+            }
+            else {
+                const calls = ["terminal", "generation"].includes(ending) ? finalCalls : [
+                    { name: "lookup", parameters: '{"synthetic-generated-key":"value"}' },
+                    { name: "second", parameters: '{"synthetic-generated-second":' },
+                ];
+                expect(JSON.parse(attrs[fi_semantic_conventions_1.SemanticConventions.RAW_OUTPUT]).toolCalls).toEqual(calls);
+                expect(JSON.parse(attrs[fi_semantic_conventions_1.SemanticConventions.LLM_OUTPUT_MESSAGES])[0].tool_calls).toEqual(calls.map(call => ({
+                    function: { name: call.name, arguments: typeof call.parameters === "string" ? call.parameters : JSON.stringify(call.parameters) },
+                })));
+            }
+        }));
+    }));
+});
+//# sourceMappingURL=sdk.test.js.map