@core-ai/opentelemetry 0.10.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Omnifact (https://omnifact.ai)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,30 @@
+# @core-ai/opentelemetry
+
+[![npm](https://img.shields.io/npm/v/@core-ai/opentelemetry.svg)](https://www.npmjs.com/package/@core-ai/opentelemetry)
+
+OpenTelemetry middleware for `@core-ai/core-ai`.
+
+## Installation
+
+```bash
+npm install @core-ai/opentelemetry @opentelemetry/api
+```
+
+`@opentelemetry/api` is a peer dependency and must be installed alongside this package.
+
+## Usage
+
+```ts
+import { generate } from '@core-ai/core-ai';
+import { createOpenAI } from '@core-ai/openai';
+import { createOtelMiddleware } from '@core-ai/opentelemetry';
+
+const openai = createOpenAI({ apiKey: process.env.OPENAI_API_KEY });
+const model = openai.chatModel('gpt-5-mini');
+
+const result = await generate({
+    model,
+    messages: [{ role: 'user', content: 'Hello!' }],
+    middleware: [createOtelMiddleware()],
+});
+```

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import { EmbeddingModelMiddleware, ImageModelMiddleware, ChatModelMiddleware } from '@core-ai/core-ai';
+
+type OtelMiddlewareOptions = {
+    recordContent?: boolean;
+    tracerName?: string;
+};
+declare function createOtelMiddleware(options?: OtelMiddlewareOptions): ChatModelMiddleware;
+declare function createOtelEmbeddingMiddleware(options?: OtelMiddlewareOptions): EmbeddingModelMiddleware;
+declare function createOtelImageMiddleware(options?: OtelMiddlewareOptions): ImageModelMiddleware;
+
+export { type OtelMiddlewareOptions, createOtelEmbeddingMiddleware, createOtelImageMiddleware, createOtelMiddleware };

package/dist/index.js

@@ -0,0 +1,536 @@
+// src/index.ts
+import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
+
+// src/attributes.ts
+import { zodSchemaToJsonSchema } from "@core-ai/core-ai";
+function safeJsonStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return void 0;
+  }
+}
+function setSpanAttribute(span, key, value) {
+  if (value !== void 0) {
+    span.setAttribute(key, value);
+  }
+}
+function isPrimitiveArray(value) {
+  if (!Array.isArray(value)) {
+    return false;
+  }
+  if (value.length === 0) {
+    return true;
+  }
+  const first = value[0];
+  const primitiveType = typeof first;
+  if (primitiveType !== "string" && primitiveType !== "number" && primitiveType !== "boolean") {
+    return false;
+  }
+  return value.every((item) => typeof item === primitiveType);
+}
+function toSpanAttributeValue(value) {
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (isPrimitiveArray(value)) {
+    return value;
+  }
+  return safeJsonStringify(value);
+}
+function setMetadataAttributes(span, metadata) {
+  if (!metadata) {
+    return;
+  }
+  const { functionId, ...restMetadata } = metadata;
+  if (typeof functionId === "string") {
+    span.setAttribute("core_ai.function_id", functionId);
+  }
+  for (const [key, value] of Object.entries(restMetadata)) {
+    setSpanAttribute(
+      span,
+      `core_ai.metadata.${key}`,
+      toSpanAttributeValue(value)
+    );
+  }
+}
+function serializeUserContentParts(content) {
+  if (typeof content === "string") {
+    return [{ type: "text", content }];
+  }
+  return content.map((part) => {
+    if (part.type === "text") {
+      return {
+        type: "text",
+        content: part.text
+      };
+    }
+    if (part.type === "image") {
+      return {
+        type: "image",
+        source: part.source
+      };
+    }
+    return {
+      type: "file",
+      data: part.data,
+      mime_type: part.mimeType,
+      ...part.filename ? { filename: part.filename } : {}
+    };
+  });
+}
+function serializeAssistantContentParts(parts) {
+  return parts.map((part) => {
+    if (part.type === "text") {
+      return {
+        type: "text",
+        content: part.text
+      };
+    }
+    if (part.type === "reasoning") {
+      return {
+        type: "reasoning",
+        content: part.text,
+        ...part.providerMetadata ? {
+          provider_metadata: part.providerMetadata
+        } : {}
+      };
+    }
+    return {
+      type: "tool_call",
+      id: part.toolCall.id,
+      name: part.toolCall.name,
+      arguments: part.toolCall.arguments
+    };
+  });
+}
+function setChatInputAttributes(span, messages, tools) {
+  const systemInstructions = [];
+  const inputMessages = [];
+  for (const message of messages) {
+    if (message.role === "system") {
+      systemInstructions.push({
+        type: "text",
+        content: message.content
+      });
+      continue;
+    }
+    if (message.role === "user") {
+      inputMessages.push({
+        role: "user",
+        parts: serializeUserContentParts(message.content)
+      });
+      continue;
+    }
+    if (message.role === "assistant") {
+      inputMessages.push({
+        role: "assistant",
+        parts: serializeAssistantContentParts(message.parts)
+      });
+      continue;
+    }
+    inputMessages.push({
+      role: "tool",
+      parts: [
+        {
+          type: "tool_call_response",
+          id: message.toolCallId,
+          result: message.content,
+          ...message.isError ? { is_error: true } : {}
+        }
+      ]
+    });
+  }
+  if (systemInstructions.length > 0) {
+    setSpanAttribute(
+      span,
+      "gen_ai.system_instructions",
+      safeJsonStringify(systemInstructions)
+    );
+  }
+  setSpanAttribute(
+    span,
+    "gen_ai.input.messages",
+    safeJsonStringify(inputMessages)
+  );
+  setSpanAttribute(span, "input.value", safeJsonStringify(messages));
+  if (tools && Object.keys(tools).length > 0) {
+    setSpanAttribute(
+      span,
+      "gen_ai.tool.definitions",
+      safeJsonStringify(
+        Object.entries(tools).map(([name, definition]) => ({
+          type: "function",
+          name,
+          description: definition.description,
+          parameters: zodSchemaToJsonSchema(definition.parameters)
+        }))
+      )
+    );
+  }
+}
+function setChatOutputAttributes(span, result) {
+  const parts = serializeAssistantContentParts(result.parts);
+  setSpanAttribute(
+    span,
+    "gen_ai.output.messages",
+    safeJsonStringify([
+      {
+        role: "assistant",
+        parts,
+        finish_reason: result.finishReason
+      }
+    ])
+  );
+  const outputValue = result.content ?? (parts.length > 0 ? safeJsonStringify(parts) : void 0);
+  setSpanAttribute(
+    span,
+    "output.value",
+    outputValue === null ? void 0 : outputValue
+  );
+}
+function setObjectOutputAttributes(span, result) {
+  if (result.object === void 0) {
+    return;
+  }
+  const objectContent = safeJsonStringify(result.object);
+  if (!objectContent) {
+    return;
+  }
+  setSpanAttribute(
+    span,
+    "gen_ai.output.messages",
+    safeJsonStringify([
+      {
+        role: "assistant",
+        parts: [
+          {
+            type: "text",
+            content: objectContent
+          }
+        ],
+        finish_reason: result.finishReason
+      }
+    ])
+  );
+  span.setAttribute("output.value", objectContent);
+}
+function setEmbedInputAttributes(span, input) {
+  setSpanAttribute(
+    span,
+    "input.value",
+    typeof input === "string" ? input : safeJsonStringify(input)
+  );
+}
+function setImageInputAttributes(span, prompt) {
+  span.setAttribute("input.value", prompt);
+}
+function setChatUsageAttributes(span, usage) {
+  span.setAttribute("gen_ai.usage.input_tokens", usage.inputTokens);
+  span.setAttribute("gen_ai.usage.output_tokens", usage.outputTokens);
+  span.setAttribute(
+    "gen_ai.usage.cache_read.input_tokens",
+    usage.inputTokenDetails.cacheReadTokens
+  );
+  span.setAttribute(
+    "gen_ai.usage.cache_creation.input_tokens",
+    usage.inputTokenDetails.cacheWriteTokens
+  );
+}
+function setEmbedUsageAttributes(span, usage) {
+  if (!usage) {
+    return;
+  }
+  span.setAttribute("gen_ai.usage.input_tokens", usage.inputTokens);
+}
+function setFinishReasonAttribute(span, finishReason) {
+  span.setAttribute("gen_ai.response.finish_reasons", [finishReason]);
+}
+function setChatRequestAttributes(span, model, options, outputType) {
+  span.setAttribute("gen_ai.provider.name", model.provider);
+  span.setAttribute("gen_ai.request.model", model.modelId);
+  span.setAttribute("gen_ai.operation.name", "chat");
+  span.setAttribute("gen_ai.output.type", outputType);
+  setSpanAttribute(
+    span,
+    "gen_ai.request.temperature",
+    options.temperature
+  );
+  setSpanAttribute(span, "gen_ai.request.max_tokens", options.maxTokens);
+  setSpanAttribute(span, "gen_ai.request.top_p", options.topP);
+  if ("schemaName" in options) {
+    setSpanAttribute(
+      span,
+      "gen_ai.request.schema_name",
+      options.schemaName
+    );
+  }
+  setMetadataAttributes(span, options.metadata);
+}
+function setEmbedRequestAttributes(span, model, options) {
+  span.setAttribute("gen_ai.provider.name", model.provider);
+  span.setAttribute("gen_ai.request.model", model.modelId);
+  span.setAttribute("gen_ai.operation.name", "embeddings");
+  setMetadataAttributes(span, options.metadata);
+}
+function setImageRequestAttributes(span, model, options) {
+  span.setAttribute("gen_ai.provider.name", model.provider);
+  span.setAttribute("gen_ai.request.model", model.modelId);
+  span.setAttribute("gen_ai.operation.name", "image_generation");
+  span.setAttribute("gen_ai.output.type", "image");
+  setMetadataAttributes(span, options.metadata);
+}
+function createChatSpanName(model) {
+  return `chat ${model.modelId}`;
+}
+function createEmbedSpanName(model) {
+  return `embeddings ${model.modelId}`;
+}
+function createImageSpanName(model) {
+  return `image_generation ${model.modelId}`;
+}
+
+// src/index.ts
+function getErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+function toError(error) {
+  if (error instanceof Error) {
+    return error;
+  }
+  return new Error(String(error));
+}
+function recordError(span, error) {
+  span.setAttribute("error.type", error instanceof Error ? error.name : "_OTHER");
+  span.setStatus({
+    code: SpanStatusCode.ERROR,
+    message: getErrorMessage(error)
+  });
+  span.recordException(toError(error));
+}
+function createOtelMiddleware(options = {}) {
+  const { recordContent = false, tracerName = "core-ai" } = options;
+  return {
+    generate: async ({ execute, options: generateOptions, model }) => {
+      const tracer = trace.getTracer(tracerName);
+      return tracer.startActiveSpan(
+        createChatSpanName(model),
+        {
+          kind: SpanKind.CLIENT
+        },
+        async (span) => {
+          setChatRequestAttributes(span, model, generateOptions, "text");
+          if (recordContent) {
+            setChatInputAttributes(
+              span,
+              generateOptions.messages,
+              generateOptions.tools
+            );
+          }
+          try {
+            const result = await execute();
+            setChatUsageAttributes(span, result.usage);
+            setFinishReasonAttribute(span, result.finishReason);
+            if (recordContent) {
+              setChatOutputAttributes(span, result);
+            }
+            span.setStatus({
+              code: SpanStatusCode.OK
+            });
+            return result;
+          } catch (error) {
+            recordError(span, error);
+            throw error;
+          } finally {
+            span.end();
+          }
+        }
+      );
+    },
+    stream: async ({ execute, options: generateOptions, model }) => {
+      const tracer = trace.getTracer(tracerName);
+      return tracer.startActiveSpan(
+        createChatSpanName(model),
+        {
+          kind: SpanKind.CLIENT
+        },
+        async (span) => {
+          setChatRequestAttributes(span, model, generateOptions, "text");
+          if (recordContent) {
+            setChatInputAttributes(
+              span,
+              generateOptions.messages,
+              generateOptions.tools
+            );
+          }
+          try {
+            const chatStream = await execute();
+            void chatStream.result.then((result) => {
+              setChatUsageAttributes(span, result.usage);
+              setFinishReasonAttribute(span, result.finishReason);
+              if (recordContent) {
+                setChatOutputAttributes(span, result);
+              }
+              span.setStatus({
+                code: SpanStatusCode.OK
+              });
+            }).catch((error) => {
+              recordError(span, error);
+            }).finally(() => {
+              span.end();
+            });
+            return chatStream;
+          } catch (error) {
+            recordError(span, error);
+            span.end();
+            throw error;
+          }
+        }
+      );
+    },
+    generateObject: async (args) => {
+      const { execute, options: generateOptions, model } = args;
+      const tracer = trace.getTracer(tracerName);
+      return tracer.startActiveSpan(
+        createChatSpanName(model),
+        {
+          kind: SpanKind.CLIENT
+        },
+        async (span) => {
+          setChatRequestAttributes(span, model, generateOptions, "json");
+          if (recordContent) {
+            setChatInputAttributes(span, generateOptions.messages);
+          }
+          try {
+            const result = await execute();
+            setChatUsageAttributes(span, result.usage);
+            setFinishReasonAttribute(span, result.finishReason);
+            if (recordContent) {
+              setObjectOutputAttributes(span, result);
+            }
+            span.setStatus({
+              code: SpanStatusCode.OK
+            });
+            return result;
+          } catch (error) {
+            recordError(span, error);
+            throw error;
+          } finally {
+            span.end();
+          }
+        }
+      );
+    },
+    streamObject: async (args) => {
+      const { execute, options: generateOptions, model } = args;
+      const tracer = trace.getTracer(tracerName);
+      return tracer.startActiveSpan(
+        createChatSpanName(model),
+        {
+          kind: SpanKind.CLIENT
+        },
+        async (span) => {
+          setChatRequestAttributes(span, model, generateOptions, "json");
+          if (recordContent) {
+            setChatInputAttributes(span, generateOptions.messages);
+          }
+          try {
+            const objectStream = await execute();
+            void objectStream.result.then((result) => {
+              setChatUsageAttributes(span, result.usage);
+              setFinishReasonAttribute(span, result.finishReason);
+              if (recordContent) {
+                setObjectOutputAttributes(span, result);
+              }
+              span.setStatus({
+                code: SpanStatusCode.OK
+              });
+            }).catch((error) => {
+              recordError(span, error);
+            }).finally(() => {
+              span.end();
+            });
+            return objectStream;
+          } catch (error) {
+            recordError(span, error);
+            span.end();
+            throw error;
+          }
+        }
+      );
+    }
+  };
+}
+function createOtelEmbeddingMiddleware(options = {}) {
+  const { recordContent = false, tracerName = "core-ai" } = options;
+  return {
+    embed: async ({ execute, options: embedOptions, model }) => {
+      const tracer = trace.getTracer(tracerName);
+      return tracer.startActiveSpan(
+        createEmbedSpanName(model),
+        {
+          kind: SpanKind.CLIENT
+        },
+        async (span) => {
+          setEmbedRequestAttributes(span, model, embedOptions);
+          if (recordContent) {
+            setEmbedInputAttributes(span, embedOptions.input);
+          }
+          try {
+            const result = await execute();
+            setEmbedUsageAttributes(span, result.usage);
+            span.setStatus({
+              code: SpanStatusCode.OK
+            });
+            return result;
+          } catch (error) {
+            recordError(span, error);
+            throw error;
+          } finally {
+            span.end();
+          }
+        }
+      );
+    }
+  };
+}
+function createOtelImageMiddleware(options = {}) {
+  const { recordContent = false, tracerName = "core-ai" } = options;
+  return {
+    generate: async ({ execute, options: imageOptions, model }) => {
+      const tracer = trace.getTracer(tracerName);
+      return tracer.startActiveSpan(
+        createImageSpanName(model),
+        {
+          kind: SpanKind.CLIENT
+        },
+        async (span) => {
+          setImageRequestAttributes(span, model, imageOptions);
+          if (recordContent) {
+            setImageInputAttributes(span, imageOptions.prompt);
+          }
+          try {
+            const result = await execute();
+            span.setStatus({
+              code: SpanStatusCode.OK
+            });
+            return result;
+          } catch (error) {
+            recordError(span, error);
+            throw error;
+          } finally {
+            span.end();
+          }
+        }
+      );
+    }
+  };
+}
+export {
+  createOtelEmbeddingMiddleware,
+  createOtelImageMiddleware,
+  createOtelMiddleware
+};

package/package.json

@@ -0,0 +1,60 @@
+{
+    "name": "@core-ai/opentelemetry",
+    "version": "0.10.0",
+    "description": "OpenTelemetry middleware for @core-ai/core-ai",
+    "license": "MIT",
+    "author": "Omnifact (https://omnifact.ai)",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/agdevhq/core-ai.git",
+        "directory": "packages/opentelemetry"
+    },
+    "keywords": [
+        "llm",
+        "ai",
+        "sdk",
+        "opentelemetry",
+        "observability"
+    ],
+    "type": "module",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
+        }
+    },
+    "files": [
+        "dist",
+        "README.md",
+        "LICENSE"
+    ],
+    "publishConfig": {
+        "access": "public",
+        "provenance": true
+    },
+    "scripts": {
+        "build": "tsup",
+        "lint": "eslint src/ --max-warnings 0",
+        "check-types": "tsc --noEmit",
+        "test": "vitest run",
+        "test:watch": "vitest"
+    },
+    "dependencies": {
+        "@core-ai/core-ai": "^0.10.0"
+    },
+    "peerDependencies": {
+        "@opentelemetry/api": "^1.9.1"
+    },
+    "devDependencies": {
+        "@core-ai/eslint-config": "*",
+        "@core-ai/typescript-config": "*",
+        "@opentelemetry/api": "^1.9.1",
+        "@opentelemetry/context-async-hooks": "^2.6.1",
+        "@opentelemetry/sdk-trace-base": "^2.6.1",
+        "typescript": "^5.7.3",
+        "vitest": "^3.2.4",
+        "zod": "^4.0.0"
+    }
+}