Skip to content

The cross-harness, self-improving memory layer for AI agents. Join our community: https://discord.com/invite/zdNChS2fBu

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.ts
index 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.ts
index 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);