tracia 0.1.1 → 0.2.2

package/dist/index.mjs

@@ -20,13 +20,23 @@ var TraciaErrorCode = /* @__PURE__ */ ((TraciaErrorCode2) => {
   TraciaErrorCode2["INVALID_REQUEST"] = "INVALID_REQUEST";
   TraciaErrorCode2["NETWORK_ERROR"] = "NETWORK_ERROR";
   TraciaErrorCode2["TIMEOUT"] = "TIMEOUT";
+  TraciaErrorCode2["ABORTED"] = "ABORTED";
   TraciaErrorCode2["UNKNOWN"] = "UNKNOWN";
+  TraciaErrorCode2["MISSING_PROVIDER_SDK"] = "MISSING_PROVIDER_SDK";
+  TraciaErrorCode2["MISSING_PROVIDER_API_KEY"] = "MISSING_PROVIDER_API_KEY";
+  TraciaErrorCode2["UNSUPPORTED_MODEL"] = "UNSUPPORTED_MODEL";
   return TraciaErrorCode2;
 })(TraciaErrorCode || {});
+var LLMProvider = /* @__PURE__ */ ((LLMProvider2) => {
+  LLMProvider2["OPENAI"] = "openai";
+  LLMProvider2["ANTHROPIC"] = "anthropic";
+  LLMProvider2["GOOGLE"] = "google";
+  return LLMProvider2;
+})(LLMProvider || {});
 
 // src/client.ts
