observeos 0.1.0

package/README.md

@@ -0,0 +1,116 @@
+# observeos
+
+**Zero-config LLM observability SDK.** Automatically trace your OpenAI, Anthropic, Ollama, and Hugging Face API calls. Calculate costs, measure latency, detect errors.
+
+## Features
+
+- Zero-config drop-in wrappers for OpenAI, Anthropic, Ollama, Hugging Face
+- Automatic token cost calculation
+- Batch trace export (non-blocking)
+- Optional OpenTelemetry export
+- PII scrubbing (optional)
+- TypeScript-first (strict mode)
+- Minimal overhead (< 1ms per call)
+
+## Installation
+
+```bash
+npm install observeos
+```
+
+## Quick Start
+
+```typescript
+import OpenAI from 'openai'
+import { createObserveOS } from 'observeos'
+
+// Initialize once at app startup
+const obs = createObserveOS({
+  apiKey: process.env.OBSERVEOS_API_KEY!,
+  baseUrl: process.env.OBSERVEOS_BASE_URL!,
+  tenantId: 'my_org',
+})
+
+// Wrap your clients — drop-in replacements
+const openai = obs.wrapOpenAI(new OpenAI())
+
+// Use exactly as before — tracing is automatic
+const response = await openai.chat.completions.create({
+  model: 'gpt-4o',
+  messages: [{ role: 'user', content: 'Hello!' }],
+})
+```
+
+Every call is now traced and sent to your observability backend automatically.
+
+## Configuration
+
+```typescript
+createObserveOS({
+  apiKey: string,                  // required: your API key
+  baseUrl: string,                 // optional: worker URL (default: http://localhost:8787)
+  tenantId: string,                // optional: tenant identifier (default: 'default')
+  environment: 'production',       // optional: environment name
+  enabled: true,                   // optional: disable tracing without code changes
+  sampleRate: 1,                   // optional: trace 100% of calls (0-1)
+  capturePromptPreview: true,      // optional: capture first 200 chars of prompt
+  captureResponsePreview: true,    // optional: capture first 200 chars of response
+  piiScrubbing: false,             // optional: mask PII before sending
+  flushInterval: 5000,             // optional: ms between batch flushes
+  maxBatchSize: 50,                // optional: traces per batch
+  otelEndpoint: undefined,         // optional: OTEL collector endpoint
+  debug: false,                    // optional: log SDK activity
+})
+```
+
+## Supported Providers
+
+### OpenAI
+
+```typescript
+import OpenAI from 'openai'
+const openai = obs.wrapOpenAI(new OpenAI())
+```
+
+### Anthropic
+
+```typescript
+import Anthropic from '@anthropic-ai/sdk'
+const anthropic = obs.wrapAnthropic(new Anthropic())
+```
+
+### Ollama
+
+```typescript
+const fetchWithTracing = obs.wrapOllama(fetch)
+const response = await fetchWithTracing('http://localhost:11434/api/chat', {
+  method: 'POST',
+  body: JSON.stringify({ model: 'llama3', messages: [] }),
+})
+```
+
+### Hugging Face
+
+```typescript
+import { HfInference } from '@huggingface/inference'
+const hf = obs.wrapHuggingFace(new HfInference())
+```
+
+## Graceful Shutdown
+
+Flush pending traces before exiting:
+
+```typescript
+process.on('SIGTERM', async () => {
+  await obs.tracer.shutdown()
+  process.exit(0)
+})
+```
+
+## Pricing
+
+Cost is calculated automatically using current provider pricing. See `MODEL_PRICING` for details.
+
+## License
+
+MIT

package/dist/index.d.cts

@@ -0,0 +1,98 @@
+import * as Anthropic from '@anthropic-ai/sdk';
+import Anthropic__default from '@anthropic-ai/sdk';
+import * as OpenAI from 'openai';
+import OpenAI__default from 'openai';
+
+type LLMProvider = 'openai' | 'anthropic' | 'ollama' | 'huggingface';
+type FinishReason = 'stop' | 'length' | 'tool_calls' | 'error' | 'content_filter' | string;
+interface LLMTrace {
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+    tenantId: string;
+    provider: LLMProvider;
+    model: string;
+    promptHash: string;
+    promptPreview?: string;
+    promptTokens?: number;
+    completionTokens?: number;
+    totalTokens?: number;
+    responsePreview?: string;
+    finishReason?: FinishReason;
+    latencyMs: number;
+    ttfbMs?: number;
+    costUsd?: number;
+    error: boolean;
+    errorMessage?: string;
+    statusCode?: number;
+    tags: Record<string, string>;
+    metadata: Record<string, unknown>;
+    environment: string;
+    createdAt: Date;
+}
+interface ObserveOSConfig {
+    apiKey: string;
+    baseUrl?: string;
+    tenantId?: string;
+    environment?: string;
+    enabled?: boolean;
+    sampleRate?: number;
+    capturePromptPreview?: boolean;
+    captureResponsePreview?: boolean;
+    piiScrubbing?: boolean;
+    flushInterval?: number;
+    maxBatchSize?: number;
+    otelEndpoint?: string;
+    debug?: boolean;
+}
+type TraceInput = Omit<LLMTrace, 'traceId' | 'spanId' | 'createdAt'>;
+
+declare class ObserveOSTracer {
+    readonly config: Required<ObserveOSConfig>;
+    private readonly exporter;
+    private queue;
+    private flushTimer;
+    private flushing;
+    constructor(config: ObserveOSConfig);
+    record(input: TraceInput): Promise<void>;
+    flush(): Promise<void>;
+    shutdown(): Promise<void>;
+    private startFlushTimer;
+}
+
+declare class Exporter {
+    private config;
+    constructor(config: Required<ObserveOSConfig>);
+    export(traces: LLMTrace[]): Promise<void>;
+    private sendToWorker;
+    private sendToOtel;
+}
+
+declare function wrapOpenAI<T extends OpenAI__default>(client: T, tracer: ObserveOSTracer): T;
+
+declare function wrapAnthropic<T extends Anthropic__default>(client: T, tracer: ObserveOSTracer): T;
+
+declare function wrapOllama(fetchFn: typeof fetch, tracer: ObserveOSTracer): typeof fetch;
+
+declare function wrapHuggingFace<T extends object>(client: T, tracer: ObserveOSTracer): T;
+
+declare function hashPrompt(prompt: string): string;
+
+interface ModelPricing {
+    input: number;
+    output: number;
+}
+declare const MODEL_PRICING: Record<string, ModelPricing>;
+declare function calculateCost(model: string, inputTokens: number, outputTokens: number): number;
+declare function getModelPricing(model: string): ModelPricing | undefined;
+
+interface ObserveOSInstance {
+    tracer: ObserveOSTracer;
+    wrapOpenAI: <T extends OpenAI.default>(client: T) => T;
+    wrapAnthropic: <T extends Anthropic.default>(client: T) => T;
+    wrapOllama: (fetchFn: typeof fetch) => typeof fetch;
+    wrapHuggingFace: <T extends object>(client: T) => T;
+}
+declare function createObserveOS(config: ObserveOSConfig): ObserveOSInstance;
+
+export { Exporter, type FinishReason, type LLMProvider, type LLMTrace, MODEL_PRICING, type ObserveOSConfig, type ObserveOSInstance, ObserveOSTracer, type TraceInput, calculateCost, createObserveOS, getModelPricing, hashPrompt, wrapAnthropic, wrapHuggingFace, wrapOllama, wrapOpenAI };

