The cross-harness, self-improving memory layer for AI agents. Join our community: https://discord.com/invite/zdNChS2fBu
Go agent-ai-cliagent-harnessesagent-securitybrowser-extensionciclaude-codecloudcodexcursordetection-engineeringjevknowledge-basememorymobile-device-managementobservabilitysecuritysecurity-information-and-event-managementsecurity-toolstelemetrytraces
fix(sdk): keep stream controls on wrapped Claude Agent queries (#831)
Rudy Mizrahi Celekli258a389f278a
diff --git a/packages/asymptote-sdk-js/src/index.test.ts b/packages/asymptote-sdk-js/src/index.test.tsindex 4387a7d4..d493d939 100644--- a/packages/asymptote-sdk-js/src/index.test.ts+++ b/packages/asymptote-sdk-js/src/index.test.ts@@ -372,6 +372,66 @@ describe("Asymptote Observe SDK", () => {expect(exporter.getFinishedSpans()).toHaveLength(1);});+ it("preserves stream control methods and their original receiver", async () => {+ const exporter = new InMemorySpanExporter();+ initialize({ spanExporter: exporter, disableDefaultExporter: true, disableBatch: true });+ class Stream {+ #interrupted = false;+ async interrupt() { this.#interrupted = true; }+ get interrupted() { return this.#interrupted; }+ async *[Symbol.asyncIterator]() { if (!this.#interrupted) yield "message"; }+ }+ const original = new Stream();+ const query = wrapClaudeAgentQuery(() => original);+ const stream = query();+ expect(stream.interrupt).toBe(stream.interrupt);+ await stream.interrupt();+ expect(original.interrupted).toBe(true);+ expect(stream.interrupted).toBe(true);+ const messages = [];+ for await (const message of stream) messages.push(message);+ expect(messages).toEqual([]);+ await flush();+ expect(exporter.getFinishedSpans()).toHaveLength(1);+ });++ it("keeps direct iterator methods traced when a control closes the real source", async () => {+ const exporter = new InMemorySpanExporter();+ initialize({ spanExporter: exporter, disableDefaultExporter: true, disableBatch: true });+ let cleaned = false;+ const source = (async function* () {+ try { yield "first"; yield "second"; } finally { cleaned = true; }+ })();+ const interrupt = async () => { await source.return(); };+ const original = Object.assign(source, { interrupt, stop: interrupt });+ Object.defineProperty(original, "stop", { value: original.interrupt, configurable: false, writable: false });+ const stream = wrapClaudeAgentQuery(() => original)();+ expect(stream[Symbol.asyncIterator]()).toBe(stream);+ expect(await stream.next()).toEqual({ value: "first", done: false });+ await stream.stop();+ expect(cleaned).toBe(true);+ expect(await stream.next()).toEqual({ value: undefined, done: true });+ await flush();+ expect(exporter.getFinishedSpans()).toHaveLength(1);+ });++ it("traces explicit iterator throw and preserves source cleanup", async () => {+ const exporter = new InMemorySpanExporter();+ initialize({ spanExporter: exporter, disableDefaultExporter: true, disableBatch: true });+ let cleaned = false;+ const original = (async function* () {+ try { yield "first"; } finally { cleaned = true; }+ })();+ const stream = wrapClaudeAgentQuery(() => original)();+ await stream.next();+ const failure = new Error("consumer failed");+ await expect(stream.throw(failure)).rejects.toBe(failure);+ expect(cleaned).toBe(true);+ await flush();+ expect(exporter.getFinishedSpans()).toHaveLength(1);+ expect(exporter.getFinishedSpans()[0]?.status.code).toBe(SpanStatusCode.ERROR);+ });+it("provides a tracer compatible with Vercel-style telemetry hooks", async () => {const exporter = new InMemorySpanExporter();initialize({ spanExporter: exporter, disableDefaultExporter: true, disableBatch: true });diff --git a/packages/asymptote-sdk-js/src/index.ts b/packages/asymptote-sdk-js/src/index.tsindex 0fecd2ac..a1673cac 100644--- a/packages/asymptote-sdk-js/src/index.ts+++ b/packages/asymptote-sdk-js/src/index.ts@@ -563,7 +563,31 @@ function finishResult<T>(result: T, span: Span, options?: ObserveOptions): unkno);}if (isAsyncIterable(result)) {- return finishAsyncIterable(result, span);+ // A stream such as the Claude Agent SDK's Query carries controls (interrupt(), setModel(), ...)+ // beside its iterator. Iteration goes through the traced iterator; every other read goes to+ // the original stream, with functions bound to it so private-field methods keep working, and+ // cached so repeated reads return the same function. The proxy targets the wrapper rather+ // than the original, whose read-only properties would make a binding get trap invalid.+ const iterator = finishAsyncIterable(result, span);+ const methods = {+ next: iterator.next.bind(iterator),+ return: iterator.return.bind(iterator),+ throw: iterator.throw.bind(iterator),+ };+ const controls = new Map<Function, Function>();+ const stream: AsyncGenerator<unknown> = new Proxy(iterator, {+ get(_target, key) {+ if (key === Symbol.asyncIterator) return iteratorForStream;+ if (key === "next" || key === "return" || key === "throw") return methods[key];+ const value = Reflect.get(result, key, result);+ if (typeof value !== "function" || key === "constructor") return value;+ let control = controls.get(value);+ if (!control) { control = value.bind(result); controls.set(value, control!); }+ return control;+ },+ });+ function iteratorForStream() { return stream; }+ return stream;}if (!options?.ignoreOutput) {span.setAttribute("asymptote.observe.output.type", typeof result);