@morsehq-dev/sdk 0.4.0-rc.1

package/dist/openai/index.d.cts

@@ -0,0 +1,136 @@
+/**
+ * `@morsehq-dev/sdk/openai` — plain OpenAI SDK instrumentation.
+ *
+ * Wraps a raw `openai` npm package client (`new OpenAI()` /
+ * `new AzureOpenAI()` / any structurally-compatible client) so every
+ * `chat.completions.create` call emits an `llm` span carrying model,
+ * token counts, `cost_usd`, and pre-segmented `context_segments`.
+ *
+ * TS port of `apps/sdk/python/src/morse_ai/adapters/openai.py`'s `wrap()`.
+ * This module intentionally covers only the `wrap(client)` recommended
+ * path (mirrors the Python module's three-layer doc comment, layer 2) —
+ * no module-level monkey-patch / `install()` layer, since plain `openai`
+ * is not one of the auto-detect targets on either SDK (see
+ * `_internal/auto-detect.ts` and Python's `_internal/auto_detect.py`
+ * `_adapter_targets()`, which both omit bare `openai`).
+ *
+ * Distinct from `@morsehq-dev/sdk/openai-agents`, which instruments the
+ * `@openai/agents` Agents SDK (a different package with its own Runner /
+ * Agent abstractions). This module is for customers calling
+ * `openai.chat.completions.create` directly.
+ *
+ * Context segments are extracted via the shared
+ * `_agent-sdk-common/context-decomposer.ts` (`decomposeOpenAiMessages`,
+ * MHQ-750) — the request's `messages`/`tools` are already in the native
+ * OpenAI wire format the decomposer expects, so no translation layer is
+ * needed.
+ *
+ * Idempotent — wrapping an already-wrapped client instance is a no-op
+ * that returns the same wrapper. Recording is best-effort: any failure
+ * while building/emitting the span is swallowed so it can never break the
+ * customer's OpenAI call. The customer's own API error (thrown by the
+ * underlying `create()` call) always propagates unchanged — the span is
+ * marked `status: "failed"` first, then the error is re-raised.
+ *
+ * Mirrors `apps/sdk/typescript/src/anthropic/index.ts` in shape.
+ */
+/** Subset of the `openai` package's chat message shape we read from. */
+interface OpenAiChatMessageParam {
+    role: string;
+    content?: unknown;
+    tool_call_id?: string;
+    [key: string]: unknown;
+}
+/** Subset of the `openai` package's tool-definition shape we read from. */
+interface OpenAiToolParam {
+    type?: string;
+    function?: {
+        name?: string;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+/**
+ * Subset of `openai`'s `ChatCompletionCreateParams` we read from. We
+ * deliberately decline to import the real types so the SDK works even when
+ * `openai` isn't installed (it's an optional peer dep).
+ */
+interface OpenAiChatCompletionCreateParams {
+    model: string;
+    messages: OpenAiChatMessageParam[];
+    tools?: OpenAiToolParam[];
+    [key: string]: unknown;
+}
+interface OpenAiCompletionUsageDetails {
+    cached_tokens?: number;
+    reasoning_tokens?: number;
+    [key: string]: unknown;
+}
+interface OpenAiCompletionUsage {
+    prompt_tokens?: number;
+    completion_tokens?: number;
+    total_tokens?: number;
+    prompt_tokens_details?: OpenAiCompletionUsageDetails;
+    completion_tokens_details?: OpenAiCompletionUsageDetails;
+    [key: string]: unknown;
+}
+interface OpenAiChatCompletionResponse {
+    id?: string;
+    model?: string;
+    usage?: OpenAiCompletionUsage;
+    choices?: Array<{
+        message?: {
+            content?: unknown;
+            [k: string]: unknown;
+        };
+        [k: string]: unknown;
+    }>;
+    [key: string]: unknown;
+}
+/**
+ * Structural shape of the plain OpenAI client we wrap. We only require
+ * that `client.chat.completions.create` is a function returning a Promise.
+ */
+interface OpenAiClientLike {
+    chat: {
+        completions: {
+            create(params: OpenAiChatCompletionCreateParams, options?: unknown): Promise<OpenAiChatCompletionResponse>;
+            [key: string]: unknown;
+        };
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+interface WrapOpenAiOptions {
+    /**
+     * When provided, used as the parent agent span's name when
+     * `chat.completions.create` is called outside an active trace. Defaults
+     * to `"openai.chat.completions.create"`.
+     */
+    defaultAgentName?: string;
+}
+/**
+ * Wrap an OpenAI client so every `chat.completions.create` call records an
+ * `llm` span with `model`, token counts, `cost_usd`, and `context_segments`.
+ * The wrapper preserves the rest of the client's surface (other resources,
+ * helpers, etc.) via a Proxy.
+ *
+ * Idempotent — a previously wrapped client is returned as-is.
+ *
+ * @example
+ * ```ts
+ * import { wrapOpenAI } from "@morsehq-dev/sdk/openai";
+ * import OpenAI from "openai";
+ *
+ * const client = wrapOpenAI(new OpenAI());
+ * const response = await client.chat.completions.create({
+ *   model: "gpt-4o-mini",
+ *   messages: [{ role: "user", content: "hello" }],
+ * });
+ * ```
+ */
+declare function wrapOpenAI<C extends OpenAiClientLike>(client: C, options?: WrapOpenAiOptions): C;
+/** True when a wrapped OpenAI client is passed in. */
+declare function isOpenAiWrapped(client: unknown): boolean;
+
+export { type OpenAiChatCompletionCreateParams, type OpenAiChatCompletionResponse, type OpenAiChatMessageParam, type OpenAiClientLike, type OpenAiCompletionUsage, type OpenAiCompletionUsageDetails, type OpenAiToolParam, type WrapOpenAiOptions, isOpenAiWrapped, wrapOpenAI };

package/dist/openai/index.d.ts

@@ -0,0 +1,136 @@
+/**
+ * `@morsehq-dev/sdk/openai` — plain OpenAI SDK instrumentation.
+ *
+ * Wraps a raw `openai` npm package client (`new OpenAI()` /
+ * `new AzureOpenAI()` / any structurally-compatible client) so every
+ * `chat.completions.create` call emits an `llm` span carrying model,
+ * token counts, `cost_usd`, and pre-segmented `context_segments`.
+ *
+ * TS port of `apps/sdk/python/src/morse_ai/adapters/openai.py`'s `wrap()`.
+ * This module intentionally covers only the `wrap(client)` recommended
+ * path (mirrors the Python module's three-layer doc comment, layer 2) —
+ * no module-level monkey-patch / `install()` layer, since plain `openai`
+ * is not one of the auto-detect targets on either SDK (see
+ * `_internal/auto-detect.ts` and Python's `_internal/auto_detect.py`
+ * `_adapter_targets()`, which both omit bare `openai`).
+ *
+ * Distinct from `@morsehq-dev/sdk/openai-agents`, which instruments the
+ * `@openai/agents` Agents SDK (a different package with its own Runner /
+ * Agent abstractions). This module is for customers calling
+ * `openai.chat.completions.create` directly.
+ *
+ * Context segments are extracted via the shared
+ * `_agent-sdk-common/context-decomposer.ts` (`decomposeOpenAiMessages`,
+ * MHQ-750) — the request's `messages`/`tools` are already in the native
+ * OpenAI wire format the decomposer expects, so no translation layer is
+ * needed.
+ *
+ * Idempotent — wrapping an already-wrapped client instance is a no-op
+ * that returns the same wrapper. Recording is best-effort: any failure
+ * while building/emitting the span is swallowed so it can never break the
+ * customer's OpenAI call. The customer's own API error (thrown by the
+ * underlying `create()` call) always propagates unchanged — the span is
+ * marked `status: "failed"` first, then the error is re-raised.
+ *
+ * Mirrors `apps/sdk/typescript/src/anthropic/index.ts` in shape.
+ */
+/** Subset of the `openai` package's chat message shape we read from. */
+interface OpenAiChatMessageParam {
+    role: string;
+    content?: unknown;
+    tool_call_id?: string;
+    [key: string]: unknown;
+}
+/** Subset of the `openai` package's tool-definition shape we read from. */
+interface OpenAiToolParam {
+    type?: string;
+    function?: {
+        name?: string;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+/**
+ * Subset of `openai`'s `ChatCompletionCreateParams` we read from. We
+ * deliberately decline to import the real types so the SDK works even when
+ * `openai` isn't installed (it's an optional peer dep).
+ */
+interface OpenAiChatCompletionCreateParams {
+    model: string;
+    messages: OpenAiChatMessageParam[];
+    tools?: OpenAiToolParam[];
+    [key: string]: unknown;
+}
+interface OpenAiCompletionUsageDetails {
+    cached_tokens?: number;
+    reasoning_tokens?: number;
+    [key: string]: unknown;
+}
+interface OpenAiCompletionUsage {
+    prompt_tokens?: number;
+    completion_tokens?: number;
+    total_tokens?: number;
+    prompt_tokens_details?: OpenAiCompletionUsageDetails;
+    completion_tokens_details?: OpenAiCompletionUsageDetails;
+    [key: string]: unknown;
+}
+interface OpenAiChatCompletionResponse {
+    id?: string;
+    model?: string;
+    usage?: OpenAiCompletionUsage;
+    choices?: Array<{
+        message?: {
+            content?: unknown;
+            [k: string]: unknown;
+        };
+        [k: string]: unknown;
+    }>;
+    [key: string]: unknown;
+}
+/**
+ * Structural shape of the plain OpenAI client we wrap. We only require
+ * that `client.chat.completions.create` is a function returning a Promise.
+ */
+interface OpenAiClientLike {
+    chat: {
+        completions: {
+            create(params: OpenAiChatCompletionCreateParams, options?: unknown): Promise<OpenAiChatCompletionResponse>;
+            [key: string]: unknown;
+        };
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+interface WrapOpenAiOptions {
+    /**
+     * When provided, used as the parent agent span's name when
+     * `chat.completions.create` is called outside an active trace. Defaults
+     * to `"openai.chat.completions.create"`.
+     */
+    defaultAgentName?: string;
+}
+/**
+ * Wrap an OpenAI client so every `chat.completions.create` call records an
+ * `llm` span with `model`, token counts, `cost_usd`, and `context_segments`.
+ * The wrapper preserves the rest of the client's surface (other resources,
+ * helpers, etc.) via a Proxy.
+ *
+ * Idempotent — a previously wrapped client is returned as-is.
+ *
+ * @example
+ * ```ts
+ * import { wrapOpenAI } from "@morsehq-dev/sdk/openai";
+ * import OpenAI from "openai";
+ *
+ * const client = wrapOpenAI(new OpenAI());
+ * const response = await client.chat.completions.create({
+ *   model: "gpt-4o-mini",
+ *   messages: [{ role: "user", content: "hello" }],
+ * });
+ * ```
+ */
+declare function wrapOpenAI<C extends OpenAiClientLike>(client: C, options?: WrapOpenAiOptions): C;
+/** True when a wrapped OpenAI client is passed in. */
+declare function isOpenAiWrapped(client: unknown): boolean;
+
+export { type OpenAiChatCompletionCreateParams, type OpenAiChatCompletionResponse, type OpenAiChatMessageParam, type OpenAiClientLike, type OpenAiCompletionUsage, type OpenAiCompletionUsageDetails, type OpenAiToolParam, type WrapOpenAiOptions, isOpenAiWrapped, wrapOpenAI };

package/dist/openai/index.js

@@ -0,0 +1,122 @@
+import { calculateCost } from '../chunk-XTKMUJWI.js';
+import { decomposeOpenAiMessages } from '../chunk-4R4SHGOK.js';
+import { init_tracing, getActiveTraceState, runAsync, startSpan } from '../chunk-TQWI4UYO.js';
+
+// src/openai/index.ts
+init_tracing();
+var WRAPPED_CLIENT = /* @__PURE__ */ Symbol.for("morse.openai.wrapped");
+function wrapOpenAI(client, options = {}) {
+  if (!client || typeof client !== "object") return client;
+  if (client[WRAPPED_CLIENT]) return client;
+  const originalCreate = client.chat?.completions?.create?.bind(client.chat.completions);
+  if (typeof originalCreate !== "function") return client;
+  const patchedCreate = buildPatchedCreate(originalCreate, options);
+  const patchedCompletions = new Proxy(client.chat.completions, {
+    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 patchedChat = new Proxy(client.chat, {
+    get(target, prop, receiver) {
+      if (prop === "completions") return patchedCompletions;
+      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 === "chat") return patchedChat;
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value === "function") return value.bind(target);
+      return value;
+    }
+  });
+  return wrapper;
+}
+function isOpenAiWrapped(client) {
+  if (!client || typeof client !== "object") return false;
+  return client[WRAPPED_CLIENT] === true;
+}
+function buildPatchedCreate(original, options) {
+  const agentName = options.defaultAgentName ?? "openai.chat.completions.create";
+  return async function patchedCreate(params, callOptions) {
+    const inTrace = getActiveTraceState() !== null;
+    const work = async () => {
+      const handle = startSpan({
+        name: "openai.chat.completions.create",
+        type: "llm",
+        metadata: { model: params?.model }
+      });
+      let response;
+      try {
+        response = await original.call(this, params, callOptions);
+      } catch (err) {
+        handle?.end(err);
+        throw err;
+      }
+      try {
+        if (handle) {
+          const segments = safeExtractSegments(params);
+          const usage = response?.usage ?? {};
+          const inputTokens = usage.prompt_tokens ?? 0;
+          const outputTokens = usage.completion_tokens ?? 0;
+          const cachedTokens = usage.prompt_tokens_details?.cached_tokens ?? 0;
+          const model = response?.model ?? params?.model;
+          handle.span.model = model;
+          if (inputTokens > 0) handle.span.input_tokens = inputTokens;
+          if (outputTokens > 0) handle.span.output_tokens = outputTokens;
+          if (cachedTokens > 0) handle.span.cached_input_tokens = cachedTokens;
+          const totalTokens = usage.total_tokens ?? (inputTokens > 0 || outputTokens > 0 ? inputTokens + outputTokens : 0);
+          if (totalTokens > 0) handle.span.total_tokens = totalTokens;
+          if (model && (inputTokens > 0 || outputTokens > 0)) {
+            const cost = calculateCost({
+              inputTokens,
+              outputTokens,
+              model,
+              cachedInputTokens: cachedTokens
+            });
+            if (cost !== void 0) handle.span.cost_usd = cost;
+          }
+          handle.span.context_segments = segments;
+        }
+      } catch {
+      }
+      handle?.end();
+      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;
+  };
+}
+function safeExtractSegments(params) {
+  try {
+    if (!params || typeof params !== "object") return [];
+    return decomposeOpenAiMessages(params.messages, params.tools);
+  } catch {
+    return [];
+  }
+}
+
+export { isOpenAiWrapped, wrapOpenAI };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/openai/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/openai/index.ts"],"names":[],"mappings":";;;;;AAwCA,YAAA,EAAA;AA+EA,IAAM,cAAA,mBAAiB,MAAA,CAAO,GAAA,CAAI,sBAAsB,CAAA;AAmCjD,SAAS,UAAA,CACd,MAAA,EACA,OAAA,GAA6B,EAAC,EAC3B;AACH,EAAA,IAAI,CAAC,MAAA,IAAU,OAAO,MAAA,KAAW,UAAU,OAAO,MAAA;AAElD,EAAA,IAAK,MAAA,CAA4C,cAAc,CAAA,EAAG,OAAO,MAAA;AAEzE,EAAA,MAAM,cAAA,GAAiB,OAAO,IAAA,EAAM,WAAA,EAAa,QAAQ,IAAA,CAAK,MAAA,CAAO,KAAK,WAAW,CAAA;AACrF,EAAA,IAAI,OAAO,cAAA,KAAmB,UAAA,EAAY,OAAO,MAAA;AAEjD,EAAA,MAAM,aAAA,GAAgB,kBAAA,CAAmB,cAAA,EAAgB,OAAO,CAAA;AAKhE,EAAA,MAAM,kBAAA,GAAqB,IAAI,KAAA,CAAM,MAAA,CAAO,KAAK,WAAA,EAAa;AAAA,IAC5D,GAAA,CAAI,MAAA,EAAQ,IAAA,EAAM,QAAA,EAAU;AAC1B,MAAA,IAAI,IAAA,KAAS,UAAU,OAAO,aAAA;AAC9B,MAAA,MAAM,KAAA,GAAQ,OAAA,CAAQ,GAAA,CAAI,MAAA,EAAQ,MAAM,QAAQ,CAAA;AAChD,MAAA,IAAI,OAAO,KAAA,KAAU,UAAA,EAAY,OAAQ,KAAA,CAAuC,KAAK,MAAM,CAAA;AAC3F,MAAA,OAAO,KAAA;AAAA,IACT;AAAA,GACD,CAAA;AAED,EAAA,MAAM,WAAA,GAAc,IAAI,KAAA,CAAM,MAAA,CAAO,IAAA,EAAM;AAAA,IACzC,GAAA,CAAI,MAAA,EAAQ,IAAA,EAAM,QAAA,EAAU;AAC1B,MAAA,IAAI,IAAA,KAAS,eAAe,OAAO,kBAAA;AACnC,MAAA,MAAM,KAAA,GAAQ,OAAA,CAAQ,GAAA,CAAI,MAAA,EAAQ,MAAM,QAAQ,CAAA;AAChD,MAAA,IAAI,OAAO,KAAA,KAAU,UAAA,EAAY,OAAQ,KAAA,CAAuC,KAAK,MAAM,CAAA;AAC3F,MAAA,OAAO,KAAA;AAAA,IACT;AAAA,GACD,CAAA;AAED,EAAA,MAAM,OAAA,GAAU,IAAI,KAAA,CAAM,MAAA,EAAQ;AAAA,IAChC,GAAA,CAAI,MAAA,EAAQ,IAAA,EAAM,QAAA,EAAU;AAC1B,MAAA,IAAI,IAAA,KAAS,gBAAgB,OAAO,IAAA;AACpC,MAAA,IAAI,IAAA,KAAS,QAAQ,OAAO,WAAA;AAC5B,MAAA,MAAM,KAAA,GAAQ,OAAA,CAAQ,GAAA,CAAI,MAAA,EAAQ,MAAM,QAAQ,CAAA;AAChD,MAAA,IAAI,OAAO,KAAA,KAAU,UAAA,EAAY,OAAQ,KAAA,CAAuC,KAAK,MAAM,CAAA;AAC3F,MAAA,OAAO,KAAA;AAAA,IACT;AAAA,GACD,CAAA;AAED,EAAA,OAAO,OAAA;AACT;AAGO,SAAS,gBAAgB,MAAA,EAA0B;AACxD,EAAA,IAAI,CAAC,MAAA,IAAU,OAAO,MAAA,KAAW,UAAU,OAAO,KAAA;AAClD,EAAA,OAAQ,MAAA,CAA4C,cAAc,CAAA,KAAM,IAAA;AAC1E;AAMA,SAAS,kBAAA,CACP,UAIA,OAAA,EAIyC;AACzC,EAAA,MAAM,SAAA,GAAY,QAAQ,gBAAA,IAAoB,gCAAA;AAE9C,EAAA,OAAO,eAAe,aAAA,CAEpB,MAAA,EACA,WAAA,EACuC;AACvC,IAAA,MAAM,OAAA,GAAU,qBAAoB,KAAM,IAAA;AAE1C,IAAA,MAAM,OAAO,YAAmD;AAC9D,MAAA,MAAM,SAAS,SAAA,CAAU;AAAA,QACvB,IAAA,EAAM,gCAAA;AAAA,QACN,IAAA,EAAM,KAAA;AAAA,QACN,QAAA,EAAU,EAAE,KAAA,EAAO,MAAA,EAAQ,KAAA;AAAM,OAClC,CAAA;AACD,MAAA,IAAI,QAAA;AACJ,MAAA,IAAI;AACF,QAAA,QAAA,GAAW,MAAM,QAAA,CAAS,IAAA,CAAK,IAAA,EAAM,QAAQ,WAAW,CAAA;AAAA,MAC1D,SAAS,GAAA,EAAK;AAGZ,QAAA,MAAA,EAAQ,IAAI,GAAG,CAAA;AACf,QAAA,MAAM,GAAA;AAAA,MACR;AAGA,MAAA,IAAI;AACF,QAAA,IAAI,MAAA,EAAQ;AACV,UAAA,MAAM,QAAA,GAAW,oBAAoB,MAAM,CAAA;AAC3C,UAAA,MAAM,KAAA,GAAQ,QAAA,EAAU,KAAA,IAAS,EAAC;AAClC,UAAA,MAAM,WAAA,GAAc,MAAM,aAAA,IAAiB,CAAA;AAC3C,UAAA,MAAM,YAAA,GAAe,MAAM,iBAAA,IAAqB,CAAA;AAChD,UAAA,MAAM,YAAA,GAAe,KAAA,CAAM,qBAAA,EAAuB,aAAA,IAAiB,CAAA;AACnE,UAAA,MAAM,KAAA,GAAQ,QAAA,EAAU,KAAA,IAAS,MAAA,EAAQ,KAAA;AAEzC,UAAA,MAAA,CAAO,KAAK,KAAA,GAAQ,KAAA;AACpB,UAAA,IAAI,WAAA,GAAc,CAAA,EAAG,MAAA,CAAO,IAAA,CAAK,YAAA,GAAe,WAAA;AAChD,UAAA,IAAI,YAAA,GAAe,CAAA,EAAG,MAAA,CAAO,IAAA,CAAK,aAAA,GAAgB,YAAA;AAClD,UAAA,IAAI,YAAA,GAAe,CAAA,EAAG,MAAA,CAAO,IAAA,CAAK,mBAAA,GAAsB,YAAA;AACxD,UAAA,MAAM,WAAA,GACJ,MAAM,YAAA,KACL,WAAA,GAAc,KAAK,YAAA,GAAe,CAAA,GAAI,cAAc,YAAA,GAAe,CAAA,CAAA;AACtE,UAAA,IAAI,WAAA,GAAc,CAAA,EAAG,MAAA,CAAO,IAAA,CAAK,YAAA,GAAe,WAAA;AAEhD,UAAA,IAAI,KAAA,KAAU,WAAA,GAAc,CAAA,IAAK,YAAA,GAAe,CAAA,CAAA,EAAI;AAClD,YAAA,MAAM,OAAO,aAAA,CAAc;AAAA,cACzB,WAAA;AAAA,cACA,YAAA;AAAA,cACA,KAAA;AAAA,cACA,iBAAA,EAAmB;AAAA,aACpB,CAAA;AACD,YAAA,IAAI,IAAA,KAAS,KAAA,CAAA,EAAW,MAAA,CAAO,IAAA,CAAK,QAAA,GAAW,IAAA;AAAA,UACjD;AACA,UAAA,MAAA,CAAO,KAAK,gBAAA,GAAmB,QAAA;AAAA,QACjC;AAAA,MACF,CAAA,CAAA,MAAQ;AAAA,MAER;AACA,MAAA,MAAA,EAAQ,GAAA,EAAI;AACZ,MAAA,OAAO,QAAA;AAAA,IACT,CAAA;AAEA,IAAA,IAAI,OAAA,EAAS;AACX,MAAA,OAAO,IAAA,EAAK;AAAA,IACd;AAOA,IAAA,IAAI,MAAA;AACJ,IAAA,IAAI,MAAA;AACJ,IAAA,MAAM,QAAA,CAAU,EAAE,SAAA,EAAU,EAAG,OAAO,SAAA,KAAc;AAClD,MAAA,SAAA,CAAU,WAAW,IAAI,CAAA;AACzB,MAAA,IAAI;AACF,QAAA,MAAA,GAAS,MAAM,IAAA,EAAK;AAAA,MACtB,SAAS,GAAA,EAAK;AACZ,QAAA,MAAA,GAAS,GAAA;AACT,QAAA,MAAM,GAAA;AAAA,MACR;AACA,MAAA,OAAO,IAAA;AAAA,IACT,CAAC,CAAA;AACD,IAAA,IAAI,MAAA,KAAW,QAAW,MAAM,MAAA;AAChC,IAAA,OAAO,MAAA;AAAA,EACT,CAAA;AACF;AAEA,SAAS,oBAAoB,MAAA,EAA4D;AACvF,EAAA,IAAI;AACF,IAAA,IAAI,CAAC,MAAA,IAAU,OAAO,MAAA,KAAW,QAAA,SAAiB,EAAC;AACnD,IAAA,OAAO,uBAAA,CAAwB,MAAA,CAAO,QAAA,EAAU,MAAA,CAAO,KAAK,CAAA;AAAA,EAC9D,CAAA,CAAA,MAAQ;AACN,IAAA,OAAO,EAAC;AAAA,EACV;AACF","file":"index.js","sourcesContent":["/**\n * `@morsehq-dev/sdk/openai` — plain OpenAI SDK instrumentation.\n *\n * Wraps a raw `openai` npm package client (`new OpenAI()` /\n * `new AzureOpenAI()` / any structurally-compatible client) so every\n * `chat.completions.create` call emits an `llm` span carrying model,\n * token counts, `cost_usd`, and pre-segmented `context_segments`.\n *\n * TS port of `apps/sdk/python/src/morse_ai/adapters/openai.py`'s `wrap()`.\n * This module intentionally covers only the `wrap(client)` recommended\n * path (mirrors the Python module's three-layer doc comment, layer 2) —\n * no module-level monkey-patch / `install()` layer, since plain `openai`\n * is not one of the auto-detect targets on either SDK (see\n * `_internal/auto-detect.ts` and Python's `_internal/auto_detect.py`\n * `_adapter_targets()`, which both omit bare `openai`).\n *\n * Distinct from `@morsehq-dev/sdk/openai-agents`, which instruments the\n * `@openai/agents` Agents SDK (a different package with its own Runner /\n * Agent abstractions). This module is for customers calling\n * `openai.chat.completions.create` directly.\n *\n * Context segments are extracted via the shared\n * `_agent-sdk-common/context-decomposer.ts` (`decomposeOpenAiMessages`,\n * MHQ-750) — the request's `messages`/`tools` are already in the native\n * OpenAI wire format the decomposer expects, so no translation layer is\n * needed.\n *\n * Idempotent — wrapping an already-wrapped client instance is a no-op\n * that returns the same wrapper. Recording is best-effort: any failure\n * while building/emitting the span is swallowed so it can never break the\n * customer's OpenAI call. The customer's own API error (thrown by the\n * underlying `create()` call) always propagates unchanged — the span is\n * marked `status: \"failed\"` first, then the error is re-raised.\n *\n * Mirrors `apps/sdk/typescript/src/anthropic/index.ts` in shape.\n */\n\nimport { decomposeOpenAiMessages } from \"../_agent-sdk-common/context-decomposer\";\nimport { calculateCost } from \"../_internal/pricing\";\nimport type { ContextSegment } from \"../_internal/spans\";\nimport { getActiveTraceState, runAsync as _runAsync, startSpan } from \"../_internal/tracing\";\n\n/* ------------------------------------------------------------------------ */\n/*  Public types — minimal structural shapes, NOT a hard dep on `openai`     */\n/* ------------------------------------------------------------------------ */\n\n/** Subset of the `openai` package's chat message shape we read from. */\nexport interface OpenAiChatMessageParam {\n  role: string;\n  content?: unknown;\n  tool_call_id?: string;\n  [key: string]: unknown;\n}\n\n/** Subset of the `openai` package's tool-definition shape we read from. */\nexport interface OpenAiToolParam {\n  type?: string;\n  function?: { name?: string; [key: string]: unknown };\n  [key: string]: unknown;\n}\n\n/**\n * Subset of `openai`'s `ChatCompletionCreateParams` we read from. We\n * deliberately decline to import the real types so the SDK works even when\n * `openai` isn't installed (it's an optional peer dep).\n */\nexport interface OpenAiChatCompletionCreateParams {\n  model: string;\n  messages: OpenAiChatMessageParam[];\n  tools?: OpenAiToolParam[];\n  // Allow forward-compat fields without complaint.\n  [key: string]: unknown;\n}\n\nexport interface OpenAiCompletionUsageDetails {\n  cached_tokens?: number;\n  reasoning_tokens?: number;\n  [key: string]: unknown;\n}\n\nexport interface OpenAiCompletionUsage {\n  prompt_tokens?: number;\n  completion_tokens?: number;\n  total_tokens?: number;\n  prompt_tokens_details?: OpenAiCompletionUsageDetails;\n  completion_tokens_details?: OpenAiCompletionUsageDetails;\n  [key: string]: unknown;\n}\n\nexport interface OpenAiChatCompletionResponse {\n  id?: string;\n  model?: string;\n  usage?: OpenAiCompletionUsage;\n  choices?: Array<{ message?: { content?: unknown; [k: string]: unknown }; [k: string]: unknown }>;\n  [key: string]: unknown;\n}\n\n/**\n * Structural shape of the plain OpenAI client we wrap. We only require\n * that `client.chat.completions.create` is a function returning a Promise.\n */\nexport interface OpenAiClientLike {\n  chat: {\n    completions: {\n      create(\n        params: OpenAiChatCompletionCreateParams,\n        options?: unknown,\n      ): Promise<OpenAiChatCompletionResponse>;\n      [key: string]: unknown;\n    };\n    [key: string]: unknown;\n  };\n  [key: string]: unknown;\n}\n\n/* ------------------------------------------------------------------------ */\n/*  Module-level sentinel                                                    */\n/* ------------------------------------------------------------------------ */\n\nconst WRAPPED_CLIENT = Symbol.for(\"morse.openai.wrapped\");\n\n/* ------------------------------------------------------------------------ */\n/*  Public API                                                               */\n/* ------------------------------------------------------------------------ */\n\nexport interface WrapOpenAiOptions {\n  /**\n   * When provided, used as the parent agent span's name when\n   * `chat.completions.create` is called outside an active trace. Defaults\n   * to `\"openai.chat.completions.create\"`.\n   */\n  defaultAgentName?: string;\n}\n\n/**\n * Wrap an OpenAI client so every `chat.completions.create` call records an\n * `llm` span with `model`, token counts, `cost_usd`, and `context_segments`.\n * The wrapper preserves the rest of the client's surface (other resources,\n * helpers, etc.) via a Proxy.\n *\n * Idempotent — a previously wrapped client is returned as-is.\n *\n * @example\n * ```ts\n * import { wrapOpenAI } from \"@morsehq-dev/sdk/openai\";\n * import OpenAI from \"openai\";\n *\n * const client = wrapOpenAI(new OpenAI());\n * const response = await client.chat.completions.create({\n *   model: \"gpt-4o-mini\",\n *   messages: [{ role: \"user\", content: \"hello\" }],\n * });\n * ```\n */\nexport function wrapOpenAI<C extends OpenAiClientLike>(\n  client: C,\n  options: WrapOpenAiOptions = {},\n): C {\n  if (!client || typeof client !== \"object\") return client;\n  // Already wrapped? Pass through.\n  if ((client as Record<string | symbol, unknown>)[WRAPPED_CLIENT]) return client;\n\n  const originalCreate = client.chat?.completions?.create?.bind(client.chat.completions);\n  if (typeof originalCreate !== \"function\") return client;\n\n  const patchedCreate = buildPatchedCreate(originalCreate, options);\n\n  // Construct a new `completions` object that proxies to the original for\n  // any non-`create` access, wrapped in a `chat` proxy, wrapped in a\n  // top-level client proxy — mirrors `wrapAnthropic`'s nested-Proxy shape.\n  const patchedCompletions = new Proxy(client.chat.completions, {\n    get(target, prop, receiver) {\n      if (prop === \"create\") return patchedCreate;\n      const value = Reflect.get(target, prop, receiver);\n      if (typeof value === \"function\") return (value as (...a: unknown[]) => unknown).bind(target);\n      return value;\n    },\n  });\n\n  const patchedChat = new Proxy(client.chat, {\n    get(target, prop, receiver) {\n      if (prop === \"completions\") return patchedCompletions;\n      const value = Reflect.get(target, prop, receiver);\n      if (typeof value === \"function\") return (value as (...a: unknown[]) => unknown).bind(target);\n      return value;\n    },\n  });\n\n  const wrapper = new Proxy(client, {\n    get(target, prop, receiver) {\n      if (prop === WRAPPED_CLIENT) return true;\n      if (prop === \"chat\") return patchedChat;\n      const value = Reflect.get(target, prop, receiver);\n      if (typeof value === \"function\") return (value as (...a: unknown[]) => unknown).bind(target);\n      return value;\n    },\n  });\n\n  return wrapper as C;\n}\n\n/** True when a wrapped OpenAI client is passed in. */\nexport function isOpenAiWrapped(client: unknown): boolean {\n  if (!client || typeof client !== \"object\") return false;\n  return (client as Record<string | symbol, unknown>)[WRAPPED_CLIENT] === true;\n}\n\n/* ------------------------------------------------------------------------ */\n/*  Internals — wrapper that records an `llm` span                           */\n/* ------------------------------------------------------------------------ */\n\nfunction buildPatchedCreate(\n  original: (\n    params: OpenAiChatCompletionCreateParams,\n    options?: unknown,\n  ) => Promise<OpenAiChatCompletionResponse>,\n  options: WrapOpenAiOptions,\n): (\n  params: OpenAiChatCompletionCreateParams,\n  options?: unknown,\n) => Promise<OpenAiChatCompletionResponse> {\n  const agentName = options.defaultAgentName ?? \"openai.chat.completions.create\";\n\n  return async function patchedCreate(\n    this: unknown,\n    params: OpenAiChatCompletionCreateParams,\n    callOptions?: unknown,\n  ): Promise<OpenAiChatCompletionResponse> {\n    const inTrace = getActiveTraceState() !== null;\n\n    const work = async (): Promise<OpenAiChatCompletionResponse> => {\n      const handle = startSpan({\n        name: \"openai.chat.completions.create\",\n        type: \"llm\",\n        metadata: { model: params?.model },\n      });\n      let response: OpenAiChatCompletionResponse | undefined;\n      try {\n        response = await original.call(this, params, callOptions);\n      } catch (err) {\n        // Customer's own API error — mark the span failed, then re-raise\n        // unchanged. Never swallow the caller's real error.\n        handle?.end(err);\n        throw err;\n      }\n\n      // Recording is best-effort — never let it throw at the caller.\n      try {\n        if (handle) {\n          const segments = safeExtractSegments(params);\n          const usage = response?.usage ?? {};\n          const inputTokens = usage.prompt_tokens ?? 0;\n          const outputTokens = usage.completion_tokens ?? 0;\n          const cachedTokens = usage.prompt_tokens_details?.cached_tokens ?? 0;\n          const model = response?.model ?? params?.model;\n\n          handle.span.model = model;\n          if (inputTokens > 0) handle.span.input_tokens = inputTokens;\n          if (outputTokens > 0) handle.span.output_tokens = outputTokens;\n          if (cachedTokens > 0) handle.span.cached_input_tokens = cachedTokens;\n          const totalTokens =\n            usage.total_tokens ??\n            (inputTokens > 0 || outputTokens > 0 ? inputTokens + outputTokens : 0);\n          if (totalTokens > 0) handle.span.total_tokens = totalTokens;\n\n          if (model && (inputTokens > 0 || outputTokens > 0)) {\n            const cost = calculateCost({\n              inputTokens,\n              outputTokens,\n              model,\n              cachedInputTokens: cachedTokens,\n            });\n            if (cost !== undefined) handle.span.cost_usd = cost;\n          }\n          handle.span.context_segments = segments;\n        }\n      } catch {\n        // swallow — telemetry must never break the caller\n      }\n      handle?.end();\n      return response;\n    };\n\n    if (inTrace) {\n      return work();\n    }\n\n    // No active trace — open a fresh agent span around the call so the\n    // llm span has a parent. Mirrors `wrapAnthropic`'s pattern: we can't\n    // return `work()`'s Promise from inside `_runAsync`'s callback while\n    // preserving typing AND having the fresh trace own the lifecycle, so\n    // we wrap explicitly.\n    let result: OpenAiChatCompletionResponse | undefined;\n    let thrown: unknown;\n    await _runAsync({ agentName }, async (runHandle) => {\n      runHandle.setOutcome(true);\n      try {\n        result = await work();\n      } catch (err) {\n        thrown = err;\n        throw err;\n      }\n      return null;\n    });\n    if (thrown !== undefined) throw thrown;\n    return result as OpenAiChatCompletionResponse;\n  };\n}\n\nfunction safeExtractSegments(params: OpenAiChatCompletionCreateParams): ContextSegment[] {\n  try {\n    if (!params || typeof params !== \"object\") return [];\n    return decomposeOpenAiMessages(params.messages, params.tools);\n  } catch {\n    return [];\n  }\n}\n"]}