package/dist/index.d.ts

@@ -0,0 +1,98 @@
+import * as Anthropic from '@anthropic-ai/sdk';
+import Anthropic__default from '@anthropic-ai/sdk';
+import * as OpenAI from 'openai';
+import OpenAI__default from 'openai';
+
+type LLMProvider = 'openai' | 'anthropic' | 'ollama' | 'huggingface';
+type FinishReason = 'stop' | 'length' | 'tool_calls' | 'error' | 'content_filter' | string;
+interface LLMTrace {
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+    tenantId: string;
+    provider: LLMProvider;
+    model: string;
+    promptHash: string;
+    promptPreview?: string;
+    promptTokens?: number;
+    completionTokens?: number;
+    totalTokens?: number;
+    responsePreview?: string;
+    finishReason?: FinishReason;
+    latencyMs: number;
+    ttfbMs?: number;
+    costUsd?: number;
+    error: boolean;
+    errorMessage?: string;
+    statusCode?: number;
+    tags: Record<string, string>;
+    metadata: Record<string, unknown>;
+    environment: string;
+    createdAt: Date;
+}
+interface ObserveOSConfig {
+    apiKey: string;
+    baseUrl?: string;
+    tenantId?: string;
+    environment?: string;
+    enabled?: boolean;
+    sampleRate?: number;
+    capturePromptPreview?: boolean;
+    captureResponsePreview?: boolean;
+    piiScrubbing?: boolean;
+    flushInterval?: number;
+    maxBatchSize?: number;
+    otelEndpoint?: string;
+    debug?: boolean;
+}
+type TraceInput = Omit<LLMTrace, 'traceId' | 'spanId' | 'createdAt'>;
+
+declare class ObserveOSTracer {
+    readonly config: Required<ObserveOSConfig>;
+    private readonly exporter;
+    private queue;
+    private flushTimer;
+    private flushing;
+    constructor(config: ObserveOSConfig);
+    record(input: TraceInput): Promise<void>;
+    flush(): Promise<void>;
+    shutdown(): Promise<void>;
+    private startFlushTimer;
+}
+
+declare class Exporter {
+    private config;
+    constructor(config: Required<ObserveOSConfig>);
+    export(traces: LLMTrace[]): Promise<void>;
+    private sendToWorker;
+    private sendToOtel;
+}
+
+declare function wrapOpenAI<T extends OpenAI__default>(client: T, tracer: ObserveOSTracer): T;
+
+declare function wrapAnthropic<T extends Anthropic__default>(client: T, tracer: ObserveOSTracer): T;
+
+declare function wrapOllama(fetchFn: typeof fetch, tracer: ObserveOSTracer): typeof fetch;
+
+declare function wrapHuggingFace<T extends object>(client: T, tracer: ObserveOSTracer): T;
+
+declare function hashPrompt(prompt: string): string;
+
+interface ModelPricing {
+    input: number;
+    output: number;
+}
+declare const MODEL_PRICING: Record<string, ModelPricing>;
+declare function calculateCost(model: string, inputTokens: number, outputTokens: number): number;
+declare function getModelPricing(model: string): ModelPricing | undefined;
+
+interface ObserveOSInstance {
+    tracer: ObserveOSTracer;
+    wrapOpenAI: <T extends OpenAI.default>(client: T) => T;
+    wrapAnthropic: <T extends Anthropic.default>(client: T) => T;
+    wrapOllama: (fetchFn: typeof fetch) => typeof fetch;
+    wrapHuggingFace: <T extends object>(client: T) => T;
+}
+declare function createObserveOS(config: ObserveOSConfig): ObserveOSInstance;
+
+export { Exporter, type FinishReason, type LLMProvider, type LLMTrace, MODEL_PRICING, type ObserveOSConfig, type ObserveOSInstance, ObserveOSTracer, type TraceInput, calculateCost, createObserveOS, getModelPricing, hashPrompt, wrapAnthropic, wrapHuggingFace, wrapOllama, wrapOpenAI };

package/dist/index.js

