@morsehq-dev/sdk 0.5.0-rc.4 → 0.5.0-rc.5

package/dist/anthropic-agent-sdk/index.d.ts

@@ -62,21 +62,6 @@ interface ClaudeSDKClientLike {
     on?(event: string, handler: (payload: unknown) => void): void;
     off?(event: string, handler: (payload: unknown) => void): void;
 }
-/**
- * Subset of the SDK module shape we probe when patching via
- * `instrumentClaudeAgentSDK({ claudeAgentSdkModule })`. Best-effort.
- */
-interface ClaudeAgentSDKModuleLike {
-    ClaudeSDKClient?: {
-        prototype: {
-            query: unknown;
-            [k: string]: unknown;
-        };
-    };
-    query?: (...args: unknown[]) => unknown;
-    default?: unknown;
-    [k: string]: unknown;
-}
 
 /**
  * `@morsehq-dev/sdk/anthropic-agent-sdk` — Claude Agent SDK client wrapper.
@@ -120,27 +105,23 @@ interface WrapClaudeAgentSDKOptions {
  */
 declare function wrapClaudeAgentSDK<C extends ClaudeSDKClientLike>(client: C, options?: WrapClaudeAgentSDKOptions): C;
 /**
- * Top-level installer. Two modes:
+ * Instance wrapper. This once had a second mode that patched
+ * `ClaudeSDKClient.prototype.query` on the module. Deleted in MHQ-936 —
+ * neither half of it could ever work in TypeScript:
  *
- *   - `instrumentClaudeAgentSDK(client)` — equivalent to `wrapClaudeAgentSDK(client)`.
- *   - `instrumentClaudeAgentSDK({ claudeAgentSdkModule: mod })` — best-effort
- *     prototype patch on `ClaudeSDKClient.prototype.query`. Prefer the
- *     wrap form when possible.
+ *   - `ClaudeSDKClient` is the *Python* package's API. The TS package has
+ *     never exported it (checked at 0.1.77 and 0.3.223), so the carrier
+ *     lookup always returned null and the install silently no-opped.
+ *   - Patching the real `query` export is impossible regardless: it is
+ *     read-only and non-configurable, so assignment throws — the same wall
+ *     `ai` hit in MHQ-758.
  *
- * Always returns the wrapped client, `true`/`false` for the module path, or
- * `undefined` on absorbed error. Never throws.
- */
-type InstrumentClientArg = ClaudeSDKClientLike | (WrapClaudeAgentSDKOptions & {
-    claudeAgentSdkModule?: unknown;
-}) | undefined;
-declare const instrumentClaudeAgentSDK: (clientOrOptions?: InstrumentClientArg, maybeOptions?: WrapClaudeAgentSDKOptions) => Promise<unknown | undefined>;
-/**
- * Restore the prototype patch and clear the install sentinel. Pass the
- * same module reference given to `instrumentClaudeAgentSDK`, or omit and
- * the function will best-effort do nothing (no-op). Calling on a wrapped
- * client (vs. a module) is a no-op — just discard the wrapped client.
+ * For the real package use `wrapClaudeAgentQuery(query)` (`./query-wrapper.ts`).
+ * This remains for any object exposing a `.query` method.
+ *
+ * Never throws; returns the wrapped client, or a falsy value otherwise.
  */
-declare const uninstallClaudeAgentSDK: (claudeAgentSdkModule?: unknown) => void | undefined;
+declare const instrumentClaudeAgentSDK: (client?: ClaudeSDKClientLike, maybeOptions?: WrapClaudeAgentSDKOptions) => Promise<unknown | undefined>;
 /** True when a wrapped Claude Agent SDK client is passed in. */
 declare function isClaudeAgentSDKWrapped(client: unknown): boolean;
 