-var SDK_VERSION = "0.1.1";
-var DEFAULT_TIMEOUT_MS = 3e4;
+var SDK_VERSION = "0.2.2";
+var DEFAULT_TIMEOUT_MS = 12e4;
 function mapApiErrorCodeToTraciaErrorCode(apiCode) {
   const codeMap = {
     UNAUTHORIZED: "UNAUTHORIZED" /* UNAUTHORIZED */,
@@ -174,10 +184,511 @@ var Prompts = class {
   }
 };
 
+// src/models.ts
+var MODEL_TO_PROVIDER = {
+  // OpenAI
+  "chatgpt-4o-latest": "openai" /* OPENAI */,
+  "gpt-3.5-turbo": "openai" /* OPENAI */,
+  "gpt-3.5-turbo-0125": "openai" /* OPENAI */,
+  "gpt-3.5-turbo-1106": "openai" /* OPENAI */,
+  "gpt-3.5-turbo-16k": "openai" /* OPENAI */,
+  "gpt-4": "openai" /* OPENAI */,
+  "gpt-4-0125-preview": "openai" /* OPENAI */,
+  "gpt-4-1106-preview": "openai" /* OPENAI */,
+  "gpt-4-turbo": "openai" /* OPENAI */,
+  "gpt-4-turbo-2024-04-09": "openai" /* OPENAI */,
+  "gpt-4-turbo-preview": "openai" /* OPENAI */,
+  "gpt-4.1": "openai" /* OPENAI */,
+  "gpt-4.1-2025-04-14": "openai" /* OPENAI */,
+  "gpt-4.1-mini": "openai" /* OPENAI */,
+  "gpt-4.1-mini-2025-04-14": "openai" /* OPENAI */,
+  "gpt-4.1-nano": "openai" /* OPENAI */,
+  "gpt-4.1-nano-2025-04-14": "openai" /* OPENAI */,
+  "gpt-4o": "openai" /* OPENAI */,
+  "gpt-4o-2024-05-13": "openai" /* OPENAI */,
+  "gpt-4o-2024-08-06": "openai" /* OPENAI */,
+  "gpt-4o-2024-11-20": "openai" /* OPENAI */,
+  "gpt-4o-mini": "openai" /* OPENAI */,
+  "gpt-4o-mini-2024-07-18": "openai" /* OPENAI */,
+  "gpt-4o-mini-search-preview": "openai" /* OPENAI */,
+  "gpt-4o-mini-search-preview-2025-03-11": "openai" /* OPENAI */,
+  "gpt-4o-search-preview": "openai" /* OPENAI */,
+  "gpt-4o-search-preview-2025-03-11": "openai" /* OPENAI */,
+  "gpt-5": "openai" /* OPENAI */,
+  "gpt-5.1": "openai" /* OPENAI */,
+  "gpt-5.1-2025-11-13": "openai" /* OPENAI */,
+  "gpt-5.1-chat-latest": "openai" /* OPENAI */,
+  "gpt-5.2": "openai" /* OPENAI */,
+  "gpt-5.2-2025-12-11": "openai" /* OPENAI */,
+  "gpt-5.2-chat-latest": "openai" /* OPENAI */,
+  "gpt-5.2-pro": "openai" /* OPENAI */,
+  "gpt-5.2-pro-2025-12-11": "openai" /* OPENAI */,
+  "gpt-5-pro": "openai" /* OPENAI */,
+  "gpt-5-pro-2025-10-06": "openai" /* OPENAI */,
+  "gpt-5-2025-08-07": "openai" /* OPENAI */,
+  "gpt-5-chat-latest": "openai" /* OPENAI */,
+  "gpt-5-codex": "openai" /* OPENAI */,
+  "gpt-5.1-codex": "openai" /* OPENAI */,
+  "gpt-5.1-codex-max": "openai" /* OPENAI */,
+  "gpt-5.1-codex-mini": "openai" /* OPENAI */,
+  "gpt-5-mini": "openai" /* OPENAI */,
+  "gpt-5-mini-2025-08-07": "openai" /* OPENAI */,
+  "gpt-5-nano": "openai" /* OPENAI */,
+  "gpt-5-nano-2025-08-07": "openai" /* OPENAI */,
+  "o1": "openai" /* OPENAI */,
+  "o1-2024-12-17": "openai" /* OPENAI */,
+  "o1-pro": "openai" /* OPENAI */,
+  "o1-pro-2025-03-19": "openai" /* OPENAI */,
+  "o3": "openai" /* OPENAI */,
+  "o3-2025-04-16": "openai" /* OPENAI */,
+  "o3-mini": "openai" /* OPENAI */,
+  "o3-mini-2025-01-31": "openai" /* OPENAI */,
+  "o4-mini": "openai" /* OPENAI */,
+  "o4-mini-2025-04-16": "openai" /* OPENAI */,
+  // Anthropic
+  "claude-haiku-4-5-20251001": "anthropic" /* ANTHROPIC */,
+  "claude-haiku-4-5": "anthropic" /* ANTHROPIC */,
+  "claude-3-7-sonnet-20250219": "anthropic" /* ANTHROPIC */,
+  "claude-3-haiku-20240307": "anthropic" /* ANTHROPIC */,
+  "claude-3-opus-20240229": "anthropic" /* ANTHROPIC */,
+  "claude-4-opus-20250514": "anthropic" /* ANTHROPIC */,
+  "claude-4-sonnet-20250514": "anthropic" /* ANTHROPIC */,
+  "claude-sonnet-4-5": "anthropic" /* ANTHROPIC */,
+  "claude-sonnet-4-5-20250929": "anthropic" /* ANTHROPIC */,
+  "claude-opus-4-1": "anthropic" /* ANTHROPIC */,
+  "claude-opus-4-1-20250805": "anthropic" /* ANTHROPIC */,
+  "claude-opus-4-20250514": "anthropic" /* ANTHROPIC */,
+  "claude-opus-4-5-20251101": "anthropic" /* ANTHROPIC */,
+  "claude-opus-4-5": "anthropic" /* ANTHROPIC */,
+  "claude-sonnet-4-20250514": "anthropic" /* ANTHROPIC */,
+  // Google
+  "gemini-2.0-flash": "google" /* GOOGLE */,
+  "gemini-2.0-flash-001": "google" /* GOOGLE */,
+  "gemini-2.0-flash-exp": "google" /* GOOGLE */,
+  "gemini-2.0-flash-lite": "google" /* GOOGLE */,
+  "gemini-2.0-flash-lite-001": "google" /* GOOGLE */,
+  "gemini-2.5-flash": "google" /* GOOGLE */,
+  "gemini-2.5-flash-lite": "google" /* GOOGLE */,
+  "gemini-2.5-flash-lite-preview-09-2025": "google" /* GOOGLE */,
+  "gemini-2.5-flash-preview-09-2025": "google" /* GOOGLE */,
+  "gemini-2.5-pro": "google" /* GOOGLE */,
+  "gemini-3-pro-preview": "google" /* GOOGLE */,
+  "gemini-3-flash-preview": "google" /* GOOGLE */
+};
+function getProviderForModel(modelId) {
+  return MODEL_TO_PROVIDER[modelId];
+}
+
+// src/providers/ai-sdk.ts
+var aiSdk = null;
+var openaiProvider = null;
+var anthropicProvider = null;
+var googleProvider = null;
+async function loadAISdk() {
+  if (aiSdk) return aiSdk;
+  try {
+    aiSdk = await import("ai");
+    return aiSdk;
+  } catch {
+    throw new TraciaError(
+      "MISSING_PROVIDER_SDK" /* MISSING_PROVIDER_SDK */,
+      "Vercel AI SDK not installed. Run: npm install ai"
+    );
+  }
+}
+async function loadOpenAIProvider() {
+  if (openaiProvider) return openaiProvider;
+  try {
+    openaiProvider = await import("@ai-sdk/openai");
+    return openaiProvider;
+  } catch {
+    throw new TraciaError(
+      "MISSING_PROVIDER_SDK" /* MISSING_PROVIDER_SDK */,
+      "OpenAI provider not installed. Run: npm install @ai-sdk/openai"
+    );
+  }
+}
+async function loadAnthropicProvider() {
+  if (anthropicProvider) return anthropicProvider;
+  try {
+    anthropicProvider = await import("@ai-sdk/anthropic");
+    return anthropicProvider;
+  } catch {
+    throw new TraciaError(
+      "MISSING_PROVIDER_SDK" /* MISSING_PROVIDER_SDK */,
+      "Anthropic provider not installed. Run: npm install @ai-sdk/anthropic"
+    );
+  }
+}
+async function loadGoogleProvider() {
+  if (googleProvider) return googleProvider;
+  try {
+    googleProvider = await import("@ai-sdk/google");
+    return googleProvider;
+  } catch {
+    throw new TraciaError(
+      "MISSING_PROVIDER_SDK" /* MISSING_PROVIDER_SDK */,
+      "Google provider not installed. Run: npm install @ai-sdk/google"
+    );
+  }
+}
+function combineAbortSignals(userSignal, timeoutMs) {
+  if (!timeoutMs && !userSignal) return void 0;
+  if (timeoutMs && !userSignal) return AbortSignal.timeout(timeoutMs);
+  if (!timeoutMs && userSignal) return userSignal;
+  const timeoutSignal = AbortSignal.timeout(timeoutMs);
+  const controller = new AbortController();
+  const cleanup = () => {
+    userSignal.removeEventListener("abort", onAbort);
+    timeoutSignal.removeEventListener("abort", onAbort);
+  };
+  const onAbort = () => {
+    cleanup();
+    controller.abort();
+  };
+  userSignal.addEventListener("abort", onAbort, { once: true });
+  timeoutSignal.addEventListener("abort", onAbort, { once: true });
+  return controller.signal;
+}
+function sanitizeErrorMessage(message) {
+  return message.replace(/\b(sk-|tr_|key-|api[_-]?key[=:\s]+)[a-zA-Z0-9_-]{10,}\b/gi, "[REDACTED]").replace(/Bearer\s+[a-zA-Z0-9_.-]+/gi, "Bearer [REDACTED]").replace(/Basic\s+[a-zA-Z0-9+/=]{20,}/gi, "Basic [REDACTED]").replace(/(authorization[=:\s]+)[^\s,}]+/gi, "$1[REDACTED]");
+}
+function resolveProvider(model, explicitProvider) {
+  if (explicitProvider) return explicitProvider;
+  const fromRegistry = getProviderForModel(model);
+  if (fromRegistry) return fromRegistry;
+  if (model.startsWith("gpt-") || model.startsWith("o1") || model.startsWith("o3") || model.startsWith("o4")) {
+    return "openai" /* OPENAI */;
+  }
+  if (model.startsWith("claude-")) {
+    return "anthropic" /* ANTHROPIC */;
+  }
+  if (model.startsWith("gemini-")) {
+    return "google" /* GOOGLE */;
+  }
+  throw new TraciaError(
+    "UNSUPPORTED_MODEL" /* UNSUPPORTED_MODEL */,
+    `Cannot determine provider for model: ${model}. Specify provider explicitly.`
+  );
+}
+async function getLanguageModel(provider, model, apiKey) {
+  switch (provider) {
+    case "openai" /* OPENAI */: {
+      const { createOpenAI } = await loadOpenAIProvider();
+      const openai = createOpenAI({ apiKey });
+      return openai(model);
+    }
+    case "anthropic" /* ANTHROPIC */: {
+      const { createAnthropic } = await loadAnthropicProvider();
+      const anthropic = createAnthropic({ apiKey });
+      return anthropic(model);
+    }
+    case "google" /* GOOGLE */: {
+      const { createGoogleGenerativeAI } = await loadGoogleProvider();
+      const google = createGoogleGenerativeAI({ apiKey });
+      return google(model);
+    }
+    default:
+      throw new TraciaError(
+        "UNSUPPORTED_MODEL" /* UNSUPPORTED_MODEL */,
+        `Unsupported provider: ${provider}`
+      );
+  }
+}
+function convertMessages(messages) {
+  return messages.map((msg) => {
+    if (msg.role === "tool") {
+      return {
+        role: "tool",
+        content: [{
+          type: "tool-result",
+          toolCallId: msg.toolCallId,
+          toolName: msg.toolCallId,
+          // AI SDK requires toolName, use toolCallId as fallback
+          input: {},
+          output: msg.content
+        }]
+      };
+    }
+    if (msg.role === "assistant" && Array.isArray(msg.content)) {
+      if (msg.content.length === 0) {
+        return { role: "assistant", content: "" };
+      }
+      const convertedContent = msg.content.map((part) => {
+        if (part.type === "tool_call") {
+          const toolCall = part;
+          return {
+            type: "tool-call",
+            toolCallId: toolCall.id,
+            toolName: toolCall.name,
+            input: toolCall.arguments
+          };
+        }
+        return part;
+      });
+      return {
+        role: "assistant",
+        content: convertedContent
+      };
+    }
+    return {
+      role: msg.role,
+      content: typeof msg.content === "string" ? msg.content : msg.content.map((b) => b.type === "text" ? b.text : "").join("")
+    };
+  });
+}
+async function convertTools(tools) {
+  if (!tools || tools.length === 0) return void 0;
+  const { tool, jsonSchema } = await loadAISdk();
+  const result = {};
+  for (const toolDef of tools) {
+    result[toolDef.name] = tool({
+      description: toolDef.description,
+      inputSchema: jsonSchema(toolDef.parameters),
+      execute: async (args) => args
+      // No-op execute function
+    });
+  }
+  return result;
+}
+function convertToolChoice(toolChoice) {
+  if (!toolChoice) return void 0;
+  if (toolChoice === "auto") return "auto";
+  if (toolChoice === "none") return "none";
+  if (toolChoice === "required") return "required";
+  return { type: "tool", toolName: toolChoice.tool };
+}
+function parseFinishReason(reason) {
+  if (reason === "tool-calls") return "tool_calls";
+  if (reason === "length") return "max_tokens";
+  return "stop";
+}
+function extractToolCalls(toolCalls) {
+  if (!toolCalls) return [];
+  return toolCalls.filter((tc) => tc.toolCallId && tc.toolName).map((tc) => ({
+    id: tc.toolCallId,
+    name: tc.toolName,
+    arguments: tc.input ?? {}
+  }));
+}
+async function complete(options) {
+  const { generateText } = await loadAISdk();
+  const provider = resolveProvider(options.model, options.provider);
+  const model = await getLanguageModel(provider, options.model, options.apiKey);
+  const convertedMessages = convertMessages(options.messages);
+  const convertedTools = await convertTools(options.tools);
+  const convertedToolChoice = convertToolChoice(options.toolChoice);
+  try {
+    const result = await generateText({
+      model,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      messages: convertedMessages,
+      temperature: options.temperature,
+      maxOutputTokens: options.maxOutputTokens,
+      topP: options.topP,
+      stopSequences: options.stopSequences,
+      tools: convertedTools,
+      toolChoice: convertedToolChoice,
+      abortSignal: options.timeoutMs ? AbortSignal.timeout(options.timeoutMs) : void 0
+    });
+    const toolCalls = extractToolCalls(result.toolCalls);
+    return {
+      text: result.text,
+      inputTokens: result.usage?.inputTokens ?? 0,
+      outputTokens: result.usage?.outputTokens ?? 0,
+      totalTokens: result.usage?.totalTokens ?? 0,
+      toolCalls,
+      finishReason: parseFinishReason(result.finishReason),
+      provider
+    };
+  } catch (error) {
+    if (error instanceof TraciaError) throw error;
+    const rawMessage = error instanceof Error ? error.message : String(error);
+    throw new TraciaError(
+      "PROVIDER_ERROR" /* PROVIDER_ERROR */,
+      `${provider} error: ${sanitizeErrorMessage(rawMessage)}`
+    );
+  }
+}
+function stream(options) {
+  const provider = resolveProvider(options.model, options.provider);
+  let resolveResult;
+  let rejectResult;
+  const resultPromise = new Promise((resolve, reject) => {
+    resolveResult = resolve;
+    rejectResult = reject;
+  });
+  async function* generateChunks() {
+    try {
+      const { streamText } = await loadAISdk();
+      const model = await getLanguageModel(provider, options.model, options.apiKey);
+      const convertedMessages = convertMessages(options.messages);
+      const convertedTools = await convertTools(options.tools);
+      const convertedToolChoice = convertToolChoice(options.toolChoice);
+      const abortSignal = combineAbortSignals(options.signal, options.timeoutMs);
+      const result = streamText({
+        model,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        messages: convertedMessages,
+        temperature: options.temperature,
+        maxOutputTokens: options.maxOutputTokens,
+        topP: options.topP,
+        stopSequences: options.stopSequences,
+        tools: convertedTools,
+        toolChoice: convertedToolChoice,
+        abortSignal
+      });
+      for await (const chunk of result.textStream) {
+        yield chunk;
+      }
+      const [text, usageData, toolCallsData, finishReasonData] = await Promise.all([
+        result.text,
+        result.usage,
+        result.toolCalls,
+        result.finishReason
+      ]);
+      const toolCalls = extractToolCalls(toolCallsData);
+      resolveResult({
+        text,
+        inputTokens: usageData?.inputTokens ?? 0,
+        outputTokens: usageData?.outputTokens ?? 0,
+        totalTokens: usageData?.totalTokens ?? 0,
+        toolCalls,
+        finishReason: parseFinishReason(finishReasonData),
+        provider
+      });
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        const traciaError2 = new TraciaError("ABORTED" /* ABORTED */, "Stream aborted");
+        rejectResult(traciaError2);
+        throw traciaError2;
+      }
+      const rawMessage = error instanceof Error ? error.message : String(error);
+      const traciaError = error instanceof TraciaError ? error : new TraciaError(
+        "PROVIDER_ERROR" /* PROVIDER_ERROR */,
+        `${provider} error: ${sanitizeErrorMessage(rawMessage)}`
+      );
+      rejectResult(traciaError);
+      throw traciaError;
+    }
+  }
+  return {
+    chunks: generateChunks(),
+    result: resultPromise
+  };
+}
+function responsesStream(options) {
+  let resolveResult;
+  let rejectResult;
+  const resultPromise = new Promise((resolve, reject) => {
+    resolveResult = resolve;
+    rejectResult = reject;
+  });
+  async function* generateEvents() {
+    let fullText = "";
+    let usage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+    const outputItems = [];
+    const toolCalls = [];
+    let aborted = false;
+    try {
+      const { createOpenAI } = await loadOpenAIProvider();
+      const openai = createOpenAI({ apiKey: options.apiKey });
+      const model = openai.responses(options.model);
+      const { streamText } = await loadAISdk();
+      const convertedTools = options.tools ? await convertTools(options.tools) : void 0;
+      const abortSignal = combineAbortSignals(options.signal, options.timeoutMs);
+      const result = streamText({
+        model,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        messages: options.input,
+        maxOutputTokens: options.maxOutputTokens,
+        tools: convertedTools,
+        abortSignal
+      });
+      for await (const chunk of result.textStream) {
+        fullText += chunk;
+        yield { type: "text_delta", data: chunk };
+      }
+      const [usageData, toolCallsData] = await Promise.all([
+        result.usage,
+        result.toolCalls
+      ]);
+      usage = {
+        inputTokens: usageData?.inputTokens ?? 0,
+        outputTokens: usageData?.outputTokens ?? 0,
+        totalTokens: usageData?.totalTokens ?? 0
+      };
+      if (toolCallsData) {
+        for (const tc of toolCallsData) {
+          if (!tc.toolCallId || !tc.toolName) continue;
+          const toolCall = {
+            id: tc.toolCallId,
+            callId: tc.toolCallId,
+            name: tc.toolName,
+            arguments: tc.input ?? {}
+          };
+          toolCalls.push(toolCall);
+          yield {
+            type: "tool_call",
+            id: toolCall.id,
+            callId: toolCall.callId,
+            name: toolCall.name,
+            arguments: toolCall.arguments
+          };
+        }
+      }
+      if (fullText) {
+        yield { type: "text", data: fullText };
+        outputItems.push({ type: "message", content: fullText });
+      }
+      yield { type: "done", usage };
+      resolveResult({
+        text: fullText,
+        usage,
+        outputItems,
+        toolCalls,
+        aborted
+      });
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        aborted = true;
+        resolveResult({
+          text: fullText,
+          usage,
+          outputItems,
+          toolCalls,
+          aborted
+        });
+        return;
+      }
+      const rawMessage = error instanceof Error ? error.message : String(error);
+      const traciaError = new TraciaError(
+        "PROVIDER_ERROR" /* PROVIDER_ERROR */,
+        `OpenAI Responses API error: ${sanitizeErrorMessage(rawMessage)}`
+      );
+      rejectResult(traciaError);
+      throw traciaError;
+    }
+  }
+  return {
+    events: generateEvents(),
+    result: resultPromise
+  };
+}
+
 // src/traces.ts