@@ -0,0 +1,487 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Exporter: () => Exporter,
+  MODEL_PRICING: () => MODEL_PRICING,
+  ObserveOSTracer: () => ObserveOSTracer,
+  calculateCost: () => calculateCost,
+  createObserveOS: () => createObserveOS,
+  getModelPricing: () => getModelPricing,
+  hashPrompt: () => hashPrompt,
+  wrapAnthropic: () => wrapAnthropic,
+  wrapHuggingFace: () => wrapHuggingFace,
+  wrapOllama: () => wrapOllama,
+  wrapOpenAI: () => wrapOpenAI
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/tracer.ts
+var import_crypto = require("crypto");
+
+// src/core/exporter.ts
+var Exporter = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async export(traces) {
+    await this.sendToWorker(traces);
+    if (this.config.otelEndpoint) {
+      await this.sendToOtel(traces).catch((err) => {
+        if (this.config.debug) console.error("[ObserveOS] OTEL export failed:", err.message);
+      });
+    }
+  }
+  async sendToWorker(traces) {
+    const payload = traces.map((t) => ({
+      ...t,
+      createdAt: t.createdAt.toISOString()
+    }));
+    const res = await fetch(`${this.config.baseUrl}/v1/traces`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.config.apiKey}`,
+        "X-Tenant-Id": this.config.tenantId
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "unknown error");
+      if (this.config.debug) {
+        console.error(`[ObserveOS] Ingestion failed: ${res.status} ${text}`);
+      }
+    } else if (this.config.debug) {
+      console.log(`[ObserveOS] Flushed ${traces.length} traces`);
+    }
+  }
+  async sendToOtel(traces) {
+    const spans = traces.map((t) => ({
+      traceId: t.traceId,
+      spanId: t.spanId,
+      parentSpanId: t.parentSpanId,
+      name: `${t.provider}.chat`,
+      kind: 3,
+      // CLIENT
+      startTimeUnixNano: (t.createdAt.getTime() - t.latencyMs) * 1e6,
+      endTimeUnixNano: t.createdAt.getTime() * 1e6,
+      attributes: [
+        { key: "gen_ai.system", value: { stringValue: t.provider } },
+        { key: "gen_ai.request.model", value: { stringValue: t.model } },
+        { key: "gen_ai.usage.input_tokens", value: { intValue: t.promptTokens ?? 0 } },
+        { key: "gen_ai.usage.output_tokens", value: { intValue: t.completionTokens ?? 0 } },
+        { key: "observeos.cost_usd", value: { doubleValue: t.costUsd ?? 0 } },
+        { key: "observeos.tenant_id", value: { stringValue: t.tenantId } },
+        { key: "observeos.prompt_hash", value: { stringValue: t.promptHash } },
+        { key: "error", value: { boolValue: t.error } }
+      ],
+      status: t.error ? { code: 2 } : { code: 1 }
+    }));
+    await fetch(`${this.config.otelEndpoint}/v1/traces`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ resourceSpans: [{ scopeSpans: [{ spans }] }] })
+    });
+  }
+};
+
+// src/core/tracer.ts
+var DEFAULTS = {
+  apiKey: "",
+  baseUrl: "http://localhost:8787",
+  tenantId: "default",
+  environment: "production",
+  enabled: true,
+  sampleRate: 1,
+  capturePromptPreview: true,
+  captureResponsePreview: true,
+  piiScrubbing: false,
+  flushInterval: 5e3,
+  maxBatchSize: 50,
+  otelEndpoint: "",
+  debug: false
+};
+var ObserveOSTracer = class {
+  config;
+  exporter;
+  queue = [];
+  flushTimer = null;
+  flushing = false;
+  constructor(config) {
+    this.config = { ...DEFAULTS, ...config };
+    this.exporter = new Exporter(this.config);
+    this.startFlushTimer();
+  }
+  async record(input) {
+    if (!this.config.enabled) return;
+    if (Math.random() > this.config.sampleRate) return;
+    const trace = {
+      ...input,
+      traceId: (0, import_crypto.randomUUID)().replace(/-/g, ""),
+      spanId: (0, import_crypto.randomUUID)().replace(/-/g, "").slice(0, 16),
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    this.queue.push(trace);
+    if (this.config.debug) {
+      console.log(`[ObserveOS] Queued trace: ${trace.provider}/${trace.model} (${input.latencyMs}ms)`);
+    }
+    if (this.queue.length >= this.config.maxBatchSize) {
+      this.flush().catch((err) => {
+        if (this.config.debug) console.error("[ObserveOS] Flush error:", err.message);
+      });
+    }
+  }
+  async flush() {
+    if (this.flushing || this.queue.length === 0) return;
+    this.flushing = true;
+    const batch = this.queue.splice(0);
+    try {
+      await this.exporter.export(batch);
+    } finally {
+      this.flushing = false;
+    }
+  }
+  async shutdown() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    await this.flush();
+  }
+  startFlushTimer() {
+    this.flushTimer = setInterval(() => {
+      this.flush().catch(() => {
+      });
+    }, this.config.flushInterval);
+    if (this.flushTimer.unref) this.flushTimer.unref();
+  }
+};
+
+// src/utils/hash.ts
+var import_crypto2 = require("crypto");
+function hashPrompt(prompt) {
+  const normalized = prompt.trim().toLowerCase().replace(/\s+/g, " ");
+  return (0, import_crypto2.createHash)("sha256").update(normalized, "utf8").digest("hex");
+}
+
+// src/utils/cost.ts
+var MODEL_PRICING = {
+  // OpenAI
+  "gpt-4o": { input: 2.5, output: 10 },
+  "gpt-4o-mini": { input: 0.15, output: 0.6 },
+  "gpt-4o-2024-11-20": { input: 2.5, output: 10 },
+  "gpt-4-turbo": { input: 10, output: 30 },
+  "gpt-4-turbo-preview": { input: 10, output: 30 },
+  "gpt-3.5-turbo": { input: 0.5, output: 1.5 },
+  "gpt-3.5-turbo-0125": { input: 0.5, output: 1.5 },
+  "o1": { input: 15, output: 60 },
+  "o1-mini": { input: 3, output: 12 },
+  "o3-mini": { input: 1.1, output: 4.4 },
+  // Anthropic
+  "claude-3-5-sonnet-20241022": { input: 3, output: 15 },
+  "claude-3-5-haiku-20241022": { input: 0.8, output: 4 },
+  "claude-3-opus-20240229": { input: 15, output: 75 },
+  "claude-3-sonnet-20240229": { input: 3, output: 15 },
+  "claude-3-haiku-20240307": { input: 0.25, output: 1.25 },
+  // Ollama (self-hosted — always $0)
+  "llama3": { input: 0, output: 0 },
+  "llama3.1": { input: 0, output: 0 },
+  "llama3.2": { input: 0, output: 0 },
+  "mistral": { input: 0, output: 0 },
+  "mixtral": { input: 0, output: 0 },
+  "phi3": { input: 0, output: 0 },
+  "gemma2": { input: 0, output: 0 },
+  "qwen2": { input: 0, output: 0 }
+};
+function calculateCost(model, inputTokens, outputTokens) {
+  const pricing = MODEL_PRICING[model];
+  if (!pricing) return 0;
+  const inputCost = inputTokens / 1e6 * pricing.input;
+  const outputCost = outputTokens / 1e6 * pricing.output;
+  return parseFloat((inputCost + outputCost).toFixed(8));
+}
+function getModelPricing(model) {
+  return MODEL_PRICING[model];
+}
+
+// src/utils/sanitize.ts
+var EMAIL_REGEX = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g;
+var PHONE_REGEX = /(\+?1?\s?)?(\(?\d{3}\)?[\s.-]?)?\d{3}[\s.-]?\d{4}/g;
+var SSN_REGEX = /\b\d{3}-\d{2}-\d{4}\b/g;
+var CREDIT_REGEX = /\b(?:\d[ -]?){13,16}\b/g;
+var IP_REGEX = /\b(?:\d{1,3}\.){3}\d{1,3}\b/g;
+function scrubPII(text) {
+  return text.replace(EMAIL_REGEX, "[EMAIL]").replace(PHONE_REGEX, "[PHONE]").replace(SSN_REGEX, "[SSN]").replace(CREDIT_REGEX, "[CARD]").replace(IP_REGEX, "[IP]");
+}
+
+// src/providers/openai.ts
+function wrapOpenAI(client, tracer) {
+  const original = client.chat.completions.create.bind(client.chat.completions);
+  client.chat.completions.create = async function(params, options) {
+    if (params.stream) {
+      return original(params, options);
+    }
+    const startMs = Date.now();
+    const rawPrompt = (params.messages ?? []).map((m) => typeof m.content === "string" ? m.content : JSON.stringify(m.content)).join("\n");
+    const prompt = tracer.config.piiScrubbing ? scrubPII(rawPrompt) : rawPrompt;
+    try {
+      const response = await original(params, options);
+      const latencyMs = Date.now() - startMs;
+      const res = response;
+      const usage = res.usage;
+      const promptTokens = usage?.prompt_tokens;
+      const completionTokens = usage?.completion_tokens;
+      const totalTokens = usage?.total_tokens;
+      const costUsd = promptTokens != null && completionTokens != null ? calculateCost(params.model, promptTokens, completionTokens) : void 0;
+      let responseText = res.choices?.[0]?.message?.content ?? "";
+      if (tracer.config.piiScrubbing) responseText = scrubPII(responseText);
+      await tracer.record({
+        tenantId: tracer.config.tenantId,
+        provider: "openai",
+        model: params.model,
+        promptHash: hashPrompt(rawPrompt),
+        promptPreview: tracer.config.capturePromptPreview ? prompt.slice(0, 200) : void 0,
+        promptTokens,
+        completionTokens,
+        totalTokens,
+        responsePreview: tracer.config.captureResponsePreview ? responseText.slice(0, 200) : void 0,
+        finishReason: res.choices?.[0]?.finish_reason,
+        latencyMs,
+        costUsd,
+        error: false,
+        tags: {},
+        metadata: {},
+        environment: tracer.config.environment
+      });
+      return response;
+    } catch (err) {
+      await tracer.record({
+        tenantId: tracer.config.tenantId,
+        provider: "openai",
+        model: params.model,
+        promptHash: hashPrompt(rawPrompt),
+        latencyMs: Date.now() - startMs,
+        error: true,
+        errorMessage: err.message,
+        statusCode: err.status,
+        tags: {},
+        metadata: {},
+        environment: tracer.config.environment
+      });
+      throw err;
+    }
+  };
+  return client;
+}
+
+// src/providers/anthropic.ts
+function wrapAnthropic(client, tracer) {
+  const original = client.messages.create.bind(client.messages);
+  client.messages.create = async function(params, options) {
+    if (params.stream) return original(params, options);
+    const startMs = Date.now();
+    const rawPrompt = (params.messages ?? []).map((m) => typeof m.content === "string" ? m.content : JSON.stringify(m.content)).join("\n");
+    const prompt = tracer.config.piiScrubbing ? scrubPII(rawPrompt) : rawPrompt;
+    try {
+      const response = await original(params, options);
+      const latencyMs = Date.now() - startMs;
+      const res = response;
+      const usage = res.usage;
+      const promptTokens = usage?.input_tokens;
+      const completionTokens = usage?.output_tokens;
+      const totalTokens = (promptTokens ?? 0) + (completionTokens ?? 0);
+      const costUsd = promptTokens != null && completionTokens != null ? calculateCost(params.model, promptTokens, completionTokens) : void 0;
+      const rawResponse = res.content?.filter((b) => b.type === "text").map((b) => b.text).join("") ?? "";
+      const responseText = tracer.config.piiScrubbing ? scrubPII(rawResponse) : rawResponse;
+      await tracer.record({
+        tenantId: tracer.config.tenantId,
+        provider: "anthropic",
+        model: params.model,
+        promptHash: hashPrompt(rawPrompt),
+        promptPreview: tracer.config.capturePromptPreview ? prompt.slice(0, 200) : void 0,
+        promptTokens,
+        completionTokens,
+        totalTokens,
+        responsePreview: tracer.config.captureResponsePreview ? responseText.slice(0, 200) : void 0,
+        finishReason: res.stop_reason,
+        latencyMs,
+        costUsd,
+        error: false,
+        tags: {},
+        metadata: {},
+        environment: tracer.config.environment
+      });
+      return response;
+    } catch (err) {
+      await tracer.record({
+        tenantId: tracer.config.tenantId,
+        provider: "anthropic",
+        model: params.model,
+        promptHash: hashPrompt(rawPrompt),
+        latencyMs: Date.now() - startMs,
+        error: true,
+        errorMessage: err.message,
+        statusCode: err.status,
+        tags: {},
+        metadata: {},
+        environment: tracer.config.environment
+      });
+      throw err;
+    }
+  };
+  return client;
+}
+
+// src/providers/ollama.ts
+function wrapOllama(fetchFn, tracer) {
+  return async function wrappedFetch(input, init) {
+    const url = input.toString();
+    const isOllamaChat = url.includes("/api/chat") || url.includes("/api/generate");
+    if (!isOllamaChat) return fetchFn(input, init);
+    const startMs = Date.now();
+    let body = {};
+    try {
+      body = JSON.parse(init?.body ?? "{}");
+    } catch {
+    }
+    const rawPrompt = (body.messages ?? []).map((m) => typeof m.content === "string" ? m.content : JSON.stringify(m.content)).join("\n") || body.prompt || "";
+    try {
+      const response = await fetchFn(input, init);
+      const latencyMs = Date.now() - startMs;
+      const cloned = response.clone();
+      let data = {};
+      try {
+        data = await cloned.json();
+      } catch {
+      }
+      const promptTokens = data.prompt_eval_count;
+      const completionTokens = data.eval_count;
+      const totalTokens = (promptTokens ?? 0) + (completionTokens ?? 0);
+      await tracer.record({
+        tenantId: tracer.config.tenantId,
+        provider: "ollama",
+        model: body.model ?? "unknown",
+        promptHash: hashPrompt(rawPrompt),
+        promptPreview: tracer.config.capturePromptPreview ? rawPrompt.slice(0, 200) : void 0,
+        promptTokens,
+        completionTokens,
+        totalTokens,
+        responsePreview: tracer.config.captureResponsePreview ? (data.message?.content ?? data.response ?? "").slice(0, 200) : void 0,
+        finishReason: data.done ? "stop" : void 0,
+        latencyMs,
+        costUsd: 0,
+        error: false,
+        tags: {},
+        metadata: {},
+        environment: tracer.config.environment
+      });
+      return response;
+    } catch (err) {
+      await tracer.record({
+        tenantId: tracer.config.tenantId,
+        provider: "ollama",
+        model: body.model ?? "unknown",
+        promptHash: hashPrompt(rawPrompt),
+        latencyMs: Date.now() - startMs,
+        error: true,
+        errorMessage: err.message,
+        tags: {},
+        metadata: {},
+        environment: tracer.config.environment
+      });
+      throw err;
+    }
+  };
+}
+
+// src/providers/huggingface.ts
+function wrapHuggingFace(client, tracer) {
+  const methods = ["textGeneration", "chatCompletion", "textClassification", "summarization"];
+  for (const method of methods) {
+    const original = client[method]?.bind(client);
+    if (!original) continue;
+    client[method] = async function(params) {
+      const startMs = Date.now();
+      const rawPrompt = params.inputs ?? params.messages?.map((m) => m.content).join("\n") ?? "";
+      try {
+        const response = await original(params);
+        const latencyMs = Date.now() - startMs;
+        const responseText = response?.generated_text ?? response?.choices?.[0]?.message?.content ?? (Array.isArray(response) ? response[0]?.generated_text : "") ?? "";
+        await tracer.record({
+          tenantId: tracer.config.tenantId,
+          provider: "huggingface",
+          model: params.model ?? "unknown",
+          promptHash: hashPrompt(rawPrompt),
+          promptPreview: tracer.config.capturePromptPreview ? rawPrompt.slice(0, 200) : void 0,
+          responsePreview: tracer.config.captureResponsePreview ? String(responseText).slice(0, 200) : void 0,
+          latencyMs,
+          error: false,
+          tags: { hf_method: method },
+          metadata: {},
+          environment: tracer.config.environment
+        });
+        return response;
+      } catch (err) {
+        await tracer.record({
+          tenantId: tracer.config.tenantId,
+          provider: "huggingface",
+          model: params.model ?? "unknown",
+          promptHash: hashPrompt(rawPrompt),
+          latencyMs: Date.now() - startMs,
+          error: true,
+          errorMessage: err.message,
+          tags: { hf_method: method },
+          metadata: {},
+          environment: tracer.config.environment
+        });
+        throw err;
+      }
+    };
+  }
+  return client;
+}
+
+// src/index.ts
+function createObserveOS(config) {
+  const tracer = new ObserveOSTracer(config);
+  return {
+    tracer,
+    wrapOpenAI: (client) => wrapOpenAI(client, tracer),
+    wrapAnthropic: (client) => wrapAnthropic(client, tracer),
+    wrapOllama: (fetchFn) => wrapOllama(fetchFn, tracer),
+    wrapHuggingFace: (client) => wrapHuggingFace(client, tracer)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Exporter,
+  MODEL_PRICING,
+  ObserveOSTracer,
+  calculateCost,
+  createObserveOS,
+  getModelPricing,
+  hashPrompt,
+  wrapAnthropic,
+  wrapHuggingFace,
+  wrapOllama,
+  wrapOpenAI
+});

package/dist/index.mjs

@@ -0,0 +1,450 @@
+// src/core/tracer.ts
+import { randomUUID } from "crypto";
+
+// src/core/exporter.ts
+var Exporter = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async export(traces) {
+    await this.sendToWorker(traces);
+    if (this.config.otelEndpoint) {
+      await this.sendToOtel(traces).catch((err) => {
+        if (this.config.debug) console.error("[ObserveOS] OTEL export failed:", err.message);
+      });
+    }
+  }
+  async sendToWorker(traces) {
+    const payload = traces.map((t) => ({
+      ...t,
+      createdAt: t.createdAt.toISOString()
+    }));
+    const res = await fetch(`${this.config.baseUrl}/v1/traces`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.config.apiKey}`,
+        "X-Tenant-Id": this.config.tenantId
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "unknown error");
+      if (this.config.debug) {
+        console.error(`[ObserveOS] Ingestion failed: ${res.status} ${text}`);
+      }
+    } else if (this.config.debug) {
+      console.log(`[ObserveOS] Flushed ${traces.length} traces`);
+    }
+  }
+  async sendToOtel(traces) {
+    const spans = traces.map((t) => ({
+      traceId: t.traceId,
+      spanId: t.spanId,
+      parentSpanId: t.parentSpanId,
+      name: `${t.provider}.chat`,
+      kind: 3,
+      // CLIENT
+      startTimeUnixNano: (t.createdAt.getTime() - t.latencyMs) * 1e6,
+      endTimeUnixNano: t.createdAt.getTime() * 1e6,
+      attributes: [
+        { key: "gen_ai.system", value: { stringValue: t.provider } },
+        { key: "gen_ai.request.model", value: { stringValue: t.model } },
+        { key: "gen_ai.usage.input_tokens", value: { intValue: t.promptTokens ?? 0 } },
+        { key: "gen_ai.usage.output_tokens", value: { intValue: t.completionTokens ?? 0 } },
+        { key: "observeos.cost_usd", value: { doubleValue: t.costUsd ?? 0 } },
+        { key: "observeos.tenant_id", value: { stringValue: t.tenantId } },
+        { key: "observeos.prompt_hash", value: { stringValue: t.promptHash } },
+        { key: "error", value: { boolValue: t.error } }
+      ],
+      status: t.error ? { code: 2 } : { code: 1 }
+    }));
+    await fetch(`${this.config.otelEndpoint}/v1/traces`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ resourceSpans: [{ scopeSpans: [{ spans }] }] })
+    });
+  }
+};
+
+// src/core/tracer.ts
+var DEFAULTS = {
+  apiKey: "",
+  baseUrl: "http://localhost:8787",
+  tenantId: "default",
+  environment: "production",
+  enabled: true,
+  sampleRate: 1,
+  capturePromptPreview: true,
+  captureResponsePreview: true,
+  piiScrubbing: false,
+  flushInterval: 5e3,
+  maxBatchSize: 50,
+  otelEndpoint: "",
+  debug: false
+};
+var ObserveOSTracer = class {
+  config;
+  exporter;
+  queue = [];
+  flushTimer = null;
+  flushing = false;
+  constructor(config) {
+    this.config = { ...DEFAULTS, ...config };
+    this.exporter = new Exporter(this.config);
+    this.startFlushTimer();
+  }
+  async record(input) {
+    if (!this.config.enabled) return;
+    if (Math.random() > this.config.sampleRate) return;
+    const trace = {
+      ...input,
+      traceId: randomUUID().replace(/-/g, ""),
+      spanId: randomUUID().replace(/-/g, "").slice(0, 16),
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    this.queue.push(trace);
+    if (this.config.debug) {
+      console.log(`[ObserveOS] Queued trace: ${trace.provider}/${trace.model} (${input.latencyMs}ms)`);
+    }
+    if (this.queue.length >= this.config.maxBatchSize) {
+      this.flush().catch((err) => {
+        if (this.config.debug) console.error("[ObserveOS] Flush error:", err.message);
+      });
+    }
+  }
+  async flush() {
+    if (this.flushing || this.queue.length === 0) return;
+    this.flushing = true;
+    const batch = this.queue.splice(0);
+    try {
+      await this.exporter.export(batch);
+    } finally {
+      this.flushing = false;
+    }
+  }
+  async shutdown() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    await this.flush();
+  }
+  startFlushTimer() {
+    this.flushTimer = setInterval(() => {
+      this.flush().catch(() => {
+      });
+    }, this.config.flushInterval);
+    if (this.flushTimer.unref) this.flushTimer.unref();
+  }
+};
+
+// src/utils/hash.ts
+import { createHash } from "crypto";
+function hashPrompt(prompt) {
+  const normalized = prompt.trim().toLowerCase().replace(/\s+/g, " ");
+  return createHash("sha256").update(normalized, "utf8").digest("hex");
+}
+
+// src/utils/cost.ts
+var MODEL_PRICING = {
+  // OpenAI
+  "gpt-4o": { input: 2.5, output: 10 },
+  "gpt-4o-mini": { input: 0.15, output: 0.6 },
+  "gpt-4o-2024-11-20": { input: 2.5, output: 10 },
+  "gpt-4-turbo": { input: 10, output: 30 },
+  "gpt-4-turbo-preview": { input: 10, output: 30 },
+  "gpt-3.5-turbo": { input: 0.5, output: 1.5 },
+  "gpt-3.5-turbo-0125": { input: 0.5, output: 1.5 },
+  "o1": { input: 15, output: 60 },
+  "o1-mini": { input: 3, output: 12 },
+  "o3-mini": { input: 1.1, output: 4.4 },
+  // Anthropic
+  "claude-3-5-sonnet-20241022": { input: 3, output: 15 },
+  "claude-3-5-haiku-20241022": { input: 0.8, output: 4 },
+  "claude-3-opus-20240229": { input: 15, output: 75 },
+  "claude-3-sonnet-20240229": { input: 3, output: 15 },
+  "claude-3-haiku-20240307": { input: 0.25, output: 1.25 },
+  // Ollama (self-hosted — always $0)
+  "llama3": { input: 0, output: 0 },
+  "llama3.1": { input: 0, output: 0 },
+  "llama3.2": { input: 0, output: 0 },
+  "mistral": { input: 0, output: 0 },
+  "mixtral": { input: 0, output: 0 },
+  "phi3": { input: 0, output: 0 },
+  "gemma2": { input: 0, output: 0 },
+  "qwen2": { input: 0, output: 0 }
+};
+function calculateCost(model, inputTokens, outputTokens) {
+  const pricing = MODEL_PRICING[model];
+  if (!pricing) return 0;
+  const inputCost = inputTokens / 1e6 * pricing.input;
+  const outputCost = outputTokens / 1e6 * pricing.output;
+  return parseFloat((inputCost + outputCost).toFixed(8));
+}
+function getModelPricing(model) {
+  return MODEL_PRICING[model];
+}
+
+// src/utils/sanitize.ts
+var EMAIL_REGEX = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g;
+var PHONE_REGEX = /(\+?1?\s?)?(\(?\d{3}\)?[\s.-]?)?\d{3}[\s.-]?\d{4}/g;
+var SSN_REGEX = /\b\d{3}-\d{2}-\d{4}\b/g;
+var CREDIT_REGEX = /\b(?:\d[ -]?){13,16}\b/g;
+var IP_REGEX = /\b(?:\d{1,3}\.){3}\d{1,3}\b/g;
+function scrubPII(text) {
+  return text.replace(EMAIL_REGEX, "[EMAIL]").replace(PHONE_REGEX, "[PHONE]").replace(SSN_REGEX, "[SSN]").replace(CREDIT_REGEX, "[CARD]").replace(IP_REGEX, "[IP]");
+}
+
+// src/providers/openai.ts
+function wrapOpenAI(client, tracer) {
+  const original = client.chat.completions.create.bind(client.chat.completions);
+  client.chat.completions.create = async function(params, options) {
+    if (params.stream) {
+      return original(params, options);
+    }
+    const startMs = Date.now();
+    const rawPrompt = (params.messages ?? []).map((m) => typeof m.content === "string" ? m.content : JSON.stringify(m.content)).join("\n");
+    const prompt = tracer.config.piiScrubbing ? scrubPII(rawPrompt) : rawPrompt;
+    try {
+      const response = await original(params, options);
+      const latencyMs = Date.now() - startMs;
+      const res = response;
+      const usage = res.usage;
+      const promptTokens = usage?.prompt_tokens;
+      const completionTokens = usage?.completion_tokens;
+      const totalTokens = usage?.total_tokens;
+      const costUsd = promptTokens != null && completionTokens != null ? calculateCost(params.model, promptTokens, completionTokens) : void 0;
+      let responseText = res.choices?.[0]?.message?.content ?? "";
+      if (tracer.config.piiScrubbing) responseText = scrubPII(responseText);
+      await tracer.record({
+        tenantId: tracer.config.tenantId,
+        provider: "openai",
+        model: params.model,
+        promptHash: hashPrompt(rawPrompt),
+        promptPreview: tracer.config.capturePromptPreview ? prompt.slice(0, 200) : void 0,
+        promptTokens,
+        completionTokens,
+        totalTokens,
+        responsePreview: tracer.config.captureResponsePreview ? responseText.slice(0, 200) : void 0,
+        finishReason: res.choices?.[0]?.finish_reason,
+        latencyMs,
+        costUsd,
+        error: false,
+        tags: {},
+        metadata: {},
+        environment: tracer.config.environment
+      });
+      return response;
+    } catch (err) {
+      await tracer.record({
+        tenantId: tracer.config.tenantId,
+        provider: "openai",
+        model: params.model,
+        promptHash: hashPrompt(rawPrompt),
+        latencyMs: Date.now() - startMs,
+        error: true,
+        errorMessage: err.message,
+        statusCode: err.status,
+        tags: {},
+        metadata: {},
+        environment: tracer.config.environment
+      });
+      throw err;
+    }
+  };
+  return client;
+}
+
+// src/providers/anthropic.ts
+function wrapAnthropic(client, tracer) {
+  const original = client.messages.create.bind(client.messages);
+  client.messages.create = async function(params, options) {
+    if (params.stream) return original(params, options);
+    const startMs = Date.now();
+    const rawPrompt = (params.messages ?? []).map((m) => typeof m.content === "string" ? m.content : JSON.stringify(m.content)).join("\n");
+    const prompt = tracer.config.piiScrubbing ? scrubPII(rawPrompt) : rawPrompt;
+    try {
+      const response = await original(params, options);
+      const latencyMs = Date.now() - startMs;
+      const res = response;
+      const usage = res.usage;
+      const promptTokens = usage?.input_tokens;
+      const completionTokens = usage?.output_tokens;
+      const totalTokens = (promptTokens ?? 0) + (completionTokens ?? 0);
+      const costUsd = promptTokens != null && completionTokens != null ? calculateCost(params.model, promptTokens, completionTokens) : void 0;
+      const rawResponse = res.content?.filter((b) => b.type === "text").map((b) => b.text).join("") ?? "";
+      const responseText = tracer.config.piiScrubbing ? scrubPII(rawResponse) : rawResponse;
+      await tracer.record({
+        tenantId: tracer.config.tenantId,
+        provider: "anthropic",
+        model: params.model,
+        promptHash: hashPrompt(rawPrompt),
+        promptPreview: tracer.config.capturePromptPreview ? prompt.slice(0, 200) : void 0,
+        promptTokens,
+        completionTokens,
+        totalTokens,
+        responsePreview: tracer.config.captureResponsePreview ? responseText.slice(0, 200) : void 0,
+        finishReason: res.stop_reason,
+        latencyMs,
+        costUsd,
+        error: false,
+        tags: {},
+        metadata: {},
+        environment: tracer.config.environment
+      });
+      return response;
+    } catch (err) {
+      await tracer.record({
+        tenantId: tracer.config.tenantId,
+        provider: "anthropic",
+        model: params.model,
+        promptHash: hashPrompt(rawPrompt),
+        latencyMs: Date.now() - startMs,
+        error: true,
+        errorMessage: err.message,
+        statusCode: err.status,
+        tags: {},
+        metadata: {},
+        environment: tracer.config.environment
+      });
+      throw err;
+    }
+  };
+  return client;
+}
+
+// src/providers/ollama.ts
+function wrapOllama(fetchFn, tracer) {
+  return async function wrappedFetch(input, init) {
+    const url = input.toString();
+    const isOllamaChat = url.includes("/api/chat") || url.includes("/api/generate");
+    if (!isOllamaChat) return fetchFn(input, init);
+    const startMs = Date.now();
+    let body = {};
+    try {
+      body = JSON.parse(init?.body ?? "{}");
+    } catch {
+    }
+    const rawPrompt = (body.messages ?? []).map((m) => typeof m.content === "string" ? m.content : JSON.stringify(m.content)).join("\n") || body.prompt || "";
+    try {
+      const response = await fetchFn(input, init);
+      const latencyMs = Date.now() - startMs;
+      const cloned = response.clone();
+      let data = {};
+      try {
+        data = await cloned.json();
+      } catch {
+      }
+      const promptTokens = data.prompt_eval_count;
+      const completionTokens = data.eval_count;
+      const totalTokens = (promptTokens ?? 0) + (completionTokens ?? 0);
+      await tracer.record({
+        tenantId: tracer.config.tenantId,
+        provider: "ollama",
+        model: body.model ?? "unknown",
+        promptHash: hashPrompt(rawPrompt),
+        promptPreview: tracer.config.capturePromptPreview ? rawPrompt.slice(0, 200) : void 0,
+        promptTokens,
+        completionTokens,
+        totalTokens,
+        responsePreview: tracer.config.captureResponsePreview ? (data.message?.content ?? data.response ?? "").slice(0, 200) : void 0,
+        finishReason: data.done ? "stop" : void 0,
+        latencyMs,
+        costUsd: 0,
+        error: false,
+        tags: {},
+        metadata: {},
+        environment: tracer.config.environment
+      });
+      return response;
+    } catch (err) {
+      await tracer.record({
+        tenantId: tracer.config.tenantId,
+        provider: "ollama",
+        model: body.model ?? "unknown",
+        promptHash: hashPrompt(rawPrompt),
+        latencyMs: Date.now() - startMs,
+        error: true,
+        errorMessage: err.message,
+        tags: {},
+        metadata: {},
+        environment: tracer.config.environment
+      });
+      throw err;
+    }
+  };
+}
+
+// src/providers/huggingface.ts
+function wrapHuggingFace(client, tracer) {
+  const methods = ["textGeneration", "chatCompletion", "textClassification", "summarization"];
+  for (const method of methods) {
+    const original = client[method]?.bind(client);
+    if (!original) continue;
+    client[method] = async function(params) {
+      const startMs = Date.now();
+      const rawPrompt = params.inputs ?? params.messages?.map((m) => m.content).join("\n") ?? "";
+      try {
+        const response = await original(params);
+        const latencyMs = Date.now() - startMs;
+        const responseText = response?.generated_text ?? response?.choices?.[0]?.message?.content ?? (Array.isArray(response) ? response[0]?.generated_text : "") ?? "";
+        await tracer.record({
+          tenantId: tracer.config.tenantId,
+          provider: "huggingface",
+          model: params.model ?? "unknown",
+          promptHash: hashPrompt(rawPrompt),
+          promptPreview: tracer.config.capturePromptPreview ? rawPrompt.slice(0, 200) : void 0,
+          responsePreview: tracer.config.captureResponsePreview ? String(responseText).slice(0, 200) : void 0,
+          latencyMs,
+          error: false,
+          tags: { hf_method: method },
+          metadata: {},
+          environment: tracer.config.environment
+        });
+        return response;
+      } catch (err) {
+        await tracer.record({
+          tenantId: tracer.config.tenantId,
+          provider: "huggingface",
+          model: params.model ?? "unknown",
+          promptHash: hashPrompt(rawPrompt),
+          latencyMs: Date.now() - startMs,
+          error: true,
+          errorMessage: err.message,
+          tags: { hf_method: method },
+          metadata: {},
+          environment: tracer.config.environment
+        });
+        throw err;
+      }
+    };
+  }
+  return client;
+}
+
+// src/index.ts
+function createObserveOS(config) {
+  const tracer = new ObserveOSTracer(config);
+  return {
+    tracer,
+    wrapOpenAI: (client) => wrapOpenAI(client, tracer),
+    wrapAnthropic: (client) => wrapAnthropic(client, tracer),
+    wrapOllama: (fetchFn) => wrapOllama(fetchFn, tracer),
+    wrapHuggingFace: (client) => wrapHuggingFace(client, tracer)
+  };
+}
+export {
+  Exporter,
+  MODEL_PRICING,
+  ObserveOSTracer,
+  calculateCost,
+  createObserveOS,
+  getModelPricing,
+  hashPrompt,
+  wrapAnthropic,
+  wrapHuggingFace,
+  wrapOllama,
+  wrapOpenAI
+};

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "observeos",
+  "version": "0.1.0",
+  "description": "TypeScript-native LLM observability. Trace OpenAI, Anthropic, Ollama, Hugging Face with zero config.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": ["dist", "README.md", "LICENSE"],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:ui": "vitest --ui",
+    "type-check": "tsc --noEmit",
+    "lint": "eslint src --ext .ts",
+    "prepublishOnly": "npm run build && npm test && npm run type-check"
+  },
+  "peerDependencies": {
+    "openai": ">=4.0.0",
+    "@anthropic-ai/sdk": ">=0.20.0",
+    "@huggingface/inference": ">=2.0.0"
+  },
+  "peerDependenciesMeta": {
+    "openai": { "optional": true },
+    "@anthropic-ai/sdk": { "optional": true },
+    "@huggingface/inference": { "optional": true }
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "vitest": "^1.6.0",
+    "typescript": "^5.4.0",
+    "openai": "^4.0.0",
+    "@anthropic-ai/sdk": "^0.20.0",
+    "@huggingface/inference": "^2.8.0",
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "^7.0.0",
+    "@typescript-eslint/parser": "^7.0.0",
+    "eslint": "^8.0.0"
+  },
+  "keywords": [
+    "llm", "observability", "monitoring", "tracing", "opentelemetry",
+    "openai", "anthropic", "ollama", "huggingface",
+    "ai", "typescript", "sdk", "self-hosted"
+  ],
+  "author": "Abdul Mueez <abdulmoiz3140@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Abdul-Moiz31/ObserveOS.git"
+  },
+  "homepage": "https://github.com/Abdul-Moiz31/ObserveOS#readme",
+  "bugs": {
+    "url": "https://github.com/Abdul-Moiz31/ObserveOS/issues"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}