@morsehq-dev/sdk 0.4.0-rc.1

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

@@ -0,0 +1,735 @@
+import { extractAnthropicSegments } from '../chunk-CKFOGDUF.js';
+import { summarizeToolInput, summarizeToolOutput } from '../chunk-ZKUGOWER.js';
+import { emitAgentSpan, emitHookSpan, emitLlmSpan, emitToolSpan } from '../chunk-HDAFUKQ3.js';
+import { absorbErrorsAsync, absorbErrorsSync } from '../chunk-RTL23YOQ.js';
+import { calculateCost } from '../chunk-XTKMUJWI.js';
+import { init_tracing, getActiveTraceState, runAsync, startSpan } from '../chunk-TQWI4UYO.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;
+  const originalQuery = client.query?.bind(client);
+  if (typeof originalQuery !== "function") return client;
+  const patchedQuery = buildPatchedQuery(
+    originalQuery,
+    options
+  );
+  const wrapper = new Proxy(client, {
+    get(target, prop, receiver) {
+      if (prop === WRAPPED_CLIENT) return true;
+      if (prop === "query") return patchedQuery;
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value === "function") {
+        return value.bind(target);
+      }
+      return value;
+    }
+  });
+  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;
+  },
+  { 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;
+}
+function isClient(x) {
+  if (!x || typeof x !== "object") return false;
+  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() {
+      const handle = emitAgentSpan({
+        adapter: "anthropic-agent-sdk",
+        agentName: defaultAgentName,
+        model
+      });
+      let iter;
+      try {
+        const ret = boundOriginal(prompt, callOptions);
+        iter = ret instanceof Promise ? await ret : ret;
+      } catch (err) {
+        handle?.end(err);
+        throw err;
+      }
+      try {
+        for await (const event of iter) {
+          yield event;
+        }
+      } catch (err) {
+        handle?.end(err);
+        throw err;
+      }
+      handle?.end();
+    }
+    if (getActiveTraceState() !== null) {
+      return iterateInTrace();
+    }
+    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: defaultAgentName }, async (runHandle) => {
+        try {
+          for await (const event of iterateInTrace()) {
+            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/_agent-sdk-common/context-propagation.ts
+init_tracing();
+var captureParentForFanOut = absorbErrorsSync(
+  () => {
+    const state = getActiveTraceState();
+    if (state === null) return null;
+    const top = state.spanStack[state.spanStack.length - 1];
+    if (!top) return null;
+    return {
+      parentSpanId: top.span_id,
+      traceId: state.traceId
+    };
+  },
+  { fingerprint: "agent-sdk-common.captureParentForFanOut" }
+);
+var emitWithPinnedParent = absorbErrorsSync(
+  (opts) => {
+    const state = getActiveTraceState();
+    if (state === null) return null;
+    const snap = opts.snapshot;
+    if (!snap || snap.traceId !== state.traceId) return null;
+    const handle = startSpan({
+      name: opts.name,
+      type: opts.type,
+      metadata: opts.metadata
+    });
+    if (handle === null) return null;
+    handle.span.parent_span_id = snap.parentSpanId;
+    return handle;
+  },
+  { fingerprint: "agent-sdk-common.emitWithPinnedParent" }
+);
+function findSpanById(state, spanId) {
+  for (let i = state.spanStack.length - 1; i >= 0; i--) {
+    const s = state.spanStack[i];
+    if (s && s.span_id === spanId) return s;
+  }
+  for (let i = state.completedSpans.length - 1; i >= 0; i--) {
+    const s = state.completedSpans[i];
+    if (s && s.span_id === spanId) return s;
+  }
+  return void 0;
+}
+var emitAsToolSibling = absorbErrorsSync(
+  (opts) => {
+    const state = getActiveTraceState();
+    if (state === null) return null;
+    const tool = findSpanById(state, opts.toolSpanId);
+    if (!tool) return null;
+    const handle = startSpan({
+      name: opts.name,
+      type: opts.type,
+      metadata: opts.metadata
+    });
+    if (handle === null) return null;
+    handle.span.parent_span_id = tool.parent_span_id;
+    return handle;
+  },
+  { fingerprint: "agent-sdk-common.emitAsToolSibling" }
+);
+absorbErrorsSync(
+  () => {
+    const state = getActiveTraceState();
+    if (state === null) return null;
+    return {
+      traceId: state.traceId,
+      spanStack: state.spanStack.slice(),
+      completedSpans: state.completedSpans.slice()
+    };
+  },
+  { fingerprint: "agent-sdk-common.inspectTraceState" }
+);
+
+// src/anthropic-agent-sdk/hook-instrumentation.ts
+function isHookEvent(payload) {
+  if (payload === null || typeof payload !== "object") return false;
+  const obj = payload;
+  if (typeof obj.name !== "string" || obj.name.length === 0) return false;
+  const kind = obj.kind;
+  if (kind !== "pre_tool" && kind !== "post_tool" && kind !== "on_error") return false;
+  return true;
+}
+var _handleHookEvent = (payload, options) => {
+  if (!isHookEvent(payload)) return;
+  const { name, kind } = payload;
+  const durationMs = typeof payload.duration_ms === "number" && Number.isFinite(payload.duration_ms) ? payload.duration_ms : void 0;
+  const toolUseId = typeof payload.tool_use_id === "string" && payload.tool_use_id.length > 0 ? payload.tool_use_id : void 0;
+  const lookup = options?.toolSpanLookup;
+  const toolSpanId = toolUseId !== void 0 && typeof lookup === "function" ? lookup(toolUseId) : null;
+  if (toolSpanId !== null && toolSpanId !== void 0 && toolSpanId.length > 0) {
+    const hookMeta = { name, kind };
+    if (durationMs !== void 0) hookMeta.duration_ms = durationMs;
+    const handle = emitAsToolSibling({
+      name: `anthropic-agent-sdk.hook.${kind}.${name}`,
+      type: "tool",
+      metadata: {
+        adapter: "anthropic-agent-sdk",
+        tool_kind: "hook",
+        hook: hookMeta
+      },
+      toolSpanId
+    });
+    if (handle !== null && handle !== void 0) {
+      handle.end();
+      return;
+    }
+  }
+  const fallback = emitHookSpan({
+    adapter: "anthropic-agent-sdk",
+    hookName: name,
+    hookKind: kind,
+    durationMs
+  });
+  if (fallback !== null && fallback !== void 0) {
+    fallback.end();
+  }
+};
+var handleHookEvent = absorbErrorsSync(_handleHookEvent, {
+  fingerprint: "morse.anthropic-agent-sdk.hook-instrumentation.handle"
+});
+function installHookInstrumentation(client, options) {
+  if (client === null || typeof client !== "object" || typeof client.on !== "function") {
+    return () => {
+    };
+  }
+  const listener = (payload) => {
+    handleHookEvent(payload, options);
+  };
+  try {
+    client.on("hook", listener);
+  } catch {
+    return () => {
+    };
+  }
+  return () => {
+    try {
+      if (typeof client.off === "function") {
+        client.off("hook", listener);
+      }
+    } catch {
+    }
+  };
+}
+
+// src/anthropic-agent-sdk/llm-instrumentation.ts
+function readInputTokens(usage) {
+  if (usage === void 0 || usage === null || typeof usage !== "object") return void 0;
+  const base = typeof usage.input_tokens === "number" && Number.isFinite(usage.input_tokens) ? usage.input_tokens : 0;
+  const cacheWrite = typeof usage.cache_creation_input_tokens === "number" && Number.isFinite(usage.cache_creation_input_tokens) ? usage.cache_creation_input_tokens : 0;
+  const cacheRead = typeof usage.cache_read_input_tokens === "number" && Number.isFinite(usage.cache_read_input_tokens) ? usage.cache_read_input_tokens : 0;
+  if (usage.input_tokens === void 0 && usage.cache_creation_input_tokens === void 0 && usage.cache_read_input_tokens === void 0) {
+    return void 0;
+  }
+  return base + cacheWrite + cacheRead;
+}
+function readOutputTokens(usage) {
+  if (usage === void 0 || usage === null || typeof usage !== "object") return void 0;
+  if (typeof usage.output_tokens === "number" && Number.isFinite(usage.output_tokens)) {
+    return usage.output_tokens;
+  }
+  return void 0;
+}
+function readCacheWriteTokens(usage) {
+  if (usage === void 0 || usage === null || typeof usage !== "object") return void 0;
+  if (typeof usage.cache_creation_input_tokens === "number" && Number.isFinite(usage.cache_creation_input_tokens) && usage.cache_creation_input_tokens > 0) {
+    return usage.cache_creation_input_tokens;
+  }
+  return void 0;
+}
+function readCachedInputTokens(usage) {
+  if (usage === void 0 || usage === null || typeof usage !== "object") return void 0;
+  if (typeof usage.cache_read_input_tokens === "number" && Number.isFinite(usage.cache_read_input_tokens) && usage.cache_read_input_tokens > 0) {
+    return usage.cache_read_input_tokens;
+  }
+  return void 0;
+}
+function applyCost(handle, model, inputTokens, outputTokens, cacheWriteTokens, cachedInputTokens) {
+  if (handle.span.cost_usd !== void 0) return;
+  if (inputTokens === void 0 && outputTokens === void 0) return;
+  const cost = calculateCost({
+    inputTokens: inputTokens ?? 0,
+    outputTokens: outputTokens ?? 0,
+    model,
+    cachedInputTokens: cachedInputTokens ?? 0,
+    cacheWriteTokens: cacheWriteTokens ?? 0
+  });
+  if (cost !== void 0) handle.span.cost_usd = cost;
+}
+function safe(fn) {
+  try {
+    fn();
+  } catch {
+  }
+}
+async function* instrumentLlmCalls(events, options) {
+  let openSpan = null;
+  const fallbackModel = options?.fallbackModel;
+  const requestParams = options?.requestParams;
+  try {
+    for await (const event of events) {
+      const eventType = typeof event?.type === "string" ? event.type : "";
+      if (eventType === "assistant" && event.message) {
+        safe(() => {
+          if (openSpan !== null) {
+            openSpan.end();
+            openSpan = null;
+          }
+          const reportedModel = typeof event.message?.model === "string" && event.message.model.length > 0 ? event.message.model : void 0;
+          const model = reportedModel ?? fallbackModel;
+          if (!model) return;
+          const handle = emitLlmSpan({ adapter: "anthropic-agent-sdk", model });
+          if (!handle) return;
+          const usage = event.message?.usage;
+          const inputTokens = readInputTokens(usage);
+          const outputTokens = readOutputTokens(usage);
+          const cacheWriteTokens = readCacheWriteTokens(usage);
+          const cachedInputTokens = readCachedInputTokens(usage);
+          if (inputTokens !== void 0) handle.span.input_tokens = inputTokens;
+          if (outputTokens !== void 0) handle.span.output_tokens = outputTokens;
+          if (cacheWriteTokens !== void 0) handle.span.cache_write_tokens = cacheWriteTokens;
+          if (cachedInputTokens !== void 0) handle.span.cached_input_tokens = cachedInputTokens;
+          if (inputTokens !== void 0 && outputTokens !== void 0) {
+            handle.span.total_tokens = inputTokens + outputTokens;
+          }
+          applyCost(handle, model, inputTokens, outputTokens, cacheWriteTokens, cachedInputTokens);
+          if (requestParams !== void 0) {
+            try {
+              const segments = extractAnthropicSegments(
+                requestParams,
+                event.message
+              );
+              if (Array.isArray(segments) && segments.length > 0) {
+                handle.span.context_segments = segments;
+              }
+            } catch {
+            }
+          }
+          handle.end();
+        });
+      } else if (eventType === "message_start") {
+        safe(() => {
+          if (openSpan !== null) {
+            openSpan.end(new Error("morse: message_start without preceding message_stop"));
+            openSpan = null;
+          }
+          const reportedModel = typeof event.message?.model === "string" && event.message.model.length > 0 ? event.message.model : void 0;
+          const model = reportedModel ?? fallbackModel;
+          if (model === void 0 || model.length === 0) {
+            return;
+          }
+          openSpan = emitLlmSpan({
+            adapter: "anthropic-agent-sdk",
+            model
+          });
+        });
+      } else if (eventType === "message_stop") {
+        if (openSpan !== null) {
+          const handle = openSpan;
+          openSpan = null;
+          safe(() => {
+            const usage = event.message?.usage;
+            const inputTokens = readInputTokens(usage);
+            const outputTokens = readOutputTokens(usage);
+            const cacheWriteTokens = readCacheWriteTokens(usage);
+            const cachedInputTokens = readCachedInputTokens(usage);
+            if (inputTokens !== void 0) {
+              handle.span.input_tokens = inputTokens;
+            }
+            if (outputTokens !== void 0) {
+              handle.span.output_tokens = outputTokens;
+            }
+            if (cacheWriteTokens !== void 0) {
+              handle.span.cache_write_tokens = cacheWriteTokens;
+            }
+            if (cachedInputTokens !== void 0) {
+              handle.span.cached_input_tokens = cachedInputTokens;
+            }
+            if (inputTokens !== void 0 && outputTokens !== void 0) {
+              handle.span.total_tokens = inputTokens + outputTokens;
+            }
+            if (handle.span.model) {
+              applyCost(
+                handle,
+                handle.span.model,
+                inputTokens,
+                outputTokens,
+                cacheWriteTokens,
+                cachedInputTokens
+              );
+            }
+            if (requestParams !== void 0) {
+              try {
+                const segments = extractAnthropicSegments(
+                  requestParams,
+                  event.message
+                );
+                if (Array.isArray(segments) && segments.length > 0) {
+                  handle.span.context_segments = segments;
+                }
+              } catch {
+              }
+            }
+            handle.end();
+          });
+        }
+      }
+      yield event;
+    }
+  } finally {
+    if (openSpan !== null) {
+      const handle = openSpan;
+      openSpan = null;
+      safe(() => {
+        handle.end(new Error("morse: iterator ended before message_stop"));
+      });
+    }
+  }
+}
+
+// src/anthropic-agent-sdk/tool-and-subagent.ts
+var ADAPTER = "anthropic-agent-sdk";
+var TASK_TOOL_NAME = "Task";
+function safeCloseFailed(handle, message) {
+  try {
+    handle.end(new Error(message));
+  } catch {
+  }
+}
+function safeCloseOk(handle) {
+  try {
+    handle.end();
+  } catch {
+  }
+}
+async function* instrumentTools(events, options) {
+  const open = /* @__PURE__ */ new Map();
+  let fanOutSnapshot = null;
+  let openSubagentCount = 0;
+  const inputOpts = options?.toolInputMaxBytes ? { maxBytes: options.toolInputMaxBytes } : void 0;
+  const outputOpts = options?.toolOutputMaxBytes ? { maxBytes: options.toolOutputMaxBytes } : void 0;
+  const extractContentBlocks = (event) => {
+    const msg = event.message;
+    const content = msg?.content;
+    return Array.isArray(content) ? content : [];
+  };
+  const handleToolUse = (event) => {
+    const toolUseId = typeof event.tool_use_id === "string" ? event.tool_use_id : null;
+    const name = typeof event.name === "string" ? event.name : null;
+    if (toolUseId === null || name === null) return;
+    if (open.has(toolUseId)) return;
+    if (name === TASK_TOOL_NAME) {
+      if (fanOutSnapshot === null) {
+        fanOutSnapshot = captureParentForFanOut();
+      }
+      const input = event.input && typeof event.input === "object" ? event.input : {};
+      const description = typeof input.description === "string" && input.description.length > 0 ? input.description : `subagent_${toolUseId}`;
+      const taskPrompt = typeof input.prompt === "string" ? input.prompt : void 0;
+      const metadata = {
+        adapter: ADAPTER,
+        spawn_kind: "subagent",
+        parent_agent_name: "anthropic-agent-sdk",
+        subagent_name: description,
+        tool_use_id: toolUseId
+      };
+      if (taskPrompt !== void 0) {
+        metadata.task_description = summarizeToolInput(taskPrompt, inputOpts);
+      }
+      let handle2 = null;
+      try {
+        if (fanOutSnapshot !== null) {
+          handle2 = emitWithPinnedParent({
+            name: `${ADAPTER}.subagent.spawn`,
+            type: "agent",
+            metadata,
+            snapshot: fanOutSnapshot
+          });
+        }
+      } catch {
+        handle2 = null;
+      }
+      if (handle2 === null) return;
+      open.set(toolUseId, { handle: handle2, isSubagent: true });
+      openSubagentCount++;
+      return;
+    }
+    let handle = null;
+    try {
+      handle = emitToolSpan({
+        adapter: ADAPTER,
+        toolName: name,
+        inputSummary: summarizeToolInput(event.input, inputOpts),
+        attributes: { tool_use_id: toolUseId }
+      });
+    } catch {
+      handle = null;
+    }
+    if (handle === null) return;
+    open.set(toolUseId, { handle, isSubagent: false });
+  };
+  const handleToolResult = (event) => {
+    const toolUseId = typeof event.tool_use_id === "string" ? event.tool_use_id : null;
+    if (toolUseId === null) return;
+    const entry = open.get(toolUseId);
+    if (!entry) return;
+    open.delete(toolUseId);
+    const isError = event.is_error === true;
+    try {
+      const outputSummary = summarizeToolOutput(event.content, outputOpts);
+      entry.handle.span.metadata = {
+        ...entry.handle.span.metadata ?? {},
+        tool_output_summary: outputSummary
+      };
+      if (entry.isSubagent) {
+        entry.handle.span.metadata.success = !isError;
+      } else {
+        entry.handle.span.metadata.success = !isError;
+      }
+    } catch {
+    }
+    if (isError) {
+      safeCloseFailed(entry.handle, "tool error");
+    } else {
+      safeCloseOk(entry.handle);
+    }
+    if (entry.isSubagent) {
+      openSubagentCount = Math.max(0, openSubagentCount - 1);
+      if (openSubagentCount === 0) {
+        fanOutSnapshot = null;
+      }
+    }
+  };
+  try {
+    for await (const event of events) {
+      try {
+        const type = typeof event?.type === "string" ? event.type : null;
+        if (type === "tool_use") {
+          handleToolUse(event);
+        } else if (type === "tool_result") {
+          handleToolResult(event);
+        } else if (type === "assistant" || type === "user") {
+          const blocks = extractContentBlocks(event);
+          for (const block of blocks) {
+            if (!block || typeof block !== "object") continue;
+            const bt = typeof block.type === "string" ? block.type : null;
+            if (bt === "tool_use" && type === "assistant") {
+              handleToolUse({
+                type: "tool_use",
+                tool_use_id: block.id,
+                name: block.name,
+                input: block.input
+              });
+            } else if (bt === "tool_result" && type === "user") {
+              handleToolResult({
+                type: "tool_result",
+                tool_use_id: block.tool_use_id,
+                content: block.content,
+                is_error: block.is_error
+              });
+            }
+          }
+        }
+      } catch {
+      }
+      yield event;
+    }
+  } finally {
+    for (const [, entry] of open) {
+      safeCloseFailed(entry.handle, "tool_use without matching tool_result");
+      if (entry.isSubagent) {
+        openSubagentCount = Math.max(0, openSubagentCount - 1);
+      }
+    }
+    open.clear();
+    fanOutSnapshot = null;
+  }
+}
+
+// src/anthropic-agent-sdk/index.ts
+var FULL_WRAP_SENTINEL = /* @__PURE__ */ Symbol.for("morse.anthropic-agent-sdk.full-wrapped");
+function wrapClaudeAgentSDKWithFullInstrumentation(client, options = {}) {
+  const existing = client[FULL_WRAP_SENTINEL];
+  if (existing) {
+    return existing;
+  }
+  const wrapOpts = {
+    defaultAgentName: options.defaultAgentName,
+    defaultModel: options.defaultModel
+  };
+  const llmOpts = {
+    fallbackModel: options.defaultModel
+  };
+  const toolOpts = {
+    toolInputMaxBytes: options.toolInputMaxBytes,
+    toolOutputMaxBytes: options.toolOutputMaxBytes
+  };
+  const hookOpts = {
+    toolSpanLookup: options.toolSpanLookup
+  };
+  const outerWrapped = wrapClaudeAgentSDK(client, wrapOpts);
+  const composed = new Proxy(outerWrapped, {
+    get(target, prop, receiver) {
+      if (prop === "query") {
+        const outerQuery = target.query.bind(target);
+        return function composedQuery(prompt, callOptions) {
+          async function* compose() {
+            const ret = outerQuery(prompt, callOptions);
+            const iter = ret instanceof Promise ? await ret : ret;
+            const llmTapped = instrumentLlmCalls(iter, llmOpts);
+            const toolTapped = instrumentTools(llmTapped, toolOpts);
+            for await (const event of toolTapped) {
+              yield event;
+            }
+          }
+          return compose();
+        };
+      }
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value === "function") {
+        return value.bind(target);
+      }
+      return value;
+    }
+  });
+  const unsubscribeHooks = installHookInstrumentation(client, hookOpts);
+  let disposed = false;
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    try {
+      unsubscribeHooks();
+    } catch {
+    }
+  };
+  const result = {
+    client: composed,
+    dispose
+  };
+  try {
+    client[FULL_WRAP_SENTINEL] = result;
+  } catch {
+  }
+  return result;
+}
+
+export { installHookInstrumentation, instrumentClaudeAgentSDK, instrumentLlmCalls, instrumentTools, isClaudeAgentSDKWrapped, uninstallClaudeAgentSDK, wrapClaudeAgentSDK, wrapClaudeAgentSDKWithFullInstrumentation };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map