+var INTERNAL_SET_PENDING_TRACES = /* @__PURE__ */ Symbol("setPendingTracesMap");
 var Traces = class {
   constructor(client) {
     this.client = client;
+    this.pendingTraces = null;
+  }
+  /** @internal */
+  [INTERNAL_SET_PENDING_TRACES](map) {
+    this.pendingTraces = map;
+  }
+  async create(payload) {
+    return this.client.post("/api/v1/traces", payload);
   }
   async get(traceId) {
     return this.client.get(`/api/v1/traces/${encodeURIComponent(traceId)}`);
@@ -215,24 +726,680 @@ var Traces = class {
     const path = query ? `/api/v1/traces?${query}` : "/api/v1/traces";
     return this.client.get(path);
   }
+  async evaluate(traceId, options) {
+    if (this.pendingTraces) {
+      const pendingTrace = this.pendingTraces.get(traceId);
+      if (pendingTrace) {
+        await pendingTrace;
+      }
+    }
+    if (typeof options.value !== "number") {
+      throw new TraciaError(
+        "INVALID_REQUEST" /* INVALID_REQUEST */,
+        `Invalid evaluation value. Must be a number.`
+      );
+    }
+    const body = {
+      evaluatorKey: options.evaluator,
+      value: options.value
+    };
+    if (options.note !== void 0) {
+      body.note = options.note;
+    }
+    return this.client.post(
+      `/api/v1/traces/${encodeURIComponent(traceId)}/evaluations`,
+      body
+    );
+  }
 };
 
+// src/utils.ts
+import crypto from "crypto";
+var TRACE_ID_REGEX = /^tr_[a-f0-9]{16}$/i;
+function generateTraceId() {
+  const randomPart = crypto.randomBytes(8).toString("hex");
+  return `tr_${randomPart}`;
+}
+function isValidTraceIdFormat(traceId) {
+  return TRACE_ID_REGEX.test(traceId);
+}
+
 // src/index.ts
+var Eval = {
+  POSITIVE: 1,
+  NEGATIVE: 0
+};
 var DEFAULT_BASE_URL = "https://app.tracia.io";
+var MAX_PENDING_TRACES = 1e3;
+var TRACE_RETRY_ATTEMPTS = 2;
+var TRACE_RETRY_DELAY_MS = 500;
+var TRACE_STATUS_SUCCESS = "SUCCESS";
+var TRACE_STATUS_ERROR = "ERROR";
+var ENV_VAR_MAP = {
+  ["openai" /* OPENAI */]: "OPENAI_API_KEY",
+  ["anthropic" /* ANTHROPIC */]: "ANTHROPIC_API_KEY",
+  ["google" /* GOOGLE */]: "GOOGLE_API_KEY"
+};
+function convertResponsesItemToMessage(item) {
+  if ("role" in item && (item.role === "developer" || item.role === "user")) {
+    const messageItem = item;
+    return {
+      role: messageItem.role === "developer" ? "system" : "user",
+      content: messageItem.content
+    };
+  }
+  if ("type" in item && item.type === "function_call_output") {
+    const outputItem = item;
+    return {
+      role: "tool",
+      toolCallId: outputItem.call_id,
+      content: outputItem.output
+    };
+  }
+  if ("type" in item) {
+    return {
+      role: "assistant",
+      content: JSON.stringify(item)
+    };
+  }
+  return {
+    role: "user",
+    content: JSON.stringify(item)
+  };
+}
 var Tracia = class {
   constructor(options) {
+    this.pendingTraces = /* @__PURE__ */ new Map();
     if (!options.apiKey) {
-      throw new Error("apiKey is required");
+      throw new TraciaError(
+        "INVALID_REQUEST" /* INVALID_REQUEST */,
+        "apiKey is required"
+      );
     }
     this.client = new HttpClient({
       apiKey: options.apiKey,
       baseUrl: DEFAULT_BASE_URL
     });
+    this.onTraceError = options.onTraceError;
     this.prompts = new Prompts(this.client);
     this.traces = new Traces(this.client);
+    this.traces[INTERNAL_SET_PENDING_TRACES](this.pendingTraces);
+  }
+  runLocal(input) {
+    if (input.stream === true) {
+      return this.runLocalStreaming(input);
+    }
+    return this.runLocalNonStreaming(input);
+  }
+  async runLocalNonStreaming(input) {
+    this.validateRunLocalInput(input);
+    let traceId = "";
+    if (input.sendTrace !== false) {
+      if (input.traceId && !isValidTraceIdFormat(input.traceId)) {
+        throw new TraciaError(
+          "INVALID_REQUEST" /* INVALID_REQUEST */,
+          `Invalid trace ID format. Must match: tr_ + 16 hex characters (e.g., tr_1234567890abcdef)`
+        );
+      }
+      traceId = input.traceId || generateTraceId();
+    }
+    const interpolatedMessages = this.interpolateMessages(input.messages, input.variables);
+    const provider = resolveProvider(input.model, input.provider);
+    const apiKey = this.getProviderApiKey(provider, input.providerApiKey);
+    const startTime = Date.now();
+    let completionResult = null;
+    let errorMessage = null;
+    try {
+      completionResult = await complete({
+        model: input.model,
+        messages: interpolatedMessages,
+        apiKey,
+        provider: input.provider,
+        temperature: input.temperature,
+        maxOutputTokens: input.maxOutputTokens,
+        topP: input.topP,
+        stopSequences: input.stopSequences,
+        tools: input.tools,
+        toolChoice: input.toolChoice,
+        timeoutMs: input.timeoutMs
+      });
+    } catch (error) {
+      if (error instanceof TraciaError) {
+        errorMessage = error.message;
+      } else {
+        errorMessage = error instanceof Error ? error.message : String(error);
+      }
+    }
+    const latencyMs = Date.now() - startTime;
+    if (traceId) {
+      this.scheduleTraceCreation(traceId, {
+        traceId,
+        model: input.model,
+        provider: completionResult?.provider ?? provider,
+        input: { messages: interpolatedMessages },
+        variables: input.variables ?? null,
+        output: completionResult?.text ?? null,
+        status: errorMessage ? TRACE_STATUS_ERROR : TRACE_STATUS_SUCCESS,
+        error: errorMessage,
+        latencyMs,
+        inputTokens: completionResult?.inputTokens ?? 0,
+        outputTokens: completionResult?.outputTokens ?? 0,
+        totalTokens: completionResult?.totalTokens ?? 0,
+        tags: input.tags,
+        userId: input.userId,
+        sessionId: input.sessionId,
+        temperature: input.temperature,
+        maxOutputTokens: input.maxOutputTokens,
+        topP: input.topP,
+        tools: input.tools,
+        toolCalls: completionResult?.toolCalls
+      });
+    }
+    if (errorMessage) {
+      throw new TraciaError("PROVIDER_ERROR" /* PROVIDER_ERROR */, errorMessage);
+    }
+    const toolCalls = completionResult.toolCalls;
+    const finishReason = completionResult.finishReason;
+    const message = this.buildAssistantMessage(completionResult.text, toolCalls);
+    return {
+      text: completionResult.text,
+      traceId,
+      latencyMs,
+      usage: {
+        inputTokens: completionResult.inputTokens,
+        outputTokens: completionResult.outputTokens,
+        totalTokens: completionResult.totalTokens
+      },
+      cost: null,
+      provider: completionResult.provider,
+      model: input.model,
+      toolCalls,
+      finishReason,
+      message
+    };
+  }
+  runLocalStreaming(input) {
+    this.validateRunLocalInput(input);
+    let traceId = "";
+    if (input.sendTrace !== false) {
+      if (input.traceId && !isValidTraceIdFormat(input.traceId)) {
+        throw new TraciaError(
+          "INVALID_REQUEST" /* INVALID_REQUEST */,
+          `Invalid trace ID format. Must match: tr_ + 16 hex characters (e.g., tr_1234567890abcdef)`
+        );
+      }
+      traceId = input.traceId || generateTraceId();
+    }
+    const interpolatedMessages = this.interpolateMessages(input.messages, input.variables);
+    const provider = resolveProvider(input.model, input.provider);
+    const apiKey = this.getProviderApiKey(provider, input.providerApiKey);
+    const abortController = new AbortController();
+    const combinedSignal = input.signal ? this.combineAbortSignals(input.signal, abortController.signal) : abortController.signal;
+    return this.createLocalStream(
+      input,
+      interpolatedMessages,
+      provider,
+      apiKey,
+      traceId,
+      combinedSignal,
+      abortController
+    );
+  }
+  runResponses(input) {
+    if (input.stream === true) {
+      return this.runResponsesStreaming(input);
+    }
+    return this.runResponsesNonStreaming(input);
+  }
+  async runResponsesNonStreaming(input) {
+    const stream2 = this.runResponsesStreaming(input);
+    for await (const _event of stream2) {
+    }
+    return stream2.result;
+  }
+  runResponsesStreaming(input) {
+    this.validateResponsesInput(input);
+    let traceId = "";
+    if (input.sendTrace !== false) {
+      if (input.traceId && !isValidTraceIdFormat(input.traceId)) {
+        throw new TraciaError(
+          "INVALID_REQUEST" /* INVALID_REQUEST */,
+          `Invalid trace ID format. Must match: tr_ + 16 hex characters (e.g., tr_1234567890abcdef)`
+        );
+      }
+      traceId = input.traceId || generateTraceId();
+    }
+    const apiKey = this.getProviderApiKey("openai" /* OPENAI */, input.providerApiKey);
+    const abortController = new AbortController();
+    const combinedSignal = input.signal ? this.combineAbortSignals(input.signal, abortController.signal) : abortController.signal;
+    return this.createResponsesStream(
+      input,
+      apiKey,
+      traceId,
+      combinedSignal,
+      abortController
+    );
+  }
+  validateResponsesInput(input) {
+    if (!input.model || input.model.trim() === "") {
+      throw new TraciaError(
+        "INVALID_REQUEST" /* INVALID_REQUEST */,
+        "model is required and cannot be empty"
+      );
+    }
+    if (!input.input || input.input.length === 0) {
+      throw new TraciaError(
+        "INVALID_REQUEST" /* INVALID_REQUEST */,
+        "input array is required and cannot be empty"
+      );
+    }
+  }
+  createResponsesStream(input, apiKey, traceId, signal, abortController) {
+    const startTime = Date.now();
+    let aborted = false;
+    let resolveResult;
+    let rejectResult;
+    const resultPromise = new Promise((resolve, reject) => {
+      resolveResult = resolve;
+      rejectResult = reject;
+    });
+    const providerStream = responsesStream({
+      model: input.model,
+      input: input.input,
+      apiKey,
+      tools: input.tools,
+      maxOutputTokens: input.maxOutputTokens,
+      timeoutMs: input.timeoutMs,
+      signal
+    });
+    let collectedText = "";
+    const scheduleTrace = this.scheduleTraceCreation.bind(this);
+    async function* wrappedEvents() {
+      try {
+        for await (const event of providerStream.events) {
+          if (event.type === "text_delta") {
+            collectedText += event.data;
+          }
+          yield event;
+        }
+        const providerResult = await providerStream.result;
+        const latencyMs = Date.now() - startTime;
+        if (traceId) {
+          scheduleTrace(traceId, {
+            traceId,
+            model: input.model,
+            provider: "openai" /* OPENAI */,
+            input: { messages: input.input.map((item) => convertResponsesItemToMessage(item)) },
+            variables: null,
+            output: providerResult.text,
+            status: providerResult.aborted ? TRACE_STATUS_ERROR : TRACE_STATUS_SUCCESS,
+            error: providerResult.aborted ? "Stream aborted" : null,
+            latencyMs,
+            inputTokens: providerResult.usage.inputTokens,
+            outputTokens: providerResult.usage.outputTokens,
+            totalTokens: providerResult.usage.totalTokens,
+            tags: input.tags,
+            userId: input.userId,
+            sessionId: input.sessionId,
+            tools: input.tools,
+            toolCalls: providerResult.toolCalls.map((tc) => ({
+              id: tc.id,
+              name: tc.name,
+              arguments: tc.arguments
+            }))
+          });
+        }
+        resolveResult({
+          text: providerResult.text,
+          traceId,
+          latencyMs,
+          usage: providerResult.usage,
+          outputItems: providerResult.outputItems,
+          toolCalls: providerResult.toolCalls,
+          aborted: providerResult.aborted
+        });
+      } catch (error) {
+        const latencyMs = Date.now() - startTime;
+        const isAborted = aborted || signal.aborted;
+        const errorMessage = isAborted ? "Stream aborted" : error instanceof Error ? error.message : String(error);
+        if (traceId) {
+          scheduleTrace(traceId, {
+            traceId,
+            model: input.model,
+            provider: "openai" /* OPENAI */,
+            input: { messages: input.input.map((item) => convertResponsesItemToMessage(item)) },
+            variables: null,
+            output: collectedText || null,
+            status: TRACE_STATUS_ERROR,
+            error: errorMessage,
+            latencyMs,
+            inputTokens: 0,
+            outputTokens: 0,
+            totalTokens: 0,
+            tags: input.tags,
+            userId: input.userId,
+            sessionId: input.sessionId,
+            tools: input.tools
+          });
+        }
+        if (isAborted) {
+          resolveResult({
+            text: collectedText,
+            traceId,
+            latencyMs,
+            usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+            outputItems: [],
+            toolCalls: [],
+            aborted: true
+          });
+        } else {
+          const traciaError = error instanceof TraciaError ? error : new TraciaError("PROVIDER_ERROR" /* PROVIDER_ERROR */, errorMessage);
+          rejectResult(traciaError);
+          throw traciaError;
+        }
+      }
+    }
+    const asyncIterator = wrappedEvents();
+    return {
+      traceId,
+      [Symbol.asyncIterator]() {
+        return asyncIterator;
+      },
+      result: resultPromise,
+      abort() {
+        aborted = true;
+        abortController.abort();
+      }
+    };
+  }
+  createLocalStream(input, interpolatedMessages, provider, apiKey, traceId, signal, abortController) {
+    const startTime = Date.now();
+    let aborted = false;
+    let resolveResult;
+    let rejectResult;
+    const resultPromise = new Promise((resolve, reject) => {
+      resolveResult = resolve;
+      rejectResult = reject;
+    });
+    const providerStream = stream({
+      model: input.model,
+      messages: interpolatedMessages,
+      apiKey,
+      provider: input.provider,
+      temperature: input.temperature,
+      maxOutputTokens: input.maxOutputTokens,
+      topP: input.topP,
+      stopSequences: input.stopSequences,
+      tools: input.tools,
+      toolChoice: input.toolChoice,
+      timeoutMs: input.timeoutMs,
+      signal
+    });
+    let collectedText = "";
+    const scheduleTrace = this.scheduleTraceCreation.bind(this);
+    const buildAssistantMessage = this.buildAssistantMessage.bind(this);
+    async function* wrappedChunks() {
+      try {
+        for await (const chunk of providerStream.chunks) {
+          collectedText += chunk;
+          yield chunk;
+        }
+        const completionResult = await providerStream.result;
+        const latencyMs = Date.now() - startTime;
+        if (traceId) {
+          scheduleTrace(traceId, {
+            traceId,
+            model: input.model,
+            provider: completionResult.provider,
+            input: { messages: interpolatedMessages },
+            variables: input.variables ?? null,
+            output: completionResult.text,
+            status: TRACE_STATUS_SUCCESS,
+            error: null,
+            latencyMs,
+            inputTokens: completionResult.inputTokens,
+            outputTokens: completionResult.outputTokens,
+            totalTokens: completionResult.totalTokens,
+            tags: input.tags,
+            userId: input.userId,
+            sessionId: input.sessionId,
+            temperature: input.temperature,
+            maxOutputTokens: input.maxOutputTokens,
+            topP: input.topP,
+            tools: input.tools,
+            toolCalls: completionResult.toolCalls
+          });
+        }
+        const toolCalls = completionResult.toolCalls;
+        const finishReason = completionResult.finishReason;
+        const message = buildAssistantMessage(completionResult.text, toolCalls);
+        resolveResult({
+          text: completionResult.text,
+          traceId,
+          latencyMs,
+          usage: {
+            inputTokens: completionResult.inputTokens,
+            outputTokens: completionResult.outputTokens,
+            totalTokens: completionResult.totalTokens
+          },
+          cost: null,
+          provider: completionResult.provider,
+          model: input.model,
+          aborted: false,
+          toolCalls,
+          finishReason,
+          message
+        });
+      } catch (error) {
+        const latencyMs = Date.now() - startTime;
+        const isAborted = aborted || signal.aborted;
+        const errorMessage = isAborted ? "Stream aborted" : error instanceof Error ? error.message : String(error);
+        if (traceId) {
+          scheduleTrace(traceId, {
+            traceId,
+            model: input.model,
+            provider,
+            input: { messages: interpolatedMessages },
+            variables: input.variables ?? null,
+            output: collectedText || null,
+            status: TRACE_STATUS_ERROR,
+            error: errorMessage,
+            latencyMs,
+            inputTokens: 0,
+            outputTokens: 0,
+            totalTokens: 0,
+            tags: input.tags,
+            userId: input.userId,
+            sessionId: input.sessionId,
+            temperature: input.temperature,
+            maxOutputTokens: input.maxOutputTokens,
+            topP: input.topP
+          });
+        }
+        if (isAborted) {
+          const abortedMessage = buildAssistantMessage(collectedText, []);
+          resolveResult({
+            text: collectedText,
+            traceId,
+            latencyMs,
+            usage: {
+              inputTokens: 0,
+              outputTokens: 0,
+              totalTokens: 0
+            },
+            cost: null,
+            provider,
+            model: input.model,
+            aborted: true,
+            toolCalls: [],
+            finishReason: "stop",
+            message: abortedMessage
+          });
+        } else {
+          const traciaError = error instanceof TraciaError ? error : new TraciaError("PROVIDER_ERROR" /* PROVIDER_ERROR */, errorMessage);
+          rejectResult(traciaError);
+          throw traciaError;
+        }
+      }
+    }
+    const asyncIterator = wrappedChunks();
+    return {
+      traceId,
+      [Symbol.asyncIterator]() {
+        return asyncIterator;
+      },
+      result: resultPromise,
+      abort() {
+        aborted = true;
+        abortController.abort();
+      }
+    };
+  }
+  combineAbortSignals(signal1, signal2) {
+    const controller = new AbortController();
+    if (signal1.aborted || signal2.aborted) {
+      controller.abort();
+      return controller.signal;
+    }
+    const onAbort = () => {
+      signal1.removeEventListener("abort", onAbort);
+      signal2.removeEventListener("abort", onAbort);
+      controller.abort();
+    };
+    signal1.addEventListener("abort", onAbort, { once: true });
+    signal2.addEventListener("abort", onAbort, { once: true });
+    return controller.signal;
+  }
+  async flush() {
+    await Promise.all(this.pendingTraces.values());
+  }
+  validateRunLocalInput(input) {
+    if (!input.model || input.model.trim() === "") {
+      throw new TraciaError(
+        "INVALID_REQUEST" /* INVALID_REQUEST */,
+        "model is required and cannot be empty"
+      );
+    }
+    if (!input.messages || input.messages.length === 0) {
+      throw new TraciaError(
+        "INVALID_REQUEST" /* INVALID_REQUEST */,
+        "messages array is required and cannot be empty"
+      );
+    }
+    for (const message of input.messages) {
+      if (message.role === "tool") {
+        if (!message.toolCallId) {
+          throw new TraciaError(
+            "INVALID_REQUEST" /* INVALID_REQUEST */,
+            `Tool messages must include toolCallId. Example: { role: "tool", toolCallId: "call_123", content: '{"result": "data"}' }`
+          );
+        }
+        if (typeof message.content !== "string") {
+          throw new TraciaError(
+            "INVALID_REQUEST" /* INVALID_REQUEST */,
+            `Tool message content must be a string (the tool result). Example: { role: "tool", toolCallId: "call_123", content: '{"result": "data"}' }`
+          );
+        }
+      }
+    }
+  }
+  scheduleTraceCreation(traceId, payload) {
+    if (this.pendingTraces.size >= MAX_PENDING_TRACES) {
+      const oldestTraceId = this.pendingTraces.keys().next().value;
+      if (oldestTraceId) {
+        this.pendingTraces.delete(oldestTraceId);
+      }
+    }
+    const tracePromise = this.createTraceWithRetry(traceId, payload);
+    this.pendingTraces.set(traceId, tracePromise);
+    tracePromise.finally(() => this.pendingTraces.delete(traceId));
+  }
+  async createTraceWithRetry(traceId, payload) {
+    let lastError = null;
+    for (let attempt = 0; attempt <= TRACE_RETRY_ATTEMPTS; attempt++) {
+      try {
+        await this.traces.create(payload);
+        return;
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (attempt < TRACE_RETRY_ATTEMPTS) {
+          await this.delay(TRACE_RETRY_DELAY_MS * (attempt + 1));
+        }
+      }
+    }
+    if (this.onTraceError && lastError) {
+      this.onTraceError(lastError, traceId);
+    }
+  }
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  interpolateMessages(messages, variables) {
+    if (!variables) return messages;
+    return messages.map((message) => {
+      if (typeof message.content === "string") {
+        return {
+          ...message,
+          content: message.content.replace(
+            /\{\{(\w+)\}\}/g,
+            (match, key) => variables[key] ?? match
+          )
+        };
+      }
+      if (message.role === "tool") {
+        return message;
+      }
+      return {
+        ...message,
+        content: message.content.map((block) => {
+          if (block.type === "text") {
+            return {
+              ...block,
+              text: block.text.replace(
+                /\{\{(\w+)\}\}/g,
+                (match, key) => variables[key] ?? match
+              )
+            };
+          }
+          return block;
+        })
+      };
+    });
+  }
+  buildAssistantMessage(text, toolCalls) {
+    if (toolCalls.length === 0) {
+      return { role: "assistant", content: text };
+    }
+    const contentParts = [];
+    if (text) {
+      contentParts.push({ type: "text", text });
+    }
+    for (const toolCall of toolCalls) {
+      contentParts.push({
+        type: "tool_call",
+        id: toolCall.id,
+        name: toolCall.name,
+        arguments: toolCall.arguments
+      });
+    }
+    return { role: "assistant", content: contentParts };
+  }
+  getProviderApiKey(provider, override) {
+    if (override) return override;
+    const envVar = ENV_VAR_MAP[provider];
+    const key = process.env[envVar];
+    if (!key) {
+      throw new TraciaError(
+        "MISSING_PROVIDER_API_KEY" /* MISSING_PROVIDER_API_KEY */,
+        `Missing API key for ${provider}. Set the ${envVar} environment variable or provide providerApiKey in options.`
+      );
+    }
+    return key;
   }
 };
 export {
+  Eval,
+  LLMProvider,
   Tracia,
   TraciaError,
   TraciaErrorCode