@gammatech/aijsx 0.5.0-beta.1 → 0.5.0-dev.2024-03-12

package/dist/index.mjs

@@ -211,29 +211,30 @@ function coalesceParallelStreams(streams) {
   return iter;
 }
 
-// src/logging/log.ts
+// src/log.ts
 var LogImplementation = class {
   loggedExceptions = /* @__PURE__ */ new WeakMap();
-  chatCompletionRequest(provider, payload) {
-  }
-  chatCompletionResponse(provider, payload) {
-  }
   /**
    * Logs exceptions thrown during an element's render.
    */
-  logException(exception) {
+  logException(ctx, exception) {
     if (typeof exception === "object" && exception !== null) {
       if (this.loggedExceptions.has(exception)) {
         return;
       }
       this.loggedExceptions.set(exception, true);
     }
-    this.log("error", `AIJSX Exception: ${exception}`);
+    this.log(ctx, "error", `Rendering failed with exception: ${exception}`);
+  }
+  chatCompletionRequest(_ctx, _provider, _payload) {
+  }
+  chatCompletionResponse(_ctx, _provider, _payload) {
   }
 };
 var BoundLogger = class {
-  constructor(impl) {
+  constructor(impl, ctx) {
     this.impl = impl;
+    this.ctx = ctx;
   }
   formatMessage = (...msgs) => msgs.map((m) => {
     if (typeof m === "string") {
@@ -250,24 +251,24 @@ var BoundLogger = class {
       return JSON.stringify(m);
     }
   }).join(" ");
-  error = (...msgs) => this.impl.log("error", this.formatMessage(...msgs));
-  warn = (...msgs) => this.impl.log("warn", this.formatMessage(...msgs));
-  info = (...msgs) => this.impl.log("info", this.formatMessage(...msgs));
-  debug = (...msgs) => this.impl.log("debug", this.formatMessage(...msgs));
-  logException = (exception) => this.impl.logException(exception);
+  error = (...msgs) => this.impl.log(this.ctx, "error", this.formatMessage(...msgs));
+  warn = (...msgs) => this.impl.log(this.ctx, "warn", this.formatMessage(...msgs));
+  info = (...msgs) => this.impl.log(this.ctx, "info", this.formatMessage(...msgs));
+  debug = (...msgs) => this.impl.log(this.ctx, "debug", this.formatMessage(...msgs));
+  logException = (exception) => this.impl.logException(this.ctx, exception);
   chatCompletionRequest = (provider, payload) => {
-    return this.impl.chatCompletionRequest(provider, payload);
+    return this.impl.chatCompletionRequest(this.ctx, provider, payload);
   };
   chatCompletionResponse = (provider, payload) => {
-    return this.impl.chatCompletionResponse(provider, payload);
+    return this.impl.chatCompletionResponse(this.ctx, provider, payload);
   };
 };
 var NoopLogImplementation = class extends LogImplementation {
-  log(level, message) {
+  log(_ctx, _level, _message) {
   }
 };
 var ConsoleLogger = class extends LogImplementation {
-  log(level, message) {
+  log(ctx, level, message) {
     console.log(`[${level}] ${message}`);
   }
 };
@@ -279,9 +280,6 @@ var CombinedLogger = class extends LogImplementation {
   log(...args) {
     this.loggers.forEach((l) => l.log(...args));
   }
-  logException(...args) {
-    this.loggers.forEach((l) => l.logException(...args));
-  }
   chatCompletionRequest(...args) {
     this.loggers.forEach((l) => l.chatCompletionRequest(...args));
   }
@@ -291,10 +289,6 @@ var CombinedLogger = class extends LogImplementation {
 };
 
 // src/prompt/errors.ts
-var PromptParseVariablesError = class extends Error {
-};
-var ChainParseVariablesError = class extends Error {
-};
 var ParseVariablesError = class extends Error {
 };
 var PromptInvalidOutputError = class extends Error {
@@ -303,121 +297,25 @@ var PromptInvalidOutputError = class extends Error {
 // src/prompt/parseVariables.ts
 function parseVariables(schema, variables) {
   try {
-    return { success: true, result: schema.parse(variables) };
+    return { parsedVariables: schema.parse(variables), error: null };
   } catch (err) {
     let error = err;
     if (err && typeof err === "object" && "flatten" in err) {
       const errorMessage = JSON.stringify(err.flatten());
       error = new ParseVariablesError(errorMessage);
     }
-    return { success: false, error };
+    return { parsedVariables: null, error };
   }
 }
 
-// src/render.ts
-function renderLiteral(renderable) {
-  if (typeof renderable === "string") {
-    return renderable;
-  }
-  if (typeof renderable === "number") {
-    return renderable.toString();
-  }
-  if (typeof renderable === "undefined" || typeof renderable === "boolean" || renderable === null) {
-    return "";
-  }
-  return "";
-}
-function createRenderContext({
-  parentSpanId = null,
-  logger = new NoopLogImplementation(),
-  traceId = null,
-  contextValues = {}
-} = {}) {
-  let spanContext = {};
-  if (traceId || parentSpanId) {
-    spanContext = {
-      traceId: traceId || void 0,
-      // set to invalid span id to make sure the span
-      // isn't mistakenly tagged for having a parent
-      spanId: parentSpanId || ""
-    };
-  }
-  return new StreamRenderContext(logger, contextValues, spanContext);
-}
-
-// src/RenderResult.ts
-var accumResults = async (result) => {
-  let accum = "";
-  const iterator = result[Symbol.asyncIterator]();
-  for await (const value of iterator) {
-    accum += value;
-  }
-  return accum;
-};
-var GeneratorRenderResult = class {
-  // this promise like thing
-  constructor(generator) {
-    this.generator = generator;
-  }
-  accumPromise = void 0;
-  async next(...args) {
-    return this.generator.next(...args);
-  }
-  async return(value) {
-    return this.generator.return(value);
-  }
-  throw(e) {
-    return this.generator.throw(e);
-  }
-  [Symbol.asyncIterator]() {
-    return this;
-  }
-  then(onFulfilled, onRejected) {
-    if (!this.accumPromise) {
-      this.accumPromise = accumResults(this);
-    }
-    return this.accumPromise.then(onFulfilled, onRejected);
-  }
-};
-var AccumulatedRenderResult = class extends GeneratorRenderResult {
-  constructor(generator, cbs) {
-    super(generator);
-    this.generator = generator;
-    this.cbs = cbs;
-  }
-  accumulated = "";
-  async next(...args) {
-    let ret;
-    try {
-      ret = await this.generator.next(...args);
-    } catch (e) {
-      this.cbs.onError(e);
-      throw e;
-    }
-    const { done, value } = ret;
-    if (done) {
-      this.cbs.onDone(this.accumulated);
-    }
-    this.accumulated += value;
-    if (done) {
-      return { value: void 0, done: true };
-    }
-    return { value, done: false };
-  }
-  async throw(e) {
-    this.cbs.onError(e);
-    return this.generator.throw(e);
-  }
-};
-
-// src/tracing/types/TracingContext.ts
+// src/tracing/TracingContext.ts
 function createContextKey(description) {
   return {
     key: Symbol.for(description)
   };
 }
 var BaseTracingContext = class _BaseTracingContext {
-  _currentContext;
+  current;
   /**
    * Construct a new context which inherits values from an optional parent context.
    *
@@ -425,16 +323,16 @@ var BaseTracingContext = class _BaseTracingContext {
    */
   constructor(parentContext) {
     const self = this;
-    self._currentContext = parentContext ? new Map(parentContext) : /* @__PURE__ */ new Map();
-    self.getValue = ({ key }) => self._currentContext.get(key);
+    self.current = parentContext ? new Map(parentContext) : /* @__PURE__ */ new Map();
+    self.getValue = ({ key }) => self.current.get(key);
     self.setValue = ({ key }, value) => {
-      const context = new _BaseTracingContext(self._currentContext);
-      context._currentContext.set(key, value);
+      const context = new _BaseTracingContext(self.current);
+      context.current.set(key, value);
       return context;
     };
     self.deleteValue = ({ key }) => {
-      const context = new _BaseTracingContext(self._currentContext);
-      context._currentContext.delete(key);
+      const context = new _BaseTracingContext(self.current);
+      context.current.delete(key);
       return context;
     };
   }
@@ -460,8 +358,6 @@ var BaseTracingContext = class _BaseTracingContext {
    */
   deleteValue;
 };
-
-// src/tracing/TracingContextManager.ts
 var ROOT_CONTEXT = new BaseTracingContext();
 var NoopTracingContextManager = class {
   active() {
@@ -521,26 +417,25 @@ var ContextAPI = class _ContextAPI {
   with(context, fn, ...args) {
     return this.getContextManager().with(context, fn, ...args);
   }
+  enable() {
+    this.manager.enable();
+  }
+  disable() {
+    this.manager.disable();
+  }
   /**
    * Bind a context to a target function or event emitter
    *
    * @param context context to bind to the event emitter or function. Defaults to the currently active context
    * @param target function or event emitter to bind
    */
-  bind(context, target) {
-    return this.getContextManager().bind(context, target);
+  bind(target, context) {
+    const ctx = context || this.active();
+    return this.getContextManager().bind(ctx, target);
   }
   getContextManager() {
     return this.manager || NOOP_CONTEXT_MANAGER;
   }
-  /** Disable and remove the global context manager */
-  disable() {
-    this.getContextManager().disable();
-    this.manager = NOOP_CONTEXT_MANAGER;
-  }
-  reset() {
-    this.manager = NOOP_CONTEXT_MANAGER;
-  }
 };
 var contextApi = ContextAPI.getInstance();
 
@@ -550,13 +445,16 @@ var HrTime = class _HrTime {
     this.time = time;
     this.time = time;
   }
+  static from(time) {
+    return new _HrTime(time);
+  }
   static now() {
     const timeOrigin = performance.timeOrigin;
     const now = performance.now();
     const totalNanoseconds = timeOrigin * 1e6 + now * 1e6;
     const seconds = Math.floor(totalNanoseconds / 1e9);
     const nanoseconds = totalNanoseconds % 1e9;
-    return new _HrTime([seconds, Math.floor(nanoseconds)]);
+    return [seconds, Math.floor(nanoseconds)];
   }
   toISOString() {
     const milliseconds = this.time[0] * 1e3 + this.time[1] / 1e6;
@@ -571,61 +469,39 @@ var HrTime = class _HrTime {
 };
 
 // src/tracing/AISpan.ts
-var SPAN_KEY = createContextKey("SPAN KEY");
+var SPAN_KEY = createContextKey("AIJSX SPAN");
 var AISpan = class {
-  constructor(spanProcessorProvider, context, spanName, spanContext, parentSpanId, startTime, attributes) {
-    this.spanProcessorProvider = spanProcessorProvider;
-    this.name = spanName;
-    this._spanContext = spanContext;
-    this.parentSpanId = parentSpanId;
-    this.startHrTime = startTime || HrTime.now();
-    this.startTime = this.startHrTime.toISOString();
-    if (attributes != null) {
-      this.setAttributes(attributes);
-    }
-    const processors = spanProcessorProvider.getSpanProcessors();
-    processors.forEach((processor) => {
-      processor.onStart(this, context);
-    });
-  }
-  _spanContext;
+  name;
+  status = "unset";
+  spanContext;
   parentSpanId;
   attributes = {};
-  data = {};
   events = [];
-  //timing
   startTime;
-  startHrTime;
   endTime = null;
-  endHrTime = null;
+  startTimestamp;
+  endTimestamp = null;
+  ended = false;
   duration = -1;
-  name;
-  _ended = false;
-  status = {
-    code: 0 /* UNSET */
-  };
-  spanContext() {
-    return this._spanContext;
-  }
-  setAttribute(key, value) {
-    if (value == null || this._isSpanEnded())
-      return this;
-    this.attributes[key] = value;
-    return this;
+  processor;
+  constructor(opts) {
+    this.name = opts.name;
+    this.spanContext = opts.spanContext;
+    this.parentSpanId = opts.parentSpanId;
+    this.startTimestamp = opts.startTime || HrTime.now();
+    this.startTime = new HrTime(this.startTimestamp).toISOString();
+    this.processor = opts.processor;
+    if (opts.attributes != null) {
+      this.setAttributes(opts.attributes);
+    }
+    this.processor?.onStart?.(this);
   }
   setAttributes(attributes) {
     for (const [k, v] of Object.entries(attributes)) {
-      this.setAttribute(k, v);
+      this.attributes[k] = v;
     }
     return this;
   }
-  setData(key, value) {
-    this.data[key] = value;
-    return this;
-  }
-  getData(key) {
-    return this.data[key];
-  }
   /**
    *
    * @param name Span Name
@@ -634,46 +510,40 @@ var AISpan = class {
    * @param [timeStamp] Specified time stamp for the event
    */
   addEvent(name, attributes, startTime = HrTime.now()) {
-    if (this._isSpanEnded())
+    if (this.ended)
       return this;
-    this.events.push({
-      timestamp: startTime.toISOString(),
-      time: startTime.time,
+    const event = {
       name,
-      attributes
-    });
-    return this;
-  }
-  setStatus(status) {
-    if (this._isSpanEnded())
-      return this;
-    this.status = status;
-    return this;
-  }
-  updateName(name) {
-    if (this._isSpanEnded())
-      return this;
-    this.name = name;
+      attributes,
+      timestamp: new HrTime(startTime).toISOString(),
+      time: startTime
+    };
+    this.events.push(event);
+    if (name === "exception") {
+      this.processor?.onSpanException?.(event, this);
+    } else {
+      this.processor?.onSpanEvent?.(event, this);
+    }
     return this;
   }
-  end(endHrTime = HrTime.now()) {
-    if (this._isSpanEnded()) {
+  end(endTime = HrTime.now()) {
+    if (this.ended) {
       return;
     }
-    this._ended = true;
-    this.endHrTime = endHrTime;
+    if (this.status === "unset") {
+      this.status = "ok";
+    }
+    this.ended = true;
+    const endHrTime = new HrTime(endTime);
+    const startHrTime = new HrTime(this.startTimestamp);
+    this.endTimestamp = endHrTime.time;
     this.endTime = endHrTime.toISOString();
-    this.duration = endHrTime.minus(this.startHrTime);
-    const processors = this.spanProcessorProvider.getSpanProcessors();
-    processors.forEach((processor) => {
-      processor.onEnd(this);
-    });
-  }
-  isRecording() {
-    return this._ended === false;
+    this.duration = endHrTime.minus(startHrTime);
+    this.processor?.onEnd?.(this);
   }
   recordException(exception, time = HrTime.now()) {
     let attributes = {};
+    this.status = "error";
     if (typeof exception === "string") {
       attributes = {
         name: "Error",
@@ -688,18 +558,83 @@ var AISpan = class {
     }
     return this.addEvent("exception", attributes, time);
   }
-  get ended() {
-    return this._ended;
+};
+var NoopSpan = class extends AISpan {
+  constructor() {
+    super({
+      name: "noop-span",
+      spanContext: {
+        traceId: "",
+        spanId: ""
+      },
+      parentSpanId: null
+    });
   }
-  _isSpanEnded() {
-    return this._ended;
+};
+
+// src/tracing/utils/BoundAsyncGenerator.ts
+var BoundAsyncGenerator = class {
+  generator;
+  onDone;
+  onError;
+  constructor(generator, cbs) {
+    this.generator = contextApi.bind(generator);
+    if (cbs.onDone) {
+      this.onDone = cbs.onDone;
+    }
+    if (cbs.onError) {
+      this.onError = cbs.onError;
+    }
+  }
+  async next(...args) {
+    try {
+      const result = await this.generator.next(...args);
+      if (result.done) {
+        this.onDone?.();
+      }
+      return result;
+    } catch (e) {
+      this.onError?.(e);
+      throw e;
+    }
+  }
+  async return(value) {
+    return this.generator.return(value);
+  }
+  throw(e) {
+    return this.generator.throw(e);
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+};
+var BoundRenderResult = class extends BoundAsyncGenerator {
+  constructor(renderResult, cbs) {
+    super(renderResult, cbs);
+    this.renderResult = renderResult;
+  }
+  then(onFulfilled, onRejected) {
+    return this.renderResult.then(
+      (val) => {
+        this.onDone?.();
+        if (!onFulfilled) {
+          return val;
+        }
+        return onFulfilled?.(val);
+      },
+      (err) => {
+        this.onError?.(err);
+        if (!onRejected) {
+          throw err;
+        }
+        return onRejected?.(err);
+      }
+    );
   }
 };
 
 // src/tracing/utils/id.ts
 import { customAlphabet } from "nanoid";
-var INVALID_SPANID = "0000000000000000";
-var INVALID_TRACEID = "00000000000000000000000000000000";
 var hexAlphabet = "0123456789abcdef";
 var traceIdSize = 32;
 var spanIdSize = 16;
@@ -707,250 +642,182 @@ var idGenerator = {
   traceId: customAlphabet(hexAlphabet, traceIdSize),
   spanId: customAlphabet(hexAlphabet, spanIdSize)
 };
-function isValidTraceId(traceId) {
-  return traceId !== INVALID_TRACEID;
-}
-function isValidSpanId(spanId) {
-  return spanId !== INVALID_SPANID;
-}
-function isSpanContextValid(spanContext) {
-  return isValidTraceId(spanContext.traceId) && isValidSpanId(spanContext.spanId);
-}
-
-// src/tracing/NonRecordingSpan.ts
-var INVALID_SPAN_CONTEXT = {
-  traceId: INVALID_TRACEID,
-  spanId: INVALID_SPANID
-};
-var NonRecordingSpan = class {
-  constructor(_spanContext = INVALID_SPAN_CONTEXT) {
-    this._spanContext = _spanContext;
-  }
-  name = "non-recording-span";
-  attributes = {};
-  data = {};
-  events = [];
-  startTime = (/* @__PURE__ */ new Date()).toISOString();
-  endTime = null;
-  duration = -1;
-  parentSpanId = null;
-  setData(key, value) {
-    this.data[key] = value;
-    return this;
-  }
-  getData(key) {
-    return this.data[key];
-  }
-  // Returns a SpanContext.
-  spanContext() {
-    return this._spanContext;
-  }
-  // By default does nothing
-  setAttribute(_key, _value) {
-    return this;
-  }
-  // By default does nothing
-  setAttributes(_attributes) {
-    return this;
-  }
-  // By default does nothing
-  addEvent(_name, _attributes, _startTime) {
-    return this;
-  }
-  // By default does nothing
-  setStatus(_status) {
-    return this;
-  }
-  // By default does nothing
-  updateName(_name) {
-    return this;
-  }
-  // By default does nothing
-  end(_endTime) {
-  }
-  // isRecording always returns false for NonRecordingSpan.
-  isRecording() {
-    return false;
-  }
-  // By default does nothing
-  recordException(exception, time) {
-    return this;
-  }
-};
 
 // src/tracing/AITracer.ts
 var AITracer = class {
+  traceId;
+  processor;
   /**
    * Constructs a new Tracer instance.
    */
-  constructor(spanProcessorProvider) {
-    this.spanProcessorProvider = spanProcessorProvider;
+  constructor({
+    traceId,
+    processor
+  } = {}) {
+    this.traceId = traceId || idGenerator.traceId();
+    this.processor = processor;
   }
   /**
    * Starts a new Span or returns the default NoopSpan based on the sampling
    * decision.
    */
-  startSpan(name, options = {}, context = contextApi.active()) {
-    if (options.root) {
-      context = context.deleteValue(SPAN_KEY);
-    }
-    const parentSpan = context.getValue(SPAN_KEY);
-    const parentSpanContext = parentSpan?.spanContext();
+  createSpan(name, attributes = {}) {
+    const traceId = this.traceId;
     const spanId = idGenerator.spanId();
-    let traceId;
-    let parentSpanId = null;
-    if (!parentSpanContext) {
-      traceId = idGenerator.traceId();
-    } else {
-      traceId = isValidTraceId(parentSpanContext.traceId) ? parentSpanContext.traceId : idGenerator.traceId();
-      parentSpanId = isValidSpanId(parentSpanContext.spanId) ? parentSpanContext.spanId : null;
-    }
-    const spanContext = { traceId, spanId };
-    const span = new AISpan(
-      this.spanProcessorProvider,
-      context,
+    const parentSpan = contextApi.active().getValue(SPAN_KEY);
+    const parentSpanId = parentSpan ? parentSpan.spanContext.spanId : null;
+    const span = new AISpan({
       name,
-      spanContext,
+      spanContext: { traceId, spanId },
       parentSpanId,
-      void 0,
-      // auto compute start time
-      options.attributes
-    );
+      processor: this.processor,
+      attributes
+    });
     return span;
   }
-  startActiveSpan(name, arg2, arg3, arg4) {
-    let opts;
-    let ctx;
-    let fn;
-    if (arguments.length < 2) {
-      return;
-    } else if (arguments.length === 2) {
-      fn = arg2;
-    } else if (arguments.length === 3) {
-      opts = arg2;
-      fn = arg3;
-    } else {
-      opts = arg2;
-      ctx = arg3;
-      fn = arg4;
-    }
-    const activeContext = ctx || contextApi.active();
-    const span = this.startSpan(name, opts, activeContext);
-    const newContext = activeContext.setValue(SPAN_KEY, span);
+  startSpan(name, attributes, fn) {
+    const span = this.createSpan(name, attributes);
+    const newContext = contextApi.active().setValue(SPAN_KEY, span);
     return contextApi.with(newContext, fn, span);
   }
+  trace(name, attributes, fn) {
+    return this.startSpan(name, attributes, (span) => {
+      const onError = (e) => {
+        span.recordException(e);
+        span.end();
+      };
+      const onDone = () => {
+        span.end();
+      };
+      try {
+        const result = fn(span);
+        if (isRenderResult(result)) {
+          return new BoundRenderResult(result, {
+            onDone,
+            onError
+          });
+        }
+        if (isGenerator(result)) {
+          return new BoundAsyncGenerator(result, {
+            onDone,
+            onError
+          });
+        }
+        if (isPromise(result)) {
+          return result.then(
+            (val) => {
+              onDone();
+              return val;
+            },
+            (e) => {
+              onError(e);
+              throw e;
+            }
+          );
+        }
+        onDone();
+        return result;
+      } catch (e) {
+        onError(e);
+        throw e;
+      }
+      throw new Error("Did not return result");
+    });
+  }
   getActiveSpan() {
     const res = contextApi.active().getValue(SPAN_KEY);
-    return res;
+    return res || null;
   }
-  setSpanContext(spanContext) {
-    const ctx = contextApi.active().setValue(SPAN_KEY, new NonRecordingSpan(spanContext));
-    return ctx;
+  bind(target) {
+    return contextApi.bind(target);
   }
 };
-
-// src/tracing/NoopTracer.ts
+function isRenderResult(val) {
+  return isGenerator(val) && isPromise(val);
+}
+function isGenerator(val) {
+  return Boolean(
+    val && typeof val === "object" && "next" in val && "throw" in val && "return" in val && Symbol.asyncIterator in val
+  );
+}
+var isPromise = (val) => {
+  return Boolean(val && typeof val === "object" && "then" in val);
+};
 var NoopTracer = class {
-  // startSpan starts a noop span.
-  startSpan(name, options, context = contextApi.active()) {
-    const root = Boolean(options?.root);
-    if (root) {
-      return new NonRecordingSpan();
-    }
-    const parentFromContext = context && context.getValue(SPAN_KEY);
-    if (isSpanContext(parentFromContext) && isSpanContextValid(parentFromContext)) {
-      return new NonRecordingSpan(parentFromContext);
-    } else {
-      return new NonRecordingSpan();
-    }
-  }
-  startActiveSpan(name, arg2, arg3, arg4) {
-    let opts;
-    let ctx;
-    let fn;
-    if (arguments.length < 2) {
-      return;
-    } else if (arguments.length === 2) {
-      fn = arg2;
-    } else if (arguments.length === 3) {
-      opts = arg2;
-      fn = arg3;
-    } else {
-      opts = arg2;
-      ctx = arg3;
-      fn = arg4;
-    }
-    const parentContext = ctx ?? contextApi.active();
-    const span = this.startSpan(name, opts, parentContext);
-    const contextWithSpanSet = parentContext.setValue(SPAN_KEY, span);
-    return contextApi.with(contextWithSpanSet, fn, span);
-  }
   getActiveSpan() {
-    return contextApi.active().getValue(SPAN_KEY);
+    return null;
   }
-  setSpanContext(spanContext) {
-    return contextApi.active().setValue(SPAN_KEY, new NonRecordingSpan(spanContext));
+  trace(_name, _attributes, fn) {
+    const span = new NoopSpan();
+    return fn(span);
   }
 };
-function isSpanContext(spanContext) {
-  return typeof spanContext === "object" && typeof spanContext["spanId"] === "string" && typeof spanContext["traceId"] === "string" && typeof spanContext["traceFlags"] === "number";
-}
 
-// src/tracing/SpanProcessorProvider.ts
-var SpanProcessorProvider = class {
-  processors = [];
-  setSpanProcessors(processors) {
-    this.processors = processors;
+// src/tracing/AsyncLocalStorageContextManager.ts
+import { AsyncLocalStorage } from "async_hooks";
+var isAsyncGenerator = (obj) => obj != null && typeof obj === "object" && "next" in obj && "return" in obj && "throw" in obj && Symbol.asyncIterator in obj;
+var AsyncLocalStorageContextManager = class {
+  asyncLocalStorage;
+  constructor() {
+    this.asyncLocalStorage = new AsyncLocalStorage();
   }
-  getSpanProcessors() {
-    return this.processors;
+  active() {
+    return this.asyncLocalStorage.getStore() ?? ROOT_CONTEXT;
   }
-};
-
-// src/tracing/api/traceApi.ts
-var TraceAPI = class _TraceAPI {
-  static _instance;
-  spanProcessorProvider = new SpanProcessorProvider();
-  tracer = new AITracer(this.spanProcessorProvider);
-  /** Empty private constructor prevents end users from constructing a new instance of the API */
-  constructor() {
+  with(context, fn, ...args) {
+    return this.asyncLocalStorage.run(context, () => {
+      const result = fn(...args);
+      return result;
+    });
   }
-  /** Get the singleton instance of the Trace API */
-  static getInstance() {
-    if (!this._instance) {
-      this._instance = new _TraceAPI();
-    }
-    return this._instance;
+  enable() {
+    return this;
   }
-  setTracer(tracer) {
-    this.tracer = tracer;
+  disable() {
+    this.asyncLocalStorage.disable();
+    return this;
   }
   /**
-   * Returns a tracer from the global tracer provider.
+   * Binds a the certain context or the active one to the target function and then returns the target
+   * @param context A context (span) to be bind to target
+   * @param target a function or event emitter. When target or one of its callbacks is called,
+   *  the provided context will be used as the active context for the duration of the call.
    */
-  getTracer() {
-    return this.tracer;
-  }
-  /** Remove the global tracer provider */
-  disable() {
-    this.tracer = new NoopTracer();
+  bind(context, target) {
+    if (typeof target === "function") {
+      return this.bindFunction(context, target);
+    }
+    if (isAsyncGenerator(target)) {
+      return this.bindAsyncGenerator(target);
+    }
+    return target;
   }
-  setSpanProcessors(spanProcessors) {
-    this.spanProcessorProvider.setSpanProcessors(spanProcessors);
+  bindFunction(context, target) {
+    const manager = this;
+    const contextWrapper = function(...args) {
+      return manager.with(context, () => target.apply(this, args));
+    };
+    Object.defineProperty(contextWrapper, "length", {
+      enumerable: false,
+      configurable: true,
+      writable: false,
+      value: target.length
+    });
+    return contextWrapper;
   }
-  reset() {
-    this.spanProcessorProvider = new SpanProcessorProvider();
-    this.tracer = new AITracer(this.spanProcessorProvider);
+  bindAsyncGenerator(generator) {
+    generator.next = this.bindFunction(this.active(), generator.next);
+    return generator;
   }
 };
-var traceApi = TraceAPI.getInstance();
 
 // src/tracing/api/index.ts
 var AITraceAPI = class _AITraceAPI {
   static _instance;
-  initialized = false;
+  enabled = false;
   /** Empty private constructor prevents end users from constructing a new instance of the API */
   constructor() {
+    this.enable();
   }
   /** Get the singleton instance of the Trace API */
   static getInstance() {
@@ -959,40 +826,102 @@ var AITraceAPI = class _AITraceAPI {
     }
     return this._instance;
   }
-  init(options) {
-    if (this.initialized) {
-      throw new Error("Tracing can only be initialized once");
-    }
-    const processors = options.spanProcessors || [];
-    traceApi.setSpanProcessors(processors);
-    if (options.contextManager) {
-      contextApi.setContextManager(options.contextManager);
-    }
-    this.initialized = true;
-    return this.getTracer();
-  }
-  getTracer() {
-    return traceApi.getTracer();
+  createTracer(opts = {}) {
+    return this.enabled ? new AITracer(opts) : new NoopTracer();
   }
-  getActiveContext() {
-    return contextApi.active();
-  }
-  reset() {
-    this.initialized = false;
-    traceApi.reset();
-    contextApi.reset();
+  enable() {
+    this.enabled = true;
+    contextApi.setContextManager(new AsyncLocalStorageContextManager());
+    contextApi.disable();
   }
   disable() {
-    traceApi.disable();
+    this.enabled = false;
+    contextApi.setContextManager(NOOP_CONTEXT_MANAGER);
     contextApi.disable();
   }
-  bind(target) {
-    const activeContext = contextApi.active();
-    return contextApi.bind(activeContext, target);
-  }
 };
 var tracing = AITraceAPI.getInstance();
 
+// src/render.ts
+function renderLiteral(renderable) {
+  if (typeof renderable === "string") {
+    return renderable;
+  }
+  if (typeof renderable === "number") {
+    return renderable.toString();
+  }
+  if (typeof renderable === "undefined" || typeof renderable === "boolean" || renderable === null) {
+    return "";
+  }
+  return "";
+}
+function createRenderContext({
+  logger = new NoopLogImplementation(),
+  traceId,
+  processor,
+  contextValues = {}
+} = {}) {
+  const tracer = tracing.createTracer({
+    traceId,
+    processor
+  });
+  return new StreamRenderContext(tracer, logger, contextValues);
+}
+
+// src/RenderResult.ts
+var accumResults = async (result) => {
+  let accum = "";
+  const iterator = result[Symbol.asyncIterator]();
+  for await (const value of iterator) {
+    accum += value;
+  }
+  return accum;
+};
+var GeneratorRenderResult = class {
+  // this promise like thing
+  constructor(generator) {
+    this.generator = generator;
+  }
+  accumPromise = void 0;
+  async next(...args) {
+    return this.generator.next(...args);
+  }
+  async return(value) {
+    return this.generator.return(value);
+  }
+  throw(e) {
+    return this.generator.throw(e);
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+  then(onFulfilled, onRejected) {
+    if (!this.accumPromise) {
+      this.accumPromise = accumResults(this);
+    }
+    return this.accumPromise.then(onFulfilled, onRejected);
+  }
+};
+var AccumulatedRenderResult = class extends GeneratorRenderResult {
+  constructor(generator, onDone) {
+    super(generator);
+    this.generator = generator;
+    this.onDone = onDone;
+  }
+  accumulated = "";
+  async next(...args) {
+    const { done, value } = await this.generator.next(...args);
+    if (done) {
+      this.onDone(this.accumulated);
+    }
+    this.accumulated += value;
+    if (done) {
+      return { value: void 0, done: true };
+    }
+    return { done: false, value };
+  }
+};
+
 // src/types.ts
 var attachedContextSymbol = Symbol("AI.attachedContext");
 
@@ -1078,6 +1007,9 @@ function parseXml(input) {
     const attributeName = Object.keys(nodeObject)[1];
     const childObjects = nodeObject[nodeName];
     const attributes = Object.entries(nodeObject[attributeName] || {}).reduce((acc, [key, value]) => {
+      if (!value) {
+        return acc;
+      }
       try {
         acc[key] = JSON.parse(value);
       } catch (e) {
@@ -1095,57 +1027,56 @@ function parseXml(input) {
   return constructNode(null, parsed[0]);
 }
 function escape(html) {
+  if (!html) {
+    return "";
+  }
   return html.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
 
 // src/context.tsx
 var StreamRenderContext = class _StreamRenderContext {
-  constructor(logImplementation, contextValues, rootTraceContext) {
-    this.logImplementation = logImplementation;
+  constructor(tracer, logImpl, contextValues) {
+    this.tracer = tracer;
+    this.logImpl = logImpl;
     this.contextValues = contextValues;
-    this.rootTraceContext = rootTraceContext;
     const self = this;
-    this.logger = new BoundLogger(logImplementation);
+    this.logger = new BoundLogger(logImpl, this);
     this.render = this.render.bind(this);
-    this.runChain = this.runChain.bind(this);
-    this.renderElement = (...args) => {
-      const generator = renderElementInternal(...args);
-      return tracing.bind(generator);
-    };
-    async function* renderElementInternal(element, opts = {}) {
+    this.renderElement = async function* (renderable, opts = {}) {
       const span = self.tracer.getActiveSpan();
       const preserveTags = opts.preserveTags ?? false;
       const renderedProps = opts.renderedProps || {};
       const renderEscaped = (val) => {
         return preserveTags ? escape(val) : val;
       };
-      if (isLiteral(element)) {
-        yield renderEscaped(renderLiteral(element));
+      if (isLiteral(renderable)) {
+        yield renderEscaped(renderLiteral(renderable));
         return;
       }
-      if (isAIElement(element)) {
-        const newCtx = self.enterElement(attachedContextValues(element) || {});
-        const isFragment = element.tag.name === "AIFragment";
+      if (isAIElement(renderable)) {
+        const newCtx = self.enterElement(renderable);
+        const logger = newCtx.logger;
+        const isFragment = renderable.tag.name === "AIFragment";
         try {
           if (preserveTags && !isFragment) {
-            yield renderOpenTag(element, renderedProps);
+            yield renderOpenTag(renderable, renderedProps);
           }
-          yield* newCtx.renderElement(element.render(newCtx), opts);
+          yield* newCtx.renderElement(renderable.render(newCtx), opts);
           if (preserveTags && !isFragment) {
-            yield renderCloseTag(element);
+            yield renderCloseTag(renderable);
           }
           return;
         } catch (ex) {
-          span?.recordException(ex);
+          logger.logException(ex);
           throw ex;
         }
       }
-      if (Array.isArray(element)) {
-        if (element.every((r) => isLiteral(r))) {
-          yield element.map((r) => renderEscaped(renderLiteral(r))).join("");
+      if (Array.isArray(renderable)) {
+        if (renderable.every((r) => isLiteral(r))) {
+          yield renderable.map((r) => renderEscaped(renderLiteral(r))).join("");
           return;
         }
-        const streams = element.filter((a) => !!a).map((r) => self.renderElement(r, opts));
+        const streams = renderable.filter((a) => !!a).map((r) => self.renderElement(r, opts));
         const result = coalesceParallelStreams(streams);
         while (true) {
           const { value, done } = await result.next();
@@ -1155,201 +1086,140 @@ var StreamRenderContext = class _StreamRenderContext {
           yield value;
         }
       }
-      if (Symbol.asyncIterator in element) {
-        return yield* element[Symbol.asyncIterator]();
+      if (Symbol.asyncIterator in renderable) {
+        return yield* renderable[Symbol.asyncIterator]();
       }
-      if (!("then" in element)) {
+      if (!("then" in renderable)) {
         throw new Error(
-          `Unexpected renderable type: ${JSON.stringify(element)}`
+          `Unexpected renderable type: ${JSON.stringify(renderable)}`
         );
       }
-      const next = await element.then(
+      const next = await renderable.then(
         (r) => r
       );
       return yield* self.renderElement(next, opts);
-    }
+    };
   }
   renderElement;
   logger;
-  tracer = tracing.getTracer();
   // Implementation of the overloaded function
   render(arg1, arg2, arg3) {
     switch (true) {
       case (isPromptParsed(arg1) && !!arg2): {
-        return this.trace("ai.prompt", () => {
-          return this.renderPromptParsed(arg1, arg2, arg3 || {});
-        });
+        return this.tracer.trace(
+          "ai.prompt",
+          {
+            prompt: arg1,
+            promptKey: arg1.key,
+            variables: arg2
+          },
+          () => this.renderPromptParsed(arg1, arg2, arg3 || {})
+        );
       }
       case (isPrompt(arg1) && !!arg2): {
-        return this.trace("ai.prompt", () => {
-          return this.renderPrompt(arg1, arg2);
-        });
+        return this.tracer.trace(
+          "ai.prompt",
+          {
+            prompt: arg1,
+            promptKey: arg1.key,
+            variables: arg2
+          },
+          () => this.renderPrompt(arg1, arg2)
+        );
       }
       case (isFunctionChain(arg1) && !!arg2): {
-        return this.trace("ai.chain", () => {
-          return this.runChain(arg1, arg2);
-        });
+        return this.tracer.trace(
+          "ai.chain",
+          { chainKey: arg1.key, chainType: arg1.chainType, variables: arg2 },
+          () => this.runChain(arg1, arg2)
+        );
       }
       case (isStreamChain(arg1) && !!arg2): {
-        return this.trace("ai.chain", () => {
-          return this.runChain(arg1, arg2);
-        });
+        return this.tracer.trace(
+          "ai.chain",
+          { chainKey: arg1.key, chainType: arg1.chainType, variables: arg2 },
+          () => this.runChain(arg1, arg2)
+        );
       }
       default: {
-        return this.trace("ai.component", () => {
-          return new GeneratorRenderResult(
-            this.renderElement(
-              arg1,
-              arg2 || { preserveTags: false }
-            )
-          );
-        });
+        const currentSpan = this.tracer.getActiveSpan();
+        const stream = this.renderElement(
+          arg1,
+          arg2 || { preserveTags: false }
+        );
+        if (currentSpan) {
+          return new GeneratorRenderResult(stream);
+        }
+        return this.tracer.trace(
+          "ai.component",
+          {},
+          (span) => new AccumulatedRenderResult(stream, (output) => {
+            span.setAttributes({
+              output
+            });
+          })
+        );
       }
     }
   }
-  /**
-   * @internal
-   *
-   * Helper method to create a new span and set it as the active span
-   * if there is a rootTraceContext attached, start a different context
-   * with that spanId / traceId as the SpanContext
-   *
-   * This can safely be used other places becuase it depends on the
-   * current active span, and only uses the rootTraceContext if there
-   * is no active span
-   */
-  // TODO(jordan) better typing of this
-  trace(spanName, fn) {
-    const currentSpan = this.tracer.getActiveSpan();
-    const ctx = currentSpan ? tracing.getActiveContext() : this.tracer.setSpanContext({
-      traceId: this.rootTraceContext?.traceId || idGenerator.traceId(),
-      spanId: this.rootTraceContext?.spanId || INVALID_SPANID
-    });
-    return this.tracer.startActiveSpan(spanName, {}, ctx, fn);
-  }
   renderPrompt(prompt, variables) {
-    const span = this.tracer.getActiveSpan();
-    span?.setData("prompt", prompt);
-    span?.setAttributes({
-      promptKey: prompt.key,
-      variables
-    });
     const { schema, component: Component } = prompt;
-    const parsedVariables = parseVariables(schema, variables);
-    if (!parsedVariables.success) {
-      const { error } = parsedVariables;
-      span?.recordException(error).end();
+    const { error, parsedVariables } = parseVariables(schema, variables);
+    if (error) {
       throw error;
     }
-    const generator = this.renderElement(
-      /* @__PURE__ */ jsx(Component, { ...parsedVariables.result }),
-      {}
-    );
-    const result = new AccumulatedRenderResult(generator, {
-      onDone: tracing.bind((output) => {
-        span?.setAttributes({
-          output
-        }).end();
-        return output;
-      }),
-      onError: tracing.bind((error) => {
-        span?.recordException(error).end();
-        throw error;
-      })
+    const generator = this.renderElement(/* @__PURE__ */ jsx(Component, { ...parsedVariables }), {});
+    return new AccumulatedRenderResult(generator, (output) => {
+      this.tracer.getActiveSpan()?.setAttributes({
+        output
+      });
     });
-    return result;
   }
   async renderPromptParsed(prompt, variables, options) {
     const span = this.tracer.getActiveSpan();
-    span?.setData("prompt", prompt);
-    span?.setAttributes({
-      promptKey: prompt.key,
-      variables,
-      renderPromptOptions: options
-    });
     const { validateOutput } = options;
     const { schema, component: Component } = prompt;
-    const parsedVariables = parseVariables(schema, variables);
-    if (!parsedVariables.success) {
-      const { error } = parsedVariables;
-      span?.recordException(error).end();
+    const { error, parsedVariables } = parseVariables(schema, variables);
+    if (error) {
       throw error;
     }
-    try {
-      const stream = this.renderElement(
-        /* @__PURE__ */ jsx(Component, { ...parsedVariables.result })
-      );
-      const output = await accumResults(stream);
-      const parsedOutput = prompt.parse(output);
-      if (validateOutput) {
-        try {
-          prompt.outputSchema.parse(parsedOutput);
-        } catch (err) {
-          if (err && typeof err === "object" && "flatten" in err) {
-            const errors = JSON.stringify(err.flatten());
-            throw new PromptInvalidOutputError("Invalid output: " + errors);
-          }
-          throw err;
-        }
+    const stream = this.renderElement(/* @__PURE__ */ jsx(Component, { ...parsedVariables }));
+    const output = await accumResults(stream);
+    const parsedOutput = prompt.parse(output);
+    span?.setAttributes({
+      output,
+      parsedOutput
+    });
+    if (validateOutput) {
+      try {
+        prompt.outputSchema.parse(parsedOutput);
+      } catch (e) {
+        const err = e;
+        const errors = JSON.stringify(err.flatten());
+        throw new PromptInvalidOutputError("Invalid output: " + errors);
       }
-      span?.setAttributes({
-        output: parsedOutput
-      }).end();
-      return parsedOutput;
-    } catch (error) {
-      span?.recordException(error).end();
-      throw error;
     }
+    return parsedOutput;
   }
   runChain(chain, variables) {
-    const span = this.tracer.getActiveSpan();
-    span?.setData("chain", chain);
-    span?.setAttributes({
-      chainKey: chain.key,
-      variables
-    });
-    const { schema } = chain;
-    const parsedVariables = parseVariables(schema, variables);
-    if (!parsedVariables.success) {
-      const { error } = parsedVariables;
-      span?.recordException(error).end();
+    const { error, parsedVariables } = parseVariables(chain.schema, variables);
+    if (error) {
       throw error;
     }
     if (chain.chainType === "function") {
-      const onChainComplete = (output) => {
-        span?.setAttributes({
-          output
-        }).end();
-      };
-      const onChainError = (error) => {
-        span?.recordException(error).end();
+      const span = this.tracer.getActiveSpan();
+      const onOutput = (output) => {
+        span?.setAttributes({ output });
+        return output;
       };
-      let chainResult;
-      try {
-        chainResult = chain.run(parsedVariables.result, this);
-      } catch (e) {
-        onChainError(e);
-        throw e;
-      }
-      if (chainResult && typeof chainResult === "object" && "then" in chainResult) {
-        chainResult.then(onChainComplete, onChainError);
-        return chainResult;
+      const result = chain.run(parsedVariables, this);
+      if (result && typeof result === "object" && "then" in result) {
+        return result.then(onOutput);
       }
-      onChainComplete(chainResult);
-      return chainResult;
+      return onOutput(result);
     }
     if (chain.chainType === "stream") {
-      try {
-        const stream = chain.run(
-          parsedVariables.result,
-          this
-        );
-        span?.end();
-        return tracing.bind(stream);
-      } catch (error) {
-        span?.recordException(error).end();
-        throw error;
-      }
+      return chain.run(parsedVariables, this);
     }
     throw new Error("Invalid chain type");
   }
@@ -1357,8 +1227,9 @@ var StreamRenderContext = class _StreamRenderContext {
     return this.contextValues[context.key] ?? context.defaultValue;
   };
   // @internal
-  enterElement(newCtx) {
-    return new _StreamRenderContext(this.logImplementation, {
+  enterElement(element) {
+    const newCtx = attachedContextValues(element);
+    return new _StreamRenderContext(this.tracer, this.logImpl, {
       ...this.contextValues,
       ...newCtx
     });
@@ -1409,7 +1280,7 @@ function withContextValues(renderable, additionalContext) {
   );
 }
 function attachedContextValues(element) {
-  return element[attachedContextSymbol];
+  return element[attachedContextSymbol] || {};
 }
 function isPrompt(value) {
   return Boolean(value && typeof value === "object" && "component" in value);
@@ -1445,70 +1316,157 @@ function renderCloseTag(element) {
   return `</${element.tag.name}>`;
 }
 
-// src/tracing/AsyncLocalStorageContextManager.ts
-import { AsyncLocalStorage } from "async_hooks";
-var isAsyncGenerator = (obj) => obj != null && typeof obj === "object" && "next" in obj && "return" in obj && "throw" in obj && Symbol.asyncIterator in obj;
-var AsyncLocalStorageContextManager = class {
-  asyncLocalStorage;
-  constructor() {
-    this.asyncLocalStorage = new AsyncLocalStorage();
+// src/prompt/evaluatePrompt.ts
+async function evaluatePrompt(prompt, variables, result) {
+  const { error, parsedVariables } = parseVariables(prompt.schema, variables);
+  if (error) {
+    throw error;
   }
-  active() {
-    return this.asyncLocalStorage.getStore() ?? ROOT_CONTEXT;
+  return (await Promise.all(
+    prompt.evaluators.map(
+      (evaluator) => evaluator(parsedVariables, result)
+    )
+  )).flat();
+}
+
+// src/tracing/AISpanProcessor.ts
+var EnrichingSpanProcessor = class {
+  constructor(exporter) {
+    this.exporter = exporter;
+    this.onAllDonePromise = new Promise((resolve) => {
+      this.onAllDonePromiseResolve = resolve;
+    });
   }
-  with(context, fn, ...args) {
-    return this.asyncLocalStorage.run(context, () => {
-      const result = fn(...args);
-      return result;
+  finalSpans = [];
+  onAllDonePromise = null;
+  onAllDonePromiseResolve = null;
+  async onStart(span) {
+    this.finalSpans.push({
+      status: "running",
+      span
     });
   }
-  enable() {
-    return this;
+  async onEnd(span) {
+    const entry = this.finalSpans.find(
+      (a) => a.span.spanContext.spanId === span.spanContext.spanId
+    );
+    if (!entry) {
+      throw new Error("onEnd called without onStart");
+    }
+    const enrichedSpan = await this.enrichSpan(span);
+    entry.status = "processing";
+    entry.span = enrichedSpan;
+    entry.status = "done";
+    if (this.finalSpans.every((a) => a.status === "done")) {
+      this.onAllDonePromiseResolve?.();
+    }
+    if (span.parentSpanId == null) {
+      await this.onAllDonePromise;
+      await this.onTraceComplete(enrichedSpan);
+    }
+    this.exporter.export([enrichedSpan]);
   }
-  disable() {
-    this.asyncLocalStorage.disable();
-    return this;
+  shutdown() {
+    return this.exporter.shutdown?.();
+  }
+};
+var AISpanProcessor = class extends EnrichingSpanProcessor {
+  totalCost = 0;
+  totalUsage = {
+    prompt: 0,
+    completion: 0,
+    total: 0
+  };
+  async onTraceComplete(rootSpan) {
+    rootSpan.attributes.totalCost = this.totalCost;
+    rootSpan.attributes.totalUsage = this.totalUsage;
+  }
+  async enrichSpan(span) {
+    const result1 = await this.evaluatePrompt(span);
+    const result2 = await this.updateCost(result1);
+    const result3 = await this.updateUsage(result2);
+    return result3;
+  }
+  async updateCost(span) {
+    if (!isChatCompletionSpan(span)) {
+      return span;
+    }
+    const { cost } = span.attributes;
+    if (typeof cost === "number") {
+      this.totalCost += cost;
+    }
+    return span;
   }
-  /**
-   * Binds a the certain context or the active one to the target function and then returns the target
-   * @param context A context (span) to be bind to target
-   * @param target a function or event emitter. When target or one of its callbacks is called,
-   *  the provided context will be used as the active context for the duration of the call.
-   */
-  bind(context, target) {
-    if (typeof target === "function") {
-      return this.bindFunction(context, target);
+  async updateUsage(span) {
+    if (!isChatCompletionSpan(span)) {
+      return span;
     }
-    if (isAsyncGenerator(target)) {
-      return this.bindAsyncGenerator(target);
+    const tokensUsed = span.attributes.tokensUsed;
+    if (!tokensUsed || tokensUsed.total == null || tokensUsed.completion == null || tokensUsed.prompt == null) {
+      return span;
     }
-    return target;
+    this.totalUsage.prompt += tokensUsed.prompt;
+    this.totalUsage.completion += tokensUsed.completion;
+    this.totalUsage.total += tokensUsed.total;
+    return span;
   }
-  bindFunction(context, target) {
-    const manager = this;
-    const contextWrapper = function(...args) {
-      return manager.with(context, () => target.apply(this, args));
+  async evaluatePrompt(span) {
+    const { prompt, variables, output } = span.attributes;
+    if (!isPrompt2(prompt)) {
+      return span;
+    }
+    delete span.attributes["prompt"];
+    let evaluators = [];
+    let evaluatorResults = {};
+    let extraAttributes = {};
+    try {
+      evaluators = await evaluatePrompt(prompt, variables, output);
+      evaluatorResults = evaluators.reduce(
+        (accum, result) => {
+          accum[result.key] = result;
+          return accum;
+        },
+        {}
+      );
+      extraAttributes = {
+        evaluators,
+        evaluatorResults
+      };
+    } catch (e) {
+      extraAttributes = {
+        evaluatorError: e.message,
+        evaluators,
+        evaluatorResults
+      };
+    }
+    const toSend = {
+      ...span,
+      attributes: {
+        ...span.attributes,
+        ...extraAttributes
+      }
     };
-    Object.defineProperty(contextWrapper, "length", {
-      enumerable: false,
-      configurable: true,
-      writable: false,
-      value: target.length
-    });
-    return contextWrapper;
-  }
-  bindAsyncGenerator(generator) {
-    generator.next = this.bindFunction(this.active(), generator.next);
-    return generator;
+    return toSend;
   }
 };
+var isChatCompletionSpan = (value) => {
+  return Boolean(
+    value && typeof value == "object" && "name" in value && value.name === "ai.chatCompletion"
+  );
+};
+var isPrompt2 = (value) => {
+  return Boolean(
+    value && typeof value == "object" && "schema" in value && "evaluators" in value
+  );
+};
 
-// src/tracing/index.ts
-var aijsxTracing;
-((aijsxTracing2) => {
-  aijsxTracing2.api = tracing;
-  aijsxTracing2.AsyncLocalStorageContextManager = AsyncLocalStorageContextManager;
-})(aijsxTracing || (aijsxTracing = {}));
+// src/tracing/Trace.tsx
+var Trace = ({ name, attributes, children }, { tracer, render }) => {
+  const result = tracer.trace(name, attributes || {}, () => {
+    return render(children);
+  });
+  return result;
+};
 
 // src/prompt/createPrompt.tsx
 import { z } from "zod";
@@ -1571,19 +1529,6 @@ function createStreamChain(chain) {
   };
 }
 
-// src/prompt/evaluatePrompt.ts
-async function evaluatePrompt(prompt, variables, result) {
-  const parsed = parseVariables(prompt.schema, variables);
-  if (!parsed.success) {
-    throw parsed.error;
-  }
-  return (await Promise.all(
-    prompt.evaluators.map(
-      (evaluator) => evaluator(parsed.result, result)
-    )
-  )).flat();
-}
-
 // src/lib/openai/OpenAI.tsx
 import { OpenAI as OpenAIClient } from "openai";
 
@@ -1680,13 +1625,6 @@ var renderChatMessageContent = (content) => {
 };
 
 // src/utils.ts
-import { nanoid } from "nanoid";
-var uuid = {
-  renderId: () => nanoid(),
-  spanId: () => nanoid(),
-  traceId: () => nanoid(),
-  requestId: () => nanoid()
-};
 function getEnvVar(name, shouldThrow = true) {
   let env = globalThis.process?.env ?? void 0;
   if (env === void 0) {
@@ -1709,15 +1647,19 @@ var OpenAIClientContext = createContext(() => {
     return defaultClient;
   }
   const apiKey = getEnvVar("OPENAI_API_KEY", true);
-  defaultClient = new OpenAIClient({ apiKey });
+  const client = new OpenAIClient({ apiKey });
+  defaultClient = {
+    client,
+    provider: "openai"
+  };
   return defaultClient;
 });
 function buildOpenAIMessages(childrenXml) {
   const messages = [];
-  const chatMessageTags2 = ["UserMessage", "AssistantMessage", "SystemMessage"];
-  const parsed = parseXml(childrenXml).collapse(chatMessageTags2);
+  const chatMessageTags = ["UserMessage", "AssistantMessage", "SystemMessage"];
+  const parsed = parseXml(childrenXml).collapse(chatMessageTags);
   const topLevelValid = parsed.childNodes.every(
-    (node) => chatMessageTags2.includes(node.nodeName)
+    (node) => chatMessageTags.includes(node.nodeName)
   );
   if (!topLevelValid) {
     throw new Error("Invalid top level chat message tags");
@@ -1742,105 +1684,111 @@ function buildOpenAIMessages(childrenXml) {
   }
   return messages;
 }
-async function* OpenAIChatCompletion(props, { render, logger, getContext }) {
-  const span = tracing.getTracer().startSpan("ai.chatCompletion");
-  const requestId = uuid.requestId();
-  const perfStart = performance.now();
-  const startTime = (/* @__PURE__ */ new Date()).toISOString();
-  span.setAttributes({
-    requestId,
-    model: props.model,
-    provider: props.provider,
-    providerRegion: props.providerRegion
-  });
-  const client = getContext(OpenAIClientContext)();
-  if (!client) {
-    throw new Error("[OpenAI] must supply OpenAI model via context");
-  }
-  const openAIMessages = buildOpenAIMessages(
-    await render(props.children, {
-      preserveTags: true
-    })
-  );
-  const renderedMessages = openAIMessages.map((message) => {
-    return {
-      role: message.role,
-      content: renderChatMessageContent(message.content),
-      tokens: tokenCountForOpenAIMessage(message)
-    };
-  });
-  const chatCompletionRequest = {
-    model: props.model,
-    max_tokens: props.maxTokens,
-    temperature: props.temperature,
-    messages: openAIMessages,
-    response_format: props.responseFormat ? {
-      type: props.responseFormat
-    } : void 0,
-    stream: true
-  };
-  const logRequestData = {
-    requestId,
-    startTime,
-    model: props.model,
-    provider: props.provider,
-    providerRegion: props.providerRegion,
-    inputMessages: renderedMessages,
-    request: chatCompletionRequest
-  };
-  logger.chatCompletionRequest("openai", logRequestData);
-  span.setAttributes({
-    inputMessages: renderedMessages,
-    request: chatCompletionRequest
-  });
-  let chatResponse;
-  try {
-    chatResponse = await client.chat.completions.create(chatCompletionRequest);
-  } catch (ex) {
-    const error = ex instanceof OpenAIClient.APIError ? new ChatCompletionError(
-      `OpenAIClient.APIError: ${ex.message}`,
-      span.attributes
-    ) : new ChatCompletionError(ex.message, span.attributes);
-    span.recordException(error).end();
-    throw error;
-  }
-  let finishReason = void 0;
-  let content = "";
-  for await (const message of chatResponse) {
-    if (!message.choices || !message.choices[0]) {
-      continue;
-    }
-    const delta = message.choices[0].delta;
-    if (message.choices[0].finish_reason) {
-      finishReason = message.choices[0].finish_reason;
-    }
-    if (delta.content) {
-      content += delta.content;
-      yield delta.content;
+function OpenAIChatCompletion(props, { logger, render, tracer, getContext }) {
+  const startTime = performance.now();
+  return tracer.trace(
+    "ai.chatCompletion",
+    {},
+    async function* OpenAIChatCompletionInner(span) {
+      const { client, provider, providerRegion, costFn } = getContext(OpenAIClientContext)();
+      if (!client) {
+        throw new Error("[OpenAI] must supply OpenAI model via context");
+      }
+      const openAIMessages = buildOpenAIMessages(
+        await render(props.children, {
+          preserveTags: true
+        })
+      );
+      const renderedMessages = openAIMessages.map((message) => {
+        return {
+          role: message.role,
+          content: renderChatMessageContent(message.content),
+          tokens: tokenCountForOpenAIMessage(message)
+        };
+      });
+      const chatCompletionRequest = {
+        model: props.model,
+        max_tokens: props.maxTokens,
+        temperature: props.temperature,
+        messages: openAIMessages,
+        response_format: props.responseFormat ? {
+          type: props.responseFormat
+        } : void 0,
+        stream: true
+      };
+      const logRequestData = {
+        startTime,
+        model: props.model,
+        provider,
+        providerRegion,
+        inputMessages: renderedMessages,
+        request: chatCompletionRequest
+      };
+      logger.chatCompletionRequest("openai", logRequestData);
+      span.setAttributes({
+        model: props.model,
+        provider,
+        providerRegion,
+        requestType: "openai",
+        chatCompletionRequest
+      });
+      let chatResponse;
+      try {
+        chatResponse = await client.chat.completions.create(
+          chatCompletionRequest
+        );
+      } catch (ex) {
+        if (ex instanceof OpenAIClient.APIError) {
+          throw new ChatCompletionError(
+            `OpenAIClient.APIError: ${ex.message}`,
+            logRequestData
+          );
+        } else if (ex instanceof Error) {
+          throw new ChatCompletionError(ex.message, logRequestData);
+        }
+        throw ex;
+      }
+      let finishReason = void 0;
+      let content = "";
+      for await (const message of chatResponse) {
+        if (!message.choices || !message.choices[0]) {
+          continue;
+        }
+        const delta = message.choices[0].delta;
+        if (message.choices[0].finish_reason) {
+          finishReason = message.choices[0].finish_reason;
+        }
+        if (delta.content) {
+          content += delta.content;
+          yield delta.content;
+        }
+      }
+      const outputMessage = {
+        role: "assistant",
+        content,
+        tokens: tokenCountForOpenAIMessage({
+          role: "assistant",
+          content
+        })
+      };
+      const tokensUsed = computeUsage([...renderedMessages, outputMessage]);
+      const cost = costFn?.(tokensUsed) ?? void 0;
+      const responseData = {
+        ...logRequestData,
+        finishReason,
+        latency: performance.now() - startTime,
+        outputMessage,
+        tokensUsed
+      };
+      logger.chatCompletionResponse("openai", responseData);
+      span.setAttributes({
+        tokensUsed,
+        output: content,
+        finishReason,
+        cost
+      });
     }
-  }
-  const outputMessage = {
-    role: "assistant",
-    content,
-    tokens: tokenCountForOpenAIMessage({
-      role: "assistant",
-      content
-    })
-  };
-  const responseData = {
-    ...logRequestData,
-    endTime: (/* @__PURE__ */ new Date()).toISOString(),
-    finishReason,
-    latency: performance.now() - perfStart,
-    outputMessage,
-    tokensUsed: computeUsage([...renderedMessages, outputMessage])
-  };
-  logger.chatCompletionResponse("openai", responseData);
-  span.setAttributes({
-    outputMessage,
-    finishReason,
-    tokensUsed: computeUsage([...renderedMessages, outputMessage])
-  }).end();
+  );
 }
 
 // src/lib/openai/OpenAIVision.tsx
@@ -1851,15 +1799,15 @@ var ContentTypeImage = (_props) => {
 };
 function buildOpenAIVisionChatMessages(childrenXml) {
   const messages = [];
-  const chatMessageTags2 = [
+  const chatMessageTags = [
     "UserMessage",
     "AssistantMessage",
     "SystemMessage",
     "ContentTypeImage"
   ];
-  const parsed = parseXml(childrenXml).collapse(chatMessageTags2);
+  const parsed = parseXml(childrenXml).collapse(chatMessageTags);
   const topLevelValid = parsed.childNodes.every(
-    (node) => chatMessageTags2.includes(node.nodeName)
+    (node) => chatMessageTags.includes(node.nodeName)
   );
   if (!topLevelValid) {
     throw new Error("Invalid top level chat message tags");
@@ -1906,148 +1854,154 @@ function buildOpenAIVisionChatMessages(childrenXml) {
   }
   return { messages, dimensions };
 }
-async function* OpenAIVisionChatCompletion(props, { render, getContext, logger }) {
-  const span = tracing.getTracer().startSpan("ai.chatCompletion");
-  const requestId = uuid.requestId();
-  const perfStart = performance.now();
-  const startTime = (/* @__PURE__ */ new Date()).toISOString();
+function OpenAIVisionChatCompletion(props, { logger, render, tracer, getContext }) {
+  const startTime = performance.now();
   const model = props.model || DEFAULT_MODEL;
-  span.setAttributes({
-    requestId,
-    model,
-    provider: props.provider,
-    providerRegion: props.providerRegion
-  });
-  const client = getContext(OpenAIClientContext)();
-  if (!client) {
-    throw new Error("[OpenAI] must supply OpenAI model via context");
-  }
-  const { messages: openAIMessages, dimensions } = buildOpenAIVisionChatMessages(
-    await render(props.children, {
-      preserveTags: true,
-      renderedProps: {
-        ContentTypeImage: {
-          url: true,
-          dimensions: true,
-          detail: true
-        }
+  return tracer.trace(
+    "ai.chatCompletion",
+    {},
+    async function* OpenAIVIsionChatCompletionInner(span) {
+      const { client, provider, providerRegion, costFn } = getContext(OpenAIClientContext)();
+      if (!client) {
+        throw new Error("[OpenAI] must supply OpenAI model via context");
       }
-    })
-  );
-  const renderedMessages = openAIMessages.map((message) => {
-    if (message.role === "user") {
-      if (typeof message.content === "string") {
+      const { messages: openAIMessages, dimensions } = buildOpenAIVisionChatMessages(
+        await render(props.children, {
+          preserveTags: true,
+          renderedProps: {
+            ContentTypeImage: {
+              url: true,
+              dimensions: true,
+              detail: true
+            }
+          }
+        })
+      );
+      const renderedMessages = openAIMessages.map((message) => {
+        if (message.role === "user") {
+          if (typeof message.content === "string") {
+            return {
+              role: message.role,
+              content: message.content,
+              tokens: tokenCountForOpenAIMessage(message)
+            };
+          }
+          const BASE_COST = 85;
+          const tokens = message.content.reduce((acc, part) => {
+            if (part.type === "text") {
+              return acc + tokenCountForOpenAIMessage({
+                role: message.role,
+                content: part.text
+              });
+            }
+            const detail = part.image_url.detail || "auto";
+            if (detail === "low") {
+              return acc + BASE_COST;
+            } else if (detail === "high") {
+              const dim = dimensions.get(part);
+              if (!dim) {
+                return acc + (170 * 4 + BASE_COST);
+              }
+              const area = dim.width * dim.height;
+              const num512Images = area / (512 * 512);
+              const highCost = num512Images * 170;
+              return acc + highCost + BASE_COST;
+            } else {
+              return acc + (170 * 4 + BASE_COST);
+            }
+          }, 0);
+          return {
+            role: message.role,
+            content: renderChatMessageContent(message.content),
+            tokens
+          };
+        }
         return {
           role: message.role,
-          content: message.content,
+          content: renderChatMessageContent(message.content),
           tokens: tokenCountForOpenAIMessage(message)
         };
+      });
+      const chatCompletionRequest = {
+        model,
+        max_tokens: props.maxTokens,
+        temperature: props.temperature,
+        messages: openAIMessages,
+        stream: true
+      };
+      const logRequestData = {
+        startTime,
+        model,
+        provider,
+        providerRegion,
+        inputMessages: renderedMessages,
+        request: chatCompletionRequest
+      };
+      logger.chatCompletionRequest("openai", logRequestData);
+      span.setAttributes({
+        model: props.model,
+        provider,
+        providerRegion,
+        requestType: "openai",
+        chatCompletionRequest
+      });
+      let chatResponse;
+      try {
+        chatResponse = await client.chat.completions.create(
+          chatCompletionRequest
+        );
+      } catch (ex) {
+        if (ex instanceof OpenAIClient2.APIError) {
+          throw new ChatCompletionError(
+            `OpenAIClient.APIError: ${ex.message}`,
+            logRequestData
+          );
+        } else if (ex instanceof Error) {
+          throw new ChatCompletionError(ex.message, logRequestData);
+        }
+        throw ex;
       }
-      const BASE_COST = 85;
-      const tokens = message.content.reduce((acc, part) => {
-        if (part.type === "text") {
-          return acc + tokenCountForOpenAIMessage({
-            role: message.role,
-            content: part.text
-          });
+      let finishReason = void 0;
+      let content = "";
+      for await (const message of chatResponse) {
+        if (!message.choices || !message.choices[0]) {
+          continue;
         }
-        const detail = part.image_url.detail || "auto";
-        if (detail === "low") {
-          return acc + BASE_COST;
-        } else if (detail === "high") {
-          const dim = dimensions.get(part);
-          if (!dim) {
-            return acc + (170 * 4 + BASE_COST);
-          }
-          const area = dim.width * dim.height;
-          const num512Images = area / (512 * 512);
-          const highCost = num512Images * 170;
-          return acc + highCost + BASE_COST;
-        } else {
-          return acc + (170 * 4 + BASE_COST);
+        const delta = message.choices[0].delta;
+        if (message.choices[0].finish_reason) {
+          finishReason = message.choices[0].finish_reason;
         }
-      }, 0);
-      return {
-        role: message.role,
-        content: renderChatMessageContent(message.content),
-        tokens
+        if (delta.content) {
+          content += delta.content;
+          yield delta.content;
+        }
+      }
+      const outputMessage = {
+        role: "assistant",
+        content,
+        tokens: tokenCountForOpenAIMessage({
+          role: "assistant",
+          content
+        })
       };
+      const tokensUsed = computeUsage([...renderedMessages, outputMessage]);
+      const cost = costFn?.(tokensUsed) ?? void 0;
+      const responseData = {
+        ...logRequestData,
+        finishReason,
+        latency: performance.now() - startTime,
+        outputMessage,
+        tokensUsed
+      };
+      logger.chatCompletionResponse("openai", responseData);
+      span.setAttributes({
+        tokensUsed,
+        output: content,
+        cost,
+        finishReason
+      });
     }
-    return {
-      role: message.role,
-      content: renderChatMessageContent(message.content),
-      tokens: tokenCountForOpenAIMessage(message)
-    };
-  });
-  const chatCompletionRequest = {
-    model,
-    max_tokens: props.maxTokens,
-    temperature: props.temperature,
-    messages: openAIMessages,
-    stream: true
-  };
-  const logRequestData = {
-    requestId,
-    startTime,
-    model,
-    provider: props.provider,
-    providerRegion: props.providerRegion,
-    inputMessages: renderedMessages,
-    request: chatCompletionRequest
-  };
-  logger.chatCompletionRequest("openai", logRequestData);
-  span.setAttributes({
-    inputMessages: renderedMessages,
-    request: chatCompletionRequest
-  });
-  let chatResponse;
-  try {
-    chatResponse = await client.chat.completions.create(chatCompletionRequest);
-  } catch (ex) {
-    const error = ex instanceof OpenAIClient2.APIError ? new ChatCompletionError(
-      `OpenAIClient.APIError: ${ex.message}`,
-      span.attributes
-    ) : new ChatCompletionError(ex.message, span.attributes);
-    span.recordException(error).end();
-    throw error;
-  }
-  let finishReason = void 0;
-  let content = "";
-  for await (const message of chatResponse) {
-    if (!message.choices || !message.choices[0]) {
-      continue;
-    }
-    const delta = message.choices[0].delta;
-    if (message.choices[0].finish_reason) {
-      finishReason = message.choices[0].finish_reason;
-    }
-    if (delta.content) {
-      content += delta.content;
-      yield delta.content;
-    }
-  }
-  const outputMessage = {
-    role: "assistant",
-    content,
-    tokens: tokenCountForOpenAIMessage({
-      role: "assistant",
-      content
-    })
-  };
-  const responseData = {
-    ...logRequestData,
-    endTime: (/* @__PURE__ */ new Date()).toISOString(),
-    finishReason,
-    latency: performance.now() - perfStart,
-    outputMessage,
-    tokensUsed: computeUsage([...renderedMessages, outputMessage])
-  };
-  logger.chatCompletionResponse("openai", responseData);
-  span.setAttributes({
-    outputMessage,
-    finishReason,
-    tokensUsed: computeUsage([...renderedMessages, outputMessage])
-  }).end();
+  );
 }
 
 // src/lib/openai/index.ts
@@ -2057,21 +2011,29 @@ import { OpenAI as OpenAIClient3 } from "openai";
 import AnthropicClient from "@anthropic-ai/sdk";
 import { countTokens } from "@anthropic-ai/tokenizer";
 var defaultClient2 = null;
-var AnthropicClientContext = createContext(
-  () => {
-    if (defaultClient2) {
-      return defaultClient2;
-    }
-    defaultClient2 = new AnthropicClient({
-      apiKey: getEnvVar("ANTHROPIC_API_KEY", false)
-    });
+var AnthropicClientContext = createContext(() => {
+  if (defaultClient2) {
     return defaultClient2;
   }
-);
+  const client = new AnthropicClient({
+    apiKey: getEnvVar("ANTHROPIC_API_KEY", false)
+  });
+  defaultClient2 = {
+    client,
+    provider: "anthropic"
+  };
+  return defaultClient2;
+});
 var defaultMaxTokens = 4096;
-var chatMessageTags = ["UserMessage", "AssistantMessage", "SystemMessage"];
-function buildChatMessages(childrenXml) {
+function buildAnthropicMessages(childrenXml) {
+  let system = "";
   const messages = [];
+  const chatMessageTags = [
+    "UserMessage",
+    "AssistantMessage",
+    "SystemMessage",
+    "ClaudeImageBlockParam"
+  ];
   const parsed = parseXml(childrenXml).collapse(chatMessageTags);
   const topLevelValid = parsed.childNodes.every(
     (node) => chatMessageTags.includes(node.nodeName)
@@ -2081,142 +2043,258 @@ function buildChatMessages(childrenXml) {
   }
   for (const node of parsed.childNodes) {
     if (node.nodeName === "UserMessage") {
-      const content = `${AnthropicClient.HUMAN_PROMPT} ${node.textContent}`;
+      if (node.childNodes?.length === 1 && node.childNodes[0].nodeName === "#text") {
+        messages.push({
+          content: node.childNodes[0].value,
+          role: "user"
+        });
+        continue;
+      }
+      const parts = node.childNodes.map((n) => {
+        if (n.nodeName === "#text") {
+          return {
+            type: "text",
+            text: n.value
+          };
+        } else if (n.nodeName === "ClaudeImageBlockParam") {
+          const imagePart = {
+            type: "image",
+            source: {
+              type: "base64",
+              media_type: n.attributes.mediaType,
+              data: n.attributes.data
+            }
+          };
+          return imagePart;
+        }
+        throw new Error(
+          "Invalid ChatCompletionContentPart, expecting text or ContentTypeImage"
+        );
+      });
       messages.push({
-        role: "user",
-        content,
-        tokens: countTokens(content)
+        content: parts,
+        role: "user"
       });
     } else if (node.nodeName === "AssistantMessage") {
-      const content = `${AnthropicClient.AI_PROMPT} ${node.textContent}`;
       messages.push({
-        role: "assistant",
-        content,
-        tokens: countTokens(content)
+        content: node.textContent,
+        role: "assistant"
       });
     } else if (node.nodeName === "SystemMessage") {
-      const userContent = `${AnthropicClient.HUMAN_PROMPT} For subsequent replies you will adhere to the following instructions: ${node.textContent}`;
-      messages.push({
-        role: "user",
-        content: userContent,
-        tokens: countTokens(userContent)
+      system = node.textContent;
+    }
+  }
+  return { messages, system };
+}
+function AnthropicChatCompletion(props, { render, logger, tracer, getContext }) {
+  const startTime = performance.now();
+  return tracer.trace(
+    "ai.chatCompletion",
+    {},
+    async function* AnthropicChatCompletionInner(span) {
+      const { client, provider, providerRegion, costFn } = getContext(
+        AnthropicClientContext
+      )();
+      if (!client) {
+        throw new Error(
+          "[AnthropicChatCompletion] must supply AnthropicClient via context"
+        );
+      }
+      const { system, messages } = buildAnthropicMessages(
+        await render(props.children, {
+          preserveTags: true,
+          renderedProps: {
+            ClaudeImageBlockParam: {
+              data: true,
+              mediaType: true
+            }
+          }
+        })
+      );
+      const inputMessages = getRenderedMessages(system, messages);
+      const anthropicCompletionRequest = {
+        system,
+        messages,
+        max_tokens: props.maxTokens ?? defaultMaxTokens,
+        temperature: props.temperature,
+        model: props.model
+      };
+      const logRequestData = {
+        startTime,
+        model: props.model,
+        provider,
+        providerRegion,
+        inputMessages,
+        request: anthropicCompletionRequest
+      };
+      logger.chatCompletionRequest("anthropic", logRequestData);
+      span.setAttributes({
+        model: props.model,
+        provider,
+        providerRegion,
+        requestType: "anthropic",
+        chatCompletionRequest: anthropicCompletionRequest
       });
-      const assistantContent = `${AnthropicClient.AI_PROMPT} Okay, I will do that.`;
-      messages.push({
+      let response;
+      try {
+        response = client.messages.stream(anthropicCompletionRequest);
+      } catch (err) {
+        if (err instanceof AnthropicClient.APIError) {
+          throw new ChatCompletionError(
+            `AnthropicClient.APIError: ${err.message}`,
+            logRequestData
+          );
+        } else if (err instanceof Error) {
+          throw new ChatCompletionError(err.message, logRequestData);
+        }
+        throw err;
+      }
+      let content = "";
+      let outputUsage = 0;
+      let inputUsage = 0;
+      let finishReason = null;
+      for await (const event of response) {
+        if (event.type === "message_start") {
+          inputUsage = event.message.usage?.input_tokens || 0;
+        }
+        if (event.type === "content_block_delta") {
+          const chunk = event.delta.text;
+          content += chunk;
+          yield chunk;
+        }
+        if (event.type === "message_delta") {
+          finishReason = event.delta.stop_reason;
+          outputUsage = event.usage?.output_tokens;
+        }
+      }
+      const outputMessage = {
         role: "assistant",
-        content: assistantContent,
-        tokens: countTokens(assistantContent)
+        content,
+        tokens: outputUsage
+      };
+      const userMessage = inputMessages.find(
+        (m) => m.role === "user" && m.tokens === 0
+      );
+      const restMessages = inputMessages.filter(
+        (m) => m.role !== "assistant" && m.tokens > 0
+      );
+      const restMessagesTokens = restMessages.reduce(
+        (acc, m) => acc + m.tokens,
+        0
+      );
+      if (userMessage && inputUsage) {
+        userMessage.tokens = inputUsage - restMessagesTokens;
+      }
+      const tokensUsed = computeUsage([...inputMessages, outputMessage]);
+      const cost = costFn?.(tokensUsed) ?? void 0;
+      const responseData = {
+        ...logRequestData,
+        finishReason,
+        latency: performance.now() - startTime,
+        // NOTE(jordan) we dont REALLY need inputMessages, they are this kind of intermediary that we use
+        // to store the token values for the messages, but we could easily just compute the tokensUsed and call
+        // it a day
+        inputMessages,
+        outputMessage,
+        tokensUsed
+      };
+      logger.chatCompletionResponse("anthropic", responseData);
+      span.setAttributes({
+        tokensUsed,
+        output: content,
+        cost,
+        finishReason
       });
     }
-  }
-  return messages;
-}
-async function* AnthropicChatCompletion(props, { render, getContext, logger }) {
-  const span = tracing.getTracer().startSpan("ai.chatCompletion");
-  const requestId = uuid.requestId();
-  const perfStart = performance.now();
-  const startTime = (/* @__PURE__ */ new Date()).toISOString();
-  span.setAttributes({
-    requestId,
-    model: props.model,
-    provider: props.provider,
-    providerRegion: props.providerRegion
-  });
-  const client = getContext(AnthropicClientContext)();
-  if (!client) {
-    throw new Error(
-      "[AnthropicChatCompletion] must supply AnthropicClient via context"
-    );
-  }
-  const inputMessages = buildChatMessages(
-    await render(props.children, {
-      preserveTags: true
-    })
   );
-  const prompt = [
-    ...inputMessages.map((message) => message.content),
-    AnthropicClient.AI_PROMPT
-  ].join("");
-  const anthropicCompletionRequest = {
-    prompt,
-    max_tokens_to_sample: props.maxTokens ?? defaultMaxTokens,
-    temperature: props.temperature,
-    model: props.model,
-    stream: true
-  };
-  const logRequestData = {
-    requestId,
-    startTime,
-    model: props.model,
-    provider: props.provider,
-    providerRegion: props.providerRegion,
-    inputMessages,
-    request: anthropicCompletionRequest
+}
+function getRenderedMessages(system, messages) {
+  const systemMessage = {
+    role: "system",
+    content: system,
+    tokens: countTokens(system)
   };
-  logger.chatCompletionRequest("anthropic", logRequestData);
-  span.setAttributes({
-    inputMessages,
-    request: anthropicCompletionRequest
+  const renderedMessages = messages.map((message) => {
+    if (message.role === "user") {
+      return {
+        role: message.role,
+        content: renderChatMessageContent2(message.content),
+        // we keep user message tokens 0 and just let anthropic tell us
+        tokens: 0
+      };
+    }
+    return {
+      role: message.role,
+      content: renderChatMessageContent2(message.content),
+      tokens: countTokens(message.content)
+    };
   });
-  let response;
-  try {
-    response = await client.completions.create(anthropicCompletionRequest);
-  } catch (ex) {
-    const error = ex instanceof AnthropicClient.APIError ? new ChatCompletionError(
-      `AnthropicClient.APIError: ${ex.message}`,
-      span.attributes
-    ) : new ChatCompletionError(ex.message, span.attributes);
-    span.recordException(error).end();
-    throw error;
+  return [systemMessage, ...renderedMessages];
+}
+var renderChatMessageContent2 = (content) => {
+  if (content == null) {
+    return "";
   }
-  let content = "";
-  let isFirstResponse = true;
-  for await (const completion of response) {
-    let text = completion.completion;
-    if (isFirstResponse && text.length > 0) {
-      isFirstResponse = false;
-      if (text.startsWith(" ")) {
-        text = text.slice(1);
-      }
-    }
-    content += text;
-    yield text;
+  if (typeof content === "string") {
+    return content;
   }
-  const outputMessage = {
-    role: "assistant",
-    content,
-    tokens: countTokens(content)
-  };
-  const responseData = {
-    ...logRequestData,
-    endTime: (/* @__PURE__ */ new Date()).toISOString(),
-    finishReason: "stop",
-    latency: performance.now() - perfStart,
-    outputMessage,
-    tokensUsed: computeUsage([...inputMessages, outputMessage])
+  return content.map((part) => {
+    if (typeof part === "string") {
+      return part;
+    } else if ("text" in part) {
+      return part.text;
+    } else if ("source" in part && typeof part.source === "object") {
+      return `<ImageBlockParam data="base64..." />`;
+    }
+    throw new Error("Invalid ImageBlockParam type");
+  }).join("\n\n");
+};
+
+// src/lib/anthropic/ClaudeImageBlock.tsx
+var ClaudeImageBlockParam = (_props) => {
+  return null;
+};
+async function fetchImageAndConvertToBase64(url) {
+  const response = await fetch(url);
+  const contentType = response.headers.get("content-type");
+  const allowedTypes = ["image/jpeg", "image/png", "image/gif", "image/webp"];
+  if (!contentType || !allowedTypes.includes(contentType)) {
+    throw new Error(`Unsupported media type: ${contentType}`);
+  }
+  const blob = await response.blob();
+  const buffer = Buffer.from(await blob.arrayBuffer());
+  const base64 = buffer.toString("base64");
+  return {
+    base64,
+    mediaType: contentType
   };
-  logger.chatCompletionResponse("anthropic", responseData);
-  span.setAttributes({
-    outputMessage,
-    tokensUsed: computeUsage([...inputMessages, outputMessage])
-  }).end();
 }
+var ClaudeImageBlock = async (props) => {
+  if ("data" in props) {
+    return /* @__PURE__ */ jsx(ClaudeImageBlockParam, { ...props });
+  }
+  const { url } = props;
+  const { base64, mediaType } = await fetchImageAndConvertToBase64(url);
+  return /* @__PURE__ */ jsx(ClaudeImageBlockParam, { mediaType, data: base64 });
+};
 
 // src/lib/anthropic/index.ts
 import AnthropicClient2 from "@anthropic-ai/sdk";
 import { countTokens as countAnthropicTokens } from "@anthropic-ai/tokenizer";
 export {
   AIFragment,
+  AISpanProcessor,
   AnthropicChatCompletion,
   AnthropicClient2 as AnthropicClient,
   AnthropicClientContext,
   AssistantMessage,
   BoundLogger,
-  ChainParseVariablesError,
   ChatCompletionError,
+  ClaudeImageBlock,
   CombinedLogger,
   ConsoleLogger,
   ContentTypeImage,
+  EnrichingSpanProcessor,
   LogImplementation,
   NoopLogImplementation,
   OpenAIChatCompletion,
@@ -2225,10 +2303,9 @@ export {
   OpenAIVisionChatCompletion,
   ParseVariablesError,
   PromptInvalidOutputError,
-  PromptParseVariablesError,
   SystemMessage,
+  Trace,
   UserMessage,
-  aijsxTracing,
   attachedContextSymbol,
   computeUsage,
   countAnthropicTokens,
@@ -2238,10 +2315,10 @@ export {
   createPrompt,
   createRenderContext,
   createStreamChain,
-  defaultMaxTokens,
   evaluatePrompt,
   tokenCountForOpenAIMessage,
   tokenCountForOpenAIVisionMessage,
   tokenLimitForChatModel,
-  tokenizer
+  tokenizer,
+  tracing
 };