@@ -308,6 +289,48 @@ interface InstrumentToolsOptions {
  */
 declare function instrumentTools(events: AsyncIterable<SDKMessageLike>, options?: InstrumentToolsOptions): AsyncIterable<SDKMessageLike>;
 
+/** The subset of `Query` we depend on: async iteration. Everything else is forwarded. */
+interface ClaudeAgentQueryLike extends AsyncIterable<SDKMessageLike> {
+    [key: string]: unknown;
+}
+/** Real shape of the package's `query` export. One object argument. */
+type ClaudeAgentQueryFn = (params: {
+    prompt: unknown;
+    options?: {
+        model?: unknown;
+        [key: string]: unknown;
+    };
+}) => ClaudeAgentQueryLike;
+interface WrapClaudeAgentQueryOptions {
+    /** Agent name on the outer span when none can be derived. */
+    defaultAgentName?: string;
+    /** Model for the outer span when `params.options.model` is absent. */
+    defaultModel?: string;
+    /** Max bytes of serialized tool input captured per tool span. */
+    toolInputMaxBytes?: number;
+    /** Max bytes of serialized tool output captured per tool span. */
+    toolOutputMaxBytes?: number;
+}
+/** True if `fn` is already a traced query — wrapping twice would double-count spans. */
+declare function isClaudeAgentQueryWrapped(fn: unknown): boolean;
+/**
+ * Wrap the package's `query` function. The returned function has the same
+ * signature and returns a `Query`-compatible object.
+ *
+ * ```ts
+ * import { query } from "@anthropic-ai/claude-agent-sdk";
+ * import { wrapClaudeAgentQuery } from "@morsehq-dev/sdk/anthropic-agent-sdk";
+ *
+ * const tracedQuery = wrapClaudeAgentQuery(query);
+ * for await (const message of tracedQuery({ prompt: "..." })) { ... }
+ * ```
+ *
+ * Telemetry never changes what the caller sees: messages are yielded through
+ * untouched, and a throw from the underlying query propagates unchanged after
+ * the span is closed with the error.
+ */
+declare function wrapClaudeAgentQuery<Q extends ClaudeAgentQueryFn>(query: Q, options?: WrapClaudeAgentQueryOptions): Q;
+
 /**
  * `@morsehq-dev/sdk/anthropic-agent-sdk` — public surface for the
  * `@anthropic-ai/claude-agent-sdk` adapter.
@@ -368,4 +391,4 @@ interface FullInstrumentationResult<C extends ClaudeSDKClientLike> {
  */
 declare function wrapClaudeAgentSDKWithFullInstrumentation<C extends ClaudeSDKClientLike>(client: C, options?: FullInstrumentationOptions): FullInstrumentationResult<C>;
 
-export { type ClaudeAgentSDKModuleLike, type ClaudeSDKClientLike, type ClaudeSDKQueryOptions, type FullInstrumentationOptions, type FullInstrumentationResult, type HookEventLike, type InstallHookInstrumentationOptions, type InstrumentLlmCallsOptions, type InstrumentToolsOptions, type SDKMessageLike, type WrapClaudeAgentSDKOptions, installHookInstrumentation, instrumentClaudeAgentSDK, instrumentLlmCalls, instrumentTools, isClaudeAgentSDKWrapped, uninstallClaudeAgentSDK, wrapClaudeAgentSDK, wrapClaudeAgentSDKWithFullInstrumentation };
+export { type ClaudeAgentQueryFn, type ClaudeAgentQueryLike, type ClaudeSDKClientLike, type ClaudeSDKQueryOptions, type FullInstrumentationOptions, type FullInstrumentationResult, type HookEventLike, type InstallHookInstrumentationOptions, type InstrumentLlmCallsOptions, type InstrumentToolsOptions, type SDKMessageLike, type WrapClaudeAgentQueryOptions, type WrapClaudeAgentSDKOptions, installHookInstrumentation, instrumentClaudeAgentSDK, instrumentLlmCalls, instrumentTools, isClaudeAgentQueryWrapped, isClaudeAgentSDKWrapped, wrapClaudeAgentQuery, wrapClaudeAgentSDK, wrapClaudeAgentSDKWithFullInstrumentation };

package/dist/anthropic-agent-sdk/index.js

@@ -1,17 +1,15 @@
-import { extractAnthropicSegments } from '../chunk-2O2FFJLK.js';
-import '../chunk-YPP5DDPO.js';
-import { summarizeToolInput, summarizeToolOutput } from '../chunk-JFFZBCTP.js';
-import { emitAgentSpan, emitHookSpan, emitLlmSpan, emitToolSpan } from '../chunk-BNMTY7PE.js';
-import { absorbErrorsAsync, absorbErrorsSync } from '../chunk-Q6NQQ2LO.js';
+import { extractAnthropicSegments } from '../chunk-NR36TJMT.js';
+import '../chunk-QZDUGEIR.js';
+import { summarizeToolInput, summarizeToolOutput } from '../chunk-HONYN2OI.js';
+import { emitHookSpan, emitAgentSpan, emitLlmSpan, emitToolSpan } from '../chunk-MNV4HASC.js';
+import { absorbErrorsAsync, absorbErrorsSync } from '../chunk-YKPZQPEW.js';
 import { calculateCost } from '../chunk-XTKMUJWI.js';
 import '../chunk-4JPZV2VZ.js';
-import { init_tracing, getActiveTraceState, runAsync, startSpan, init_diagnostics, report } from '../chunk-ELBY4SJ7.js';
+import { init_tracing, getActiveTraceState, startSpan, init_diagnostics, runAsync, report } from '../chunk-ELVBOJWY.js';
 
 // src/anthropic-agent-sdk/client-wrapper.ts
 init_tracing();
 var WRAPPED_CLIENT = /* @__PURE__ */ Symbol.for("morse.anthropic-agent-sdk.wrapped");
-var INSTALL_SENTINEL = /* @__PURE__ */ Symbol.for("morse.anthropic-agent-sdk.installed");
-var ORIGINALS_SENTINEL = /* @__PURE__ */ Symbol.for("morse.anthropic-agent-sdk.originals");
 function wrapClaudeAgentSDK(client, options = {}) {
   if (!client || typeof client !== "object") return client;
   if (client[WRAPPED_CLIENT]) return client;
@@ -35,47 +33,12 @@ function wrapClaudeAgentSDK(client, options = {}) {
   return wrapper;
 }
 var instrumentClaudeAgentSDK = absorbErrorsAsync(
-  async (clientOrOptions = void 0, maybeOptions = {}) => {
-    if (clientOrOptions && isClient(clientOrOptions)) {
-      const opts2 = maybeOptions ?? {};
-      return wrapClaudeAgentSDK(clientOrOptions, opts2);
-    }
-    const opts = clientOrOptions ?? {};
-    const mod = await loadClaudeAgentSDKModule(opts.claudeAgentSdkModule);
-    if (!mod) return false;
-    const installed = mod[INSTALL_SENTINEL] === true;
-    if (installed) return true;
-    const carrier = findClientPrototypeCarrier(mod);
-    if (!carrier) return false;
-    const originalQuery = carrier.prototype.query;
-    if (typeof originalQuery !== "function") return false;
-    const patchedQuery = buildPatchedQuery(function(prompt, callOptions) {
-      return originalQuery.call(this, prompt, callOptions);
-    }, opts);
-    carrier.prototype.query = patchedQuery;
-    mod[ORIGINALS_SENTINEL] = {
-      protoQuery: originalQuery,
-      protoCarrier: carrier
-    };
-    mod[INSTALL_SENTINEL] = true;
-    return true;
+  async (client = void 0, maybeOptions = {}) => {
+    if (client && isClient(client)) return wrapClaudeAgentSDK(client, maybeOptions);
+    return false;
   },
   { fingerprint: "morse.adapters.anthropic-agent-sdk.install" }
 );
-var uninstallClaudeAgentSDK = absorbErrorsSync(
-  (claudeAgentSdkModule) => {
-    if (!claudeAgentSdkModule || typeof claudeAgentSdkModule !== "object") return;
-    const mod = claudeAgentSdkModule;
-    if (!mod[INSTALL_SENTINEL]) return;
-    const originals = mod[ORIGINALS_SENTINEL];
-    if (originals?.protoCarrier && originals.protoQuery !== void 0) {
-      originals.protoCarrier.prototype.query = originals.protoQuery;
-    }
-    mod[ORIGINALS_SENTINEL] = void 0;
-    mod[INSTALL_SENTINEL] = false;
-  },
-  { fingerprint: "morse.adapters.anthropic-agent-sdk.uninstall" }
-);
 function isClaudeAgentSDKWrapped(client) {
   if (!client || typeof client !== "object") return false;
   return client[WRAPPED_CLIENT] === true;
@@ -85,35 +48,13 @@ function isClient(x) {
   const q = x.query;
   return typeof q === "function";
 }
-async function loadClaudeAgentSDKModule(explicit) {
-  if (explicit && typeof explicit === "object") return explicit;
-  try {
-    return await Function("m", "return import(m)")("@anthropic-ai/claude-agent-sdk");
-  } catch {
-    return null;
-  }
-}
-function findClientPrototypeCarrier(mod) {
-  if (!mod || typeof mod !== "object") return null;
-  const m = mod;
-  const candidates = [
-    m.ClaudeSDKClient,
-    m.default?.ClaudeSDKClient
-  ];
-  for (const c of candidates) {
-    if (c && typeof c === "function" && c.prototype && typeof c.prototype.query === "function") {
-      return c;
-    }
-  }
-  return null;
-}
 function buildPatchedQuery(original, options) {
   const defaultAgentName = options.defaultAgentName ?? "claude-agent-sdk";
   const defaultModel = options.defaultModel;
   return function patchedQuery(prompt, callOptions) {
     const boundOriginal = (p, o) => original.call(this, p, o);
     const model = (callOptions && typeof callOptions.model === "string" ? callOptions.model : void 0) ?? defaultModel;
-    async function* iterateInTrace() {
+    async function* iterateInTrace2() {
       const handle = emitAgentSpan({
         adapter: "anthropic-agent-sdk",
         agentName: defaultAgentName,
@@ -138,7 +79,7 @@ function buildPatchedQuery(original, options) {
       handle?.end();
     }
     if (getActiveTraceState() !== null) {
-      return iterateInTrace();
+      return iterateInTrace2();
     }
     return (async function* outerTrace() {
       const queue = [];
@@ -155,7 +96,7 @@ function buildPatchedQuery(original, options) {
       });
       const runPromise = runAsync({ agentName: defaultAgentName }, async (runHandle) => {
         try {
-          for await (const event of iterateInTrace()) {
+          for await (const event of iterateInTrace2()) {
             queue.push({ kind: "value", value: event });
             notify?.();
           }
@@ -681,6 +622,119 @@ function reportSwallowed2(err, fingerprint) {
   }
 }
 
+// src/anthropic-agent-sdk/trace-bridge.ts
+init_tracing();
+function iterateInTrace(agentName, makeGenerator) {
+  if (getActiveTraceState() !== null) {
+    return makeGenerator();
+  }
+  return (async function* outerTrace() {
+    const queue = [];
+    let notify = null;
+    const waitForItem = () => new Promise((resolve) => {
+      if (queue.length > 0) {
+        resolve();
+      } else {
+        notify = () => {
+          notify = null;
+          resolve();
+        };
+      }
+    });
+    const runPromise = runAsync({ agentName }, async (runHandle) => {
+      try {
+        for await (const event of makeGenerator()) {
+          queue.push({ kind: "value", value: event });
+          notify?.();
+        }
+        runHandle.setOutcome(true);
+      } catch (err) {
+        queue.push({ kind: "error", error: err });
+        notify?.();
+        throw err;
+      } finally {
+        queue.push({ kind: "end" });
+        notify?.();
+      }
+      return null;
+    });
+    runPromise.catch(() => {
+    });
+    while (true) {
+      if (queue.length === 0) await waitForItem();
+      const item = queue.shift();
+      if (!item) continue;
+      if (item.kind === "value") {
+        yield item.value;
+      } else if (item.kind === "error") {
+        throw item.error;
+      } else {
+        return;
+      }
+    }
+  })();
+}
+
+// src/anthropic-agent-sdk/query-wrapper.ts
+var WRAPPED = /* @__PURE__ */ Symbol.for("morse.claudeAgentQuery.wrapped");
+function isClaudeAgentQueryWrapped(fn) {
+  return typeof fn === "function" && fn[WRAPPED] === true;
+}
+function wrapClaudeAgentQuery(query, options = {}) {
+  if (typeof query !== "function" || isClaudeAgentQueryWrapped(query)) return query;
+  const traced = function tracedQuery(params) {
+    const real = query(params);
+    const model = typeof params?.options?.model === "string" ? params.options.model : options.defaultModel;
+    let handle = null;
+    let opened = false;
+    async function* withAgentSpan() {
+      if (!opened) {
+        opened = true;
+        handle = emitAgentSpan({
+          adapter: "anthropic-agent-sdk",
+          agentName: options.defaultAgentName ?? "claude-agent-sdk",
+          model
+        });
+      }
+      try {
+        for await (const message of real) {
+          yield message;
+        }
+      } catch (err) {
+        handle?.end(err);
+        handle = null;
+        throw err;
+      }
+      handle?.end();
+      handle = null;
+    }
+    const tapOpts = {
+      toolInputMaxBytes: options.toolInputMaxBytes,
+      toolOutputMaxBytes: options.toolOutputMaxBytes
+    };
+    const instrumented = iterateInTrace(
+      options.defaultAgentName ?? "claude-agent-sdk",
+      () => instrumentTools(
+        instrumentLlmCalls(withAgentSpan(), { fallbackModel: model }),
+        tapOpts
+      )
+    );
+    return new Proxy(real, {
+      get(target, prop, receiver) {
+        if (prop === Symbol.asyncIterator) return () => instrumented;
+        if (prop === "next" || prop === "return" || prop === "throw") {
+          const fn = instrumented[prop];
+          return typeof fn === "function" ? fn.bind(instrumented) : fn;
+        }
+        const value = Reflect.get(target, prop, receiver);
+        return typeof value === "function" ? value.bind(target) : value;
+      }
+    });
+  };
+  Object.defineProperty(traced, WRAPPED, { value: true, enumerable: false });
+  return traced;
+}
+
 // src/anthropic-agent-sdk/index.ts
 var FULL_WRAP_SENTINEL = /* @__PURE__ */ Symbol.for("morse.anthropic-agent-sdk.full-wrapped");
 function wrapClaudeAgentSDKWithFullInstrumentation(client, options = {}) {
@@ -748,6 +802,6 @@ function wrapClaudeAgentSDKWithFullInstrumentation(client, options = {}) {
   return result;
 }
 
-export { installHookInstrumentation, instrumentClaudeAgentSDK, instrumentLlmCalls, instrumentTools, isClaudeAgentSDKWrapped, uninstallClaudeAgentSDK, wrapClaudeAgentSDK, wrapClaudeAgentSDKWithFullInstrumentation };
+export { installHookInstrumentation, instrumentClaudeAgentSDK, instrumentLlmCalls, instrumentTools, isClaudeAgentQueryWrapped, isClaudeAgentSDKWrapped, wrapClaudeAgentQuery, wrapClaudeAgentSDK, wrapClaudeAgentSDKWithFullInstrumentation };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map