@morsehq-dev/sdk 0.4.0-rc.1

package/dist/browser/chunk-A24L5N5N.js

@@ -0,0 +1,596 @@
+import { calculateCost } from './chunk-4FALQMOZ.js';
+import { absorbErrorsAsync, absorbErrorsSync } from './chunk-NQG2IAQS.js';
+import { init_spans, init_tracing, getActiveTraceState, runAsync, startSpan, nowIso, generateSpanId } from './chunk-5J2QBK75.js';
+
+// src/anthropic/index.ts
+init_spans();
+init_tracing();
+var WRAPPED_CLIENT = /* @__PURE__ */ Symbol.for("morse.anthropic.wrapped");
+var INSTALL_SENTINEL = /* @__PURE__ */ Symbol.for("morse.anthropic.installed");
+var ORIGINALS_SENTINEL = /* @__PURE__ */ Symbol.for("morse.anthropic.originals");
+var globalInstallActive = false;
+function wrapAnthropic(client, options = {}) {
+  if (!client || typeof client !== "object") return client;
+  if (client[WRAPPED_CLIENT]) return client;
+  if (globalInstallActive) return client;
+  const originalCreate = client.messages?.create?.bind(client.messages);
+  if (typeof originalCreate !== "function") return client;
+  const patchedCreate = buildPatchedCreate(originalCreate, options);
+  const patchedMessages = new Proxy(client.messages, {
+    get(target, prop, receiver) {
+      if (prop === "create") return patchedCreate;
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value === "function") return value.bind(target);
+      return value;
+    }
+  });
+  const wrapper = new Proxy(client, {
+    get(target, prop, receiver) {
+      if (prop === WRAPPED_CLIENT) return true;
+      if (prop === "messages") return patchedMessages;
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value === "function") return value.bind(target);
+      return value;
+    }
+  });
+  return wrapper;
+}
+var instrumentAnthropic = absorbErrorsAsync(
+  async (clientOrOptions, maybeOptions) => {
+    if (clientOrOptions && isClient(clientOrOptions)) {
+      const opts2 = maybeOptions ?? {};
+      return wrapAnthropic(clientOrOptions, opts2);
+    }
+    const opts = clientOrOptions ?? {};
+    const mod = await loadAnthropicModule(opts.anthropicModule);
+    if (!mod) return false;
+    const installed = mod[INSTALL_SENTINEL] === true;
+    if (installed) {
+      globalInstallActive = true;
+      return true;
+    }
+    const carrier = findMessagesPrototypeCarrier(mod);
+    if (!carrier) return false;
+    const originalCreate = carrier.prototype.create;
+    if (typeof originalCreate !== "function") return false;
+    const patchedCreate = buildPatchedCreate(function(params, callOptions) {
+      return originalCreate.call(
+        this,
+        params,
+        callOptions
+      );
+    }, opts);
+    carrier.prototype.create = patchedCreate;
+    mod[ORIGINALS_SENTINEL] = {
+      protoCreate: originalCreate,
+      protoCarrier: carrier
+    };
+    mod[INSTALL_SENTINEL] = true;
+    globalInstallActive = true;
+    return true;
+  },
+  { fingerprint: "morse.adapters.anthropic.install" }
+);
+var uninstallAnthropic = absorbErrorsSync(
+  (anthropicModule) => {
+    if (!anthropicModule || typeof anthropicModule !== "object") return;
+    const mod = anthropicModule;
+    if (!mod[INSTALL_SENTINEL]) return;
+    const originals = mod[ORIGINALS_SENTINEL];
+    if (originals?.protoCarrier && originals.protoCreate !== void 0) {
+      originals.protoCarrier.prototype.create = originals.protoCreate;
+    }
+    mod[ORIGINALS_SENTINEL] = void 0;
+    mod[INSTALL_SENTINEL] = false;
+    globalInstallActive = false;
+  },
+  { fingerprint: "morse.adapters.anthropic.uninstall" }
+);
+function _resetAnthropicInstallStateForTesting() {
+  globalInstallActive = false;
+}
+function isAnthropicWrapped(client) {
+  if (!client || typeof client !== "object") return false;
+  return client[WRAPPED_CLIENT] === true;
+}
+function isClient(x) {
+  if (!x || typeof x !== "object") return false;
+  const messages = x.messages;
+  return !!messages && typeof messages.create === "function";
+}
+async function loadAnthropicModule(explicit) {
+  if (explicit && typeof explicit === "object") return explicit;
+  try {
+    return await Function("m", "return import(m)")("@anthropic-ai/sdk");
+  } catch {
+    return null;
+  }
+}
+function findMessagesPrototypeCarrier(mod) {
+  if (!mod || typeof mod !== "object") return null;
+  const m = mod;
+  const Default = m.default ?? m.Anthropic ?? m;
+  const candidates = [
+    Default?.Messages,
+    m.Messages,
+    Default?.resources?.Messages
+  ];
+  for (const c of candidates) {
+    if (c && typeof c === "function" && c.prototype && typeof c.prototype.create === "function") {
+      return c;
+    }
+  }
+  return null;
+}
+function buildPatchedCreate(original, options) {
+  const agentName = options.defaultAgentName ?? "anthropic.messages.create";
+  const summarizeMode = options.summarize === true;
+  return async function patchedCreate(params, callOptions) {
+    const inTrace = getActiveTraceState() !== null;
+    const work = async () => {
+      const handle = startSpan({
+        name: "anthropic.messages.create",
+        type: "llm",
+        metadata: { model: params?.model, max_tokens: params?.max_tokens }
+      });
+      let response;
+      try {
+        response = await original.call(this, params, callOptions);
+      } catch (err) {
+        handle?.end(err);
+        throw err;
+      }
+      try {
+        if (handle) {
+          const segments = safeExtractSegments(params, response);
+          const usage = response?.usage ?? {};
+          const inputTokens = (usage.input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0);
+          const outputTokens = usage.output_tokens ?? 0;
+          handle.span.model = response?.model ?? params?.model;
+          if (inputTokens > 0) handle.span.input_tokens = inputTokens;
+          if (outputTokens > 0) handle.span.output_tokens = outputTokens;
+          const cacheWrite = usage.cache_creation_input_tokens ?? 0;
+          const cacheRead = usage.cache_read_input_tokens ?? 0;
+          if (cacheWrite > 0) handle.span.cache_write_tokens = cacheWrite;
+          if (cacheRead > 0) handle.span.cached_input_tokens = cacheRead;
+          if (inputTokens > 0 || outputTokens > 0) {
+            handle.span.total_tokens = inputTokens + outputTokens;
+          }
+          if (handle.span.cost_usd === void 0 && handle.span.model && (inputTokens > 0 || outputTokens > 0)) {
+            const cost = calculateCost({
+              inputTokens,
+              outputTokens,
+              model: handle.span.model,
+              cachedInputTokens: cacheRead,
+              cacheWriteTokens: cacheWrite
+            });
+            if (cost !== void 0) handle.span.cost_usd = cost;
+          }
+          handle.span.context_segments = segments;
+        }
+      } catch {
+      }
+      handle?.end();
+      if (summarizeMode && handle) {
+        try {
+          emitSummarizeMemorySpan(handle.span, response);
+        } catch {
+        }
+      }
+      return response;
+    };
+    if (inTrace) {
+      return work();
+    }
+    let result;
+    let thrown;
+    await runAsync({ agentName }, async (runHandle) => {
+      runHandle.setOutcome(true);
+      try {
+        result = await work();
+      } catch (err) {
+        thrown = err;
+        throw err;
+      }
+      return null;
+    });
+    if (thrown !== void 0) throw thrown;
+    return result;
+  };
+}
+var MAX_SEGMENT_CONTENT_BYTES = 4096;
+function extractAnthropicSegments(params, response) {
+  const segments = [];
+  let position = 0;
+  if (Array.isArray(params.tools) && params.tools.length > 0) {
+    const content = canonicalJsonStringify(params.tools);
+    segments.push(makeSegment(position++, "tool_descriptions", content));
+  }
+  let systemHadEphemeral = false;
+  if (params.system !== void 0 && params.system !== null) {
+    let text = "";
+    if (typeof params.system === "string") {
+      text = params.system;
+    } else if (Array.isArray(params.system)) {
+      const parts = [];
+      for (const block of params.system) {
+        if (block && typeof block === "object" && block.type === "text") {
+          parts.push(typeof block.text === "string" ? block.text : "");
+          if (block.cache_control && typeof block.cache_control === "object" && block.cache_control.type === "ephemeral") {
+            systemHadEphemeral = true;
+          }
+        }
+      }
+      text = parts.join("\n");
+    }
+    const seg = makeSegment(position++, "system_prompt", text);
+    if (systemHadEphemeral) seg.cache_state = "cache_write";
+    segments.push(seg);
+  }
+  const messages = Array.isArray(params.messages) ? params.messages : [];
+  let lastUserIdx = -1;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i]?.role === "user") {
+      lastUserIdx = i;
+      break;
+    }
+  }
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (!msg) continue;
+    const blocks = normalizeContent(msg.content);
+    const toolResults = blocks.filter(
+      (b) => b.type === "tool_result"
+    );
+    const nonToolResults = blocks.filter((b) => b.type !== "tool_result");
+    if (nonToolResults.length > 0) {
+      const text = renderBlocksAsText(nonToolResults, msg.role);
+      let source;
+      if (msg.role === "user" && i === lastUserIdx) {
+        source = "current_input";
+      } else {
+        source = "chat_history";
+      }
+      segments.push(makeSegment(position++, source, text));
+    } else if (typeof msg.content === "string" && msg.role === "user" && i === lastUserIdx && msg.content.length > 0) {
+      segments.push(makeSegment(position++, "current_input", msg.content));
+    }
+    for (const tr of toolResults) {
+      const text = renderToolResult(tr);
+      const seg = makeSegment(position++, "tool_observation", text);
+      seg.attrs = { tool_use_id: tr.tool_use_id };
+      if (tr.is_error) {
+        seg.attrs.is_error = true;
+      }
+      segments.push(seg);
+    }
+  }
+  const cacheRead = response?.usage?.cache_read_input_tokens ?? 0;
+  if (cacheRead > 0) {
+    for (const seg of segments) {
+      if (seg.source === "system_prompt" || seg.source === "tool_descriptions") {
+        seg.cache_state = "cache_hit";
+      }
+    }
+  }
+  return segments;
+}
+function safeExtractSegments(params, response) {
+  try {
+    return extractAnthropicSegments(params, response);
+  } catch {
+    return [];
+  }
+}
+function emitSummarizeMemorySpan(llmSpan, response) {
+  const state = getActiveTraceState();
+  if (state === null) return;
+  const summaryText = extractFirstTextBlock(response);
+  const summaryHash = sha256Hex(summaryText);
+  const summaryTokens = response?.usage?.output_tokens ?? 0;
+  const startedAt = llmSpan.ended_at ?? llmSpan.started_at ?? nowIso();
+  const memorySpan = {
+    trace_id: state.traceId,
+    span_id: generateSpanId(),
+    type: "memory",
+    name: "anthropic.summarize",
+    parent_span_id: llmSpan.span_id,
+    started_at: startedAt,
+    ended_at: startedAt,
+    duration_ms: 0,
+    status: "completed",
+    metadata: {
+      memory_op_type: "consolidate",
+      summary_token_count: summaryTokens,
+      summary_content_hash: summaryHash
+    }
+  };
+  state.completedSpans.push(memorySpan);
+}
+function extractFirstTextBlock(response) {
+  try {
+    const content = response?.content;
+    if (!Array.isArray(content)) return "";
+    for (const block of content) {
+      if (block && typeof block === "object" && block.type === "text") {
+        const t = block.text;
+        if (typeof t === "string" && t.length > 0) return t;
+      }
+    }
+    return "";
+  } catch {
+    return "";
+  }
+}
+function makeSegment(position, source, rawContent) {
+  const fullHash = sha256Hex(rawContent);
+  const truncated = truncateToBytes(rawContent, MAX_SEGMENT_CONTENT_BYTES);
+  const seg = {
+    position,
+    source,
+    content_hash: fullHash,
+    content: truncated.text,
+    cache_state: "cold"
+  };
+  if (truncated.truncated) seg.content_truncated = true;
+  return seg;
+}
+function normalizeContent(content) {
+  if (typeof content === "string") {
+    return [{ type: "text", text: content }];
+  }
+  if (Array.isArray(content)) {
+    return content.filter((b) => !!b && typeof b === "object");
+  }
+  return [];
+}
+function renderBlocksAsText(blocks, role) {
+  const out = [];
+  for (const b of blocks) {
+    if (!b || typeof b !== "object") continue;
+    if (b.type === "text") {
+      const text = b.text;
+      if (typeof text === "string") out.push(text);
+    } else if (b.type === "tool_use") {
+      const tu = b;
+      out.push(`[tool_use:${tu.name}:${tu.id}] ${canonicalJsonStringify(tu.input ?? null)}`);
+    } else {
+      out.push(canonicalJsonStringify(b));
+    }
+  }
+  if (role === "assistant") {
+    return out.length === 1 && out[0] !== void 0 ? out[0] : out.join("\n");
+  }
+  return out.length === 1 && out[0] !== void 0 ? out[0] : out.join("\n");
+}
+function renderToolResult(tr) {
+  if (typeof tr.content === "string") return tr.content;
+  if (Array.isArray(tr.content)) {
+    const parts = [];
+    for (const b of tr.content) {
+      if (b && typeof b === "object") {
+        if (b.type === "text" && typeof b.text === "string") parts.push(b.text);
+        else parts.push(canonicalJsonStringify(b));
+      }
+    }
+    return parts.join("\n");
+  }
+  return "";
+}
+function canonicalJsonStringify(value) {
+  return JSON.stringify(value, function replacer(_key, val) {
+    if (val && typeof val === "object" && !Array.isArray(val)) {
+      const obj = val;
+      const sorted = {};
+      for (const k of Object.keys(obj).sort()) {
+        sorted[k] = obj[k];
+      }
+      return sorted;
+    }
+    return val;
+  });
+}
+function sha256Hex(text) {
+  try {
+    if (typeof process !== "undefined" && process.versions?.node) {
+      const dynamicRequire = Function("m", "return require(m)");
+      const cryptoMod = dynamicRequire("node:crypto");
+      if (cryptoMod?.createHash) {
+        return cryptoMod.createHash("sha256").update(text).digest("hex");
+      }
+    }
+  } catch {
+  }
+  return purejsSha256(text);
+}
+function truncateToBytes(text, maxBytes) {
+  if (text.length <= maxBytes / 4) return { text, truncated: false };
+  const bytes = utf8Encode(text);
+  if (bytes.length <= maxBytes) return { text, truncated: false };
+  let cut = maxBytes;
+  while (cut > 0 && (bytes[cut] & 192) === 128) {
+    cut--;
+  }
+  return { text: utf8Decode(bytes.subarray(0, cut)), truncated: true };
+}
+function utf8Encode(text) {
+  if (typeof TextEncoder !== "undefined") {
+    return new TextEncoder().encode(text);
+  }
+  const out = [];
+  for (let i = 0; i < text.length; i++) {
+    const code = text.charCodeAt(i);
+    if (code < 128) {
+      out.push(code);
+    } else if (code < 2048) {
+      out.push(192 | code >> 6, 128 | code & 63);
+    } else {
+      out.push(224 | code >> 12, 128 | code >> 6 & 63, 128 | code & 63);
+    }
+  }
+  return new Uint8Array(out);
+}
+function utf8Decode(bytes) {
+  if (typeof TextDecoder !== "undefined") {
+    return new TextDecoder("utf-8").decode(bytes);
+  }
+  let out = "";
+  for (let i = 0; i < bytes.length; ) {
+    const b = bytes[i];
+    if (b < 128) {
+      out += String.fromCharCode(b);
+      i++;
+    } else if (b < 224) {
+      out += String.fromCharCode((b & 31) << 6 | bytes[i + 1] & 63);
+      i += 2;
+    } else {
+      out += String.fromCharCode(
+        (b & 15) << 12 | (bytes[i + 1] & 63) << 6 | bytes[i + 2] & 63
+      );
+      i += 3;
+    }
+  }
+  return out;
+}
+function purejsSha256(text) {
+  const K = [
+    1116352408,
+    1899447441,
+    3049323471,
+    3921009573,
+    961987163,
+    1508970993,
+    2453635748,
+    2870763221,
+    3624381080,
+    310598401,
+    607225278,
+    1426881987,
+    1925078388,
+    2162078206,
+    2614888103,
+    3248222580,
+    3835390401,
+    4022224774,
+    264347078,
+    604807628,
+    770255983,
+    1249150122,
+    1555081692,
+    1996064986,
+    2554220882,
+    2821834349,
+    2952996808,
+    3210313671,
+    3336571891,
+    3584528711,
+    113926993,
+    338241895,
+    666307205,
+    773529912,
+    1294757372,
+    1396182291,
+    1695183700,
+    1986661051,
+    2177026350,
+    2456956037,
+    2730485921,
+    2820302411,
+    3259730800,
+    3345764771,
+    3516065817,
+    3600352804,
+    4094571909,
+    275423344,
+    430227734,
+    506948616,
+    659060556,
+    883997877,
+    958139571,
+    1322822218,
+    1537002063,
+    1747873779,
+    1955562222,
+    2024104815,
+    2227730452,
+    2361852424,
+    2428436474,
+    2756734187,
+    3204031479,
+    3329325298
+  ];
+  const H = [
+    1779033703,
+    3144134277,
+    1013904242,
+    2773480762,
+    1359893119,
+    2600822924,
+    528734635,
+    1541459225
+  ];
+  const msg = utf8Encode(text);
+  const msgLen = msg.length;
+  const bitLen = msgLen * 8;
+  const padded = new Uint8Array(msgLen + 9 + 63 >> 6 << 6);
+  padded.set(msg);
+  padded[msgLen] = 128;
+  const lo = (bitLen & 4294967295) >>> 0;
+  const hi = Math.floor(bitLen / 4294967296) >>> 0;
+  padded[padded.length - 8] = hi >>> 24 & 255;
+  padded[padded.length - 7] = hi >>> 16 & 255;
+  padded[padded.length - 6] = hi >>> 8 & 255;
+  padded[padded.length - 5] = hi & 255;
+  padded[padded.length - 4] = lo >>> 24 & 255;
+  padded[padded.length - 3] = lo >>> 16 & 255;
+  padded[padded.length - 2] = lo >>> 8 & 255;
+  padded[padded.length - 1] = lo & 255;
+  const W = new Uint32Array(64);
+  for (let chunk = 0; chunk < padded.length; chunk += 64) {
+    for (let i = 0; i < 16; i++) {
+      W[i] = (padded[chunk + i * 4] << 24 | padded[chunk + i * 4 + 1] << 16 | padded[chunk + i * 4 + 2] << 8 | padded[chunk + i * 4 + 3]) >>> 0;
+    }
+    for (let i = 16; i < 64; i++) {
+      const s0 = rotr(W[i - 15], 7) ^ rotr(W[i - 15], 18) ^ W[i - 15] >>> 3;
+      const s1 = rotr(W[i - 2], 17) ^ rotr(W[i - 2], 19) ^ W[i - 2] >>> 10;
+      W[i] = W[i - 16] + s0 + W[i - 7] + s1 >>> 0;
+    }
+    let [a, b, c, d, e, f, g, h] = H;
+    for (let i = 0; i < 64; i++) {
+      const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const ch = e & f ^ ~e & g;
+      const temp1 = h + S1 + ch + K[i] + W[i] >>> 0;
+      const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const maj = a & b ^ a & c ^ b & c;
+      const temp2 = S0 + maj >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + temp1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 >>> 0;
+    }
+    H[0] = H[0] + a >>> 0;
+    H[1] = H[1] + b >>> 0;
+    H[2] = H[2] + c >>> 0;
+    H[3] = H[3] + d >>> 0;
+    H[4] = H[4] + e >>> 0;
+    H[5] = H[5] + f >>> 0;
+    H[6] = H[6] + g >>> 0;
+    H[7] = H[7] + h >>> 0;
+  }
+  let hex = "";
+  for (const v of H) {
+    hex += v.toString(16).padStart(8, "0");
+  }
+  return hex;
+}
+function rotr(x, n) {
+  return (x >>> n | x << 32 - n) >>> 0;
+}
+
+export { MAX_SEGMENT_CONTENT_BYTES, _resetAnthropicInstallStateForTesting, extractAnthropicSegments, instrumentAnthropic, isAnthropicWrapped, uninstallAnthropic, wrapAnthropic };
+//# sourceMappingURL=chunk-A24L5N5N.js.map
+//# sourceMappingURL=chunk-A24L5N5N.js.map