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

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

@@ -1,17 +1,15 @@
-import { extractAnthropicSegments } from '../chunk-N4Q2WMOE.js';
-import '../chunk-WUQXNRD3.js';
-import { summarizeToolInput, summarizeToolOutput } from '../chunk-LGG5PL5U.js';
-import { emitAgentSpan, emitHookSpan, emitLlmSpan, emitToolSpan } from '../chunk-MOBYR3AP.js';
-import { absorbErrorsAsync, absorbErrorsSync } from '../chunk-MI4OUWUZ.js';
+import { extractAnthropicSegments } from '../chunk-MIB3EOC4.js';
+import '../chunk-GLL57K7P.js';
+import { summarizeToolInput, summarizeToolOutput } from '../chunk-64YI3IZS.js';
+import { emitHookSpan, emitAgentSpan, emitLlmSpan, emitToolSpan } from '../chunk-UL5TNXQL.js';
+import { absorbErrorsAsync, absorbErrorsSync } from '../chunk-EH326H6U.js';
 import { calculateCost } from '../chunk-4FALQMOZ.js';
 import '../chunk-MLDVXMQD.js';
-import { init_tracing, getActiveTraceState, runAsync, startSpan, init_diagnostics, report } from '../chunk-Y3BOPSM3.js';
+import { init_tracing, getActiveTraceState, startSpan, init_diagnostics, runAsync, report } from '../chunk-V7AUPQIJ.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