@abassey/aid 0.1.0

package/dist/middleware/index.cjs

@@ -0,0 +1,201 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+var _chunk3LGKZRGYcjs = require('../chunk-3LGKZRGY.cjs');
+
+
+
+var _chunkNB65IHJEcjs = require('../chunk-NB65IHJE.cjs');
+
+// src/middleware/retry.ts
+var DEFAULT_RETRYABLE_CODES = ["rate_limit", "network", "timeout"];
+var DEFAULT_BASE_DELAY = 1e3;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function retry(config = {}) {
+  const maxAttempts = _nullishCoalesce(config.maxAttempts, () => ( 3));
+  const baseDelay = _nullishCoalesce(config._baseDelay, () => ( DEFAULT_BASE_DELAY));
+  return {
+    name: "retry",
+    async execute(request, next, context) {
+      let lastError;
+      for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        try {
+          const result = await next(request);
+          return result;
+        } catch (error) {
+          lastError = error instanceof Error ? error : new Error(String(error));
+          if (error instanceof _chunk3LGKZRGYcjs.AidError) {
+            if (!DEFAULT_RETRYABLE_CODES.includes(error.code)) {
+              throw error;
+            }
+          }
+          if (attempt >= maxAttempts - 1) {
+            throw lastError;
+          }
+          let delay = baseDelay * Math.pow(2, attempt);
+          if (error instanceof _chunk3LGKZRGYcjs.AidError && error.retryAfter != null) {
+            const retryAfterMs = error.retryAfter * 1e3;
+            delay = Math.max(retryAfterMs, delay);
+          }
+          await sleep(delay);
+        }
+      }
+      throw lastError;
+    }
+  };
+}
+
+// src/middleware/cache.ts
+function cache(config) {
+  const store = /* @__PURE__ */ new Map();
+  function makeKey(request) {
+    return JSON.stringify({ model: request.model, messages: request.messages });
+  }
+  function promote(key) {
+    const entry = store.get(key);
+    if (entry) {
+      store.delete(key);
+      store.set(key, entry);
+    }
+  }
+  function evictOldest() {
+    while (store.size > config.maxSize) {
+      const oldestKey = store.keys().next().value;
+      if (oldestKey !== void 0) {
+        store.delete(oldestKey);
+        const newFrontKey = store.keys().next().value;
+        if (newFrontKey !== void 0) {
+          promote(newFrontKey);
+        }
+      } else {
+        break;
+      }
+    }
+  }
+  return {
+    name: "cache",
+    async execute(request, next, context) {
+      const key = makeKey(request);
+      const cached = store.get(key);
+      if (cached) {
+        const now = Date.now();
+        if (now - cached.timestamp <= config.ttl * 1e3) {
+          store.delete(key);
+          store.set(key, cached);
+          return cached.response;
+        }
+        store.delete(key);
+      }
+      const response = await next(request);
+      store.set(key, { response, timestamp: Date.now() });
+      evictOldest();
+      return response;
+    }
+  };
+}
+
+// src/middleware/cost-guard.ts
+function costGuard(options) {
+  const { maxDailyUsd } = options;
+  let cumulativeCost = 0;
+  let lastResetDate = (/* @__PURE__ */ new Date()).toDateString();
+  return {
+    name: "cost-guard",
+    async execute(request, next, context) {
+      const today = (/* @__PURE__ */ new Date()).toDateString();
+      if (today !== lastResetDate) {
+        cumulativeCost = 0;
+        lastResetDate = today;
+      }
+      if (cumulativeCost >= maxDailyUsd) {
+        throw new (0, _chunk3LGKZRGYcjs.AidError)(
+          "cost_limit",
+          `Daily cost limit of $${maxDailyUsd} exceeded (cumulative: $${cumulativeCost.toFixed(4)})`
+        );
+      }
+      const response = await next(request);
+      cumulativeCost += response.cost;
+      return response;
+    }
+  };
+}
+
+// src/middleware/tracing.ts
+function tracing(options) {
+  const store = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _ => _.store]), () => ( _chunkNB65IHJEcjs.globalTraceStore));
+  return {
+    name: "tracing",
+    async execute(request, next, _context) {
+      const startTime = Date.now();
+      const id = crypto.randomUUID();
+      let providerName = "unknown";
+      try {
+        providerName = _chunk3LGKZRGYcjs.resolveProvider.call(void 0, request.model).providerName;
+      } catch (e2) {
+      }
+      const parent = _chunkNB65IHJEcjs.traceContext.getStore();
+      const firstUserMsg = request.messages.find((m) => m.role === "user");
+      const promptText = typeof _optionalChain([firstUserMsg, 'optionalAccess', _2 => _2.content]) === "string" ? firstUserMsg.content : "";
+      const promptPrefix = promptText.slice(0, 40).replace(/\n/g, " ");
+      const name = _optionalChain([options, 'optionalAccess', _3 => _3.nameFrom]) ? options.nameFrom(request) : promptPrefix ? `${request.model}:${promptPrefix}` : request.model;
+      try {
+        const response = await next(request);
+        const endTime = Date.now();
+        try {
+          store.add({
+            id,
+            parentId: _optionalChain([parent, 'optionalAccess', _4 => _4.id]),
+            name,
+            startTime,
+            endTime,
+            durationMs: endTime - startTime,
+            model: response.model,
+            provider: providerName,
+            tokens: response.tokens,
+            cost: response.cost,
+            status: "ok",
+            metadata: {}
+          });
+        } catch (e) {
+          console.warn("tracing: failed to record span", e);
+        }
+        return response;
+      } catch (error) {
+        const endTime = Date.now();
+        try {
+          store.add({
+            id,
+            parentId: _optionalChain([parent, 'optionalAccess', _5 => _5.id]),
+            name,
+            startTime,
+            endTime,
+            durationMs: endTime - startTime,
+            model: request.model,
+            provider: providerName,
+            tokens: { input: 0, output: 0, total: 0 },
+            cost: 0,
+            status: "error",
+            error: {
+              message: error instanceof Error ? error.message : String(error),
+              code: _optionalChain([error, 'optionalAccess', _6 => _6.code])
+            },
+            metadata: {}
+          });
+        } catch (e) {
+          console.warn("tracing: failed to record error span", e);
+        }
+        throw error;
+      }
+    }
+  };
+}
+
+
+
+
+
+
+exports.cache = cache; exports.costGuard = costGuard; exports.executePipeline = _chunk3LGKZRGYcjs.executePipeline; exports.retry = retry; exports.tracing = tracing;

package/dist/middleware/index.d.cts

@@ -0,0 +1,36 @@
+import { e as RetryConfig, M as Middleware, P as ProviderRequest, c as AiResponse } from '../types-BJReASS-.cjs';
+export { i as MiddlewareContext } from '../types-BJReASS-.cjs';
+import { T as TracingOptions } from '../types-CrFH-_qp.cjs';
+
+declare function retry(config?: RetryConfig): Middleware;
+
+interface CacheConfig {
+    ttl: number;
+    maxSize: number;
+}
+/**
+ * Creates a cache middleware that stores responses keyed by model + messages.
+ * Uses a Map as LRU cache. Cache key: JSON.stringify({model, messages}).
+ * Stores {response, timestamp}. On execute: check cache, if hit and not
+ * expired return cached, else call next and store result.
+ * Evict oldest entries when maxSize exceeded.
+ */
+declare function cache(config: CacheConfig): Middleware;
+
+interface CostGuardOptions {
+    maxDailyUsd: number;
+}
+declare function costGuard(options: CostGuardOptions): Middleware;
+
+/**
+ * Execute a middleware pipeline, composing middlewares right-to-left so that
+ * the first middleware in the array is the outermost wrapper.
+ *
+ * Each middleware's `next` calls the next middleware in the chain.
+ * The final `next` invokes the actual provider call.
+ */
+declare function executePipeline(middlewares: Middleware[], request: ProviderRequest, providerCall: (request: ProviderRequest) => Promise<AiResponse>): Promise<AiResponse>;
+
+declare function tracing(options?: TracingOptions): Middleware;
+
+export { Middleware, cache, costGuard, executePipeline, retry, tracing };

package/dist/middleware/index.d.ts

@@ -0,0 +1,36 @@
+import { e as RetryConfig, M as Middleware, P as ProviderRequest, c as AiResponse } from '../types-BJReASS-.js';
+export { i as MiddlewareContext } from '../types-BJReASS-.js';
+import { T as TracingOptions } from '../types-qfE32ADy.js';
+
+declare function retry(config?: RetryConfig): Middleware;
+
+interface CacheConfig {
+    ttl: number;
+    maxSize: number;
+}
+/**
+ * Creates a cache middleware that stores responses keyed by model + messages.
+ * Uses a Map as LRU cache. Cache key: JSON.stringify({model, messages}).
+ * Stores {response, timestamp}. On execute: check cache, if hit and not
+ * expired return cached, else call next and store result.
+ * Evict oldest entries when maxSize exceeded.
+ */
+declare function cache(config: CacheConfig): Middleware;
+
+interface CostGuardOptions {
+    maxDailyUsd: number;
+}
+declare function costGuard(options: CostGuardOptions): Middleware;
+
+/**
+ * Execute a middleware pipeline, composing middlewares right-to-left so that
+ * the first middleware in the array is the outermost wrapper.
+ *
+ * Each middleware's `next` calls the next middleware in the chain.
+ * The final `next` invokes the actual provider call.
+ */
+declare function executePipeline(middlewares: Middleware[], request: ProviderRequest, providerCall: (request: ProviderRequest) => Promise<AiResponse>): Promise<AiResponse>;
+
+declare function tracing(options?: TracingOptions): Middleware;
+
+export { Middleware, cache, costGuard, executePipeline, retry, tracing };

package/dist/middleware/index.js

@@ -0,0 +1,201 @@
+import {
+  AidError,
+  executePipeline,
+  resolveProvider
+} from "../chunk-2TNYBUNK.js";
+import {
+  globalTraceStore,
+  traceContext
+} from "../chunk-JPD7UBAZ.js";
+
+// src/middleware/retry.ts
+var DEFAULT_RETRYABLE_CODES = ["rate_limit", "network", "timeout"];
+var DEFAULT_BASE_DELAY = 1e3;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function retry(config = {}) {
+  const maxAttempts = config.maxAttempts ?? 3;
+  const baseDelay = config._baseDelay ?? DEFAULT_BASE_DELAY;
+  return {
+    name: "retry",
+    async execute(request, next, context) {
+      let lastError;
+      for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        try {
+          const result = await next(request);
+          return result;
+        } catch (error) {
+          lastError = error instanceof Error ? error : new Error(String(error));
+          if (error instanceof AidError) {
+            if (!DEFAULT_RETRYABLE_CODES.includes(error.code)) {
+              throw error;
+            }
+          }
+          if (attempt >= maxAttempts - 1) {
+            throw lastError;
+          }
+          let delay = baseDelay * Math.pow(2, attempt);
+          if (error instanceof AidError && error.retryAfter != null) {
+            const retryAfterMs = error.retryAfter * 1e3;
+            delay = Math.max(retryAfterMs, delay);
+          }
+          await sleep(delay);
+        }
+      }
+      throw lastError;
+    }
+  };
+}
+
+// src/middleware/cache.ts
+function cache(config) {
+  const store = /* @__PURE__ */ new Map();
+  function makeKey(request) {
+    return JSON.stringify({ model: request.model, messages: request.messages });
+  }
+  function promote(key) {
+    const entry = store.get(key);
+    if (entry) {
+      store.delete(key);
+      store.set(key, entry);
+    }
+  }
+  function evictOldest() {
+    while (store.size > config.maxSize) {
+      const oldestKey = store.keys().next().value;
+      if (oldestKey !== void 0) {
+        store.delete(oldestKey);
+        const newFrontKey = store.keys().next().value;
+        if (newFrontKey !== void 0) {
+          promote(newFrontKey);
+        }
+      } else {
+        break;
+      }
+    }
+  }
+  return {
+    name: "cache",
+    async execute(request, next, context) {
+      const key = makeKey(request);
+      const cached = store.get(key);
+      if (cached) {
+        const now = Date.now();
+        if (now - cached.timestamp <= config.ttl * 1e3) {
+          store.delete(key);
+          store.set(key, cached);
+          return cached.response;
+        }
+        store.delete(key);
+      }
+      const response = await next(request);
+      store.set(key, { response, timestamp: Date.now() });
+      evictOldest();
+      return response;
+    }
+  };
+}
+
+// src/middleware/cost-guard.ts
+function costGuard(options) {
+  const { maxDailyUsd } = options;
+  let cumulativeCost = 0;
+  let lastResetDate = (/* @__PURE__ */ new Date()).toDateString();
+  return {
+    name: "cost-guard",
+    async execute(request, next, context) {
+      const today = (/* @__PURE__ */ new Date()).toDateString();
+      if (today !== lastResetDate) {
+        cumulativeCost = 0;
+        lastResetDate = today;
+      }
+      if (cumulativeCost >= maxDailyUsd) {
+        throw new AidError(
+          "cost_limit",
+          `Daily cost limit of $${maxDailyUsd} exceeded (cumulative: $${cumulativeCost.toFixed(4)})`
+        );
+      }
+      const response = await next(request);
+      cumulativeCost += response.cost;
+      return response;
+    }
+  };
+}
+
+// src/middleware/tracing.ts
+function tracing(options) {
+  const store = options?.store ?? globalTraceStore;
+  return {
+    name: "tracing",
+    async execute(request, next, _context) {
+      const startTime = Date.now();
+      const id = crypto.randomUUID();
+      let providerName = "unknown";
+      try {
+        providerName = resolveProvider(request.model).providerName;
+      } catch {
+      }
+      const parent = traceContext.getStore();
+      const firstUserMsg = request.messages.find((m) => m.role === "user");
+      const promptText = typeof firstUserMsg?.content === "string" ? firstUserMsg.content : "";
+      const promptPrefix = promptText.slice(0, 40).replace(/\n/g, " ");
+      const name = options?.nameFrom ? options.nameFrom(request) : promptPrefix ? `${request.model}:${promptPrefix}` : request.model;
+      try {
+        const response = await next(request);
+        const endTime = Date.now();
+        try {
+          store.add({
+            id,
+            parentId: parent?.id,
+            name,
+            startTime,
+            endTime,
+            durationMs: endTime - startTime,
+            model: response.model,
+            provider: providerName,
+            tokens: response.tokens,
+            cost: response.cost,
+            status: "ok",
+            metadata: {}
+          });
+        } catch (e) {
+          console.warn("tracing: failed to record span", e);
+        }
+        return response;
+      } catch (error) {
+        const endTime = Date.now();
+        try {
+          store.add({
+            id,
+            parentId: parent?.id,
+            name,
+            startTime,
+            endTime,
+            durationMs: endTime - startTime,
+            model: request.model,
+            provider: providerName,
+            tokens: { input: 0, output: 0, total: 0 },
+            cost: 0,
+            status: "error",
+            error: {
+              message: error instanceof Error ? error.message : String(error),
+              code: error?.code
+            },
+            metadata: {}
+          });
+        } catch (e) {
+          console.warn("tracing: failed to record error span", e);
+        }
+        throw error;
+      }
+    }
+  };
+}
+export {
+  cache,
+  costGuard,
+  executePipeline,
+  retry,
+  tracing
+};

package/dist/observability/index.cjs

@@ -0,0 +1,147 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+var _chunkNB65IHJEcjs = require('../chunk-NB65IHJE.cjs');
+
+// src/observability/trace.ts
+async function trace(name, fn, options) {
+  const id = crypto.randomUUID();
+  const startTime = Date.now();
+  const metadata = { ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _ => _.metadata]), () => ( {})) };
+  const parent = _chunkNB65IHJEcjs.traceContext.getStore();
+  const activeSpan = {
+    get id() {
+      return id;
+    },
+    get name() {
+      return name;
+    },
+    annotate(key, value) {
+      metadata[key] = value;
+    }
+  };
+  try {
+    const result = await _chunkNB65IHJEcjs.traceContext.run(
+      activeSpan,
+      () => fn(activeSpan)
+    );
+    const endTime = Date.now();
+    _chunkNB65IHJEcjs.globalTraceStore.add({
+      id,
+      parentId: _optionalChain([parent, 'optionalAccess', _2 => _2.id]),
+      name,
+      startTime,
+      endTime,
+      durationMs: endTime - startTime,
+      model: "trace",
+      provider: "trace",
+      tokens: { input: 0, output: 0, total: 0 },
+      cost: 0,
+      status: "ok",
+      metadata
+    });
+    return result;
+  } catch (error) {
+    const endTime = Date.now();
+    _chunkNB65IHJEcjs.globalTraceStore.add({
+      id,
+      parentId: _optionalChain([parent, 'optionalAccess', _3 => _3.id]),
+      name,
+      startTime,
+      endTime,
+      durationMs: endTime - startTime,
+      model: "trace",
+      provider: "trace",
+      tokens: { input: 0, output: 0, total: 0 },
+      cost: 0,
+      status: "error",
+      error: {
+        message: error instanceof Error ? error.message : String(error)
+      },
+      metadata
+    });
+    throw error;
+  }
+}
+
+// src/observability/cost-tracker.ts
+function resolvePeriod(period) {
+  if (typeof period === "object" && "from" in period) {
+    return period;
+  }
+  const now = Date.now();
+  const d = new Date(now);
+  const todayMidnight = Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate());
+  switch (period) {
+    case "today":
+      return { from: todayMidnight, to: now };
+    case "yesterday": {
+      const yesterdayMidnight = todayMidnight - 24 * 60 * 60 * 1e3;
+      return { from: yesterdayMidnight, to: todayMidnight };
+    }
+    case "this-week": {
+      const dayOfWeek = d.getUTCDay();
+      const daysToMonday = dayOfWeek === 0 ? 6 : dayOfWeek - 1;
+      const mondayMidnight = todayMidnight - daysToMonday * 24 * 60 * 60 * 1e3;
+      return { from: mondayMidnight, to: now };
+    }
+    case "this-month": {
+      const monthStart = Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), 1);
+      return { from: monthStart, to: now };
+    }
+  }
+}
+var CostTracker = class {
+  constructor(store) {
+    this.store = store;
+  }
+  report(period) {
+    const { from, to } = resolvePeriod(period);
+    const spans = this.store.list({ from, to }).filter((s) => s.model !== "trace");
+    const totalTokens = { input: 0, output: 0, total: 0 };
+    let totalCost = 0;
+    const byModel = {};
+    const byProvider = {};
+    for (const span of spans) {
+      totalCost += span.cost;
+      totalTokens.input += span.tokens.input;
+      totalTokens.output += span.tokens.output;
+      totalTokens.total += span.tokens.total;
+      if (!byModel[span.model]) {
+        byModel[span.model] = {
+          cost: 0,
+          calls: 0,
+          tokens: { input: 0, output: 0, total: 0 }
+        };
+      }
+      byModel[span.model].cost += span.cost;
+      byModel[span.model].calls += 1;
+      byModel[span.model].tokens.input += span.tokens.input;
+      byModel[span.model].tokens.output += span.tokens.output;
+      byModel[span.model].tokens.total += span.tokens.total;
+      if (!byProvider[span.provider]) {
+        byProvider[span.provider] = { cost: 0, calls: 0 };
+      }
+      byProvider[span.provider].cost += span.cost;
+      byProvider[span.provider].calls += 1;
+    }
+    return {
+      totalCost,
+      totalTokens,
+      calls: spans.length,
+      byModel,
+      byProvider,
+      period: { from, to }
+    };
+  }
+};
+function costReport(period) {
+  return new CostTracker(_chunkNB65IHJEcjs.globalTraceStore).report(period);
+}
+
+
+
+
+
+exports.CostTracker = CostTracker; exports.InMemoryTraceStore = _chunkNB65IHJEcjs.InMemoryTraceStore; exports.costReport = costReport; exports.trace = trace;

package/dist/observability/index.d.cts

@@ -0,0 +1,30 @@
+import { A as ActiveSpan, a as TraceStore, S as Span, b as SpanFilter, C as CostPeriod, c as CostReport } from '../types-CrFH-_qp.cjs';
+export { M as ModelCostBreakdown, T as TracingOptions } from '../types-CrFH-_qp.cjs';
+import '../types-BJReASS-.cjs';
+
+declare function trace<T>(name: string, fn: (span: ActiveSpan) => Promise<T>, options?: {
+    metadata?: Record<string, unknown>;
+}): Promise<T>;
+
+declare class InMemoryTraceStore implements TraceStore {
+    private spans;
+    private order;
+    private maxSpans;
+    constructor(options?: {
+        maxSpans?: number;
+    });
+    add(span: Span): void;
+    get(id: string): Span | undefined;
+    list(filter?: SpanFilter): Span[];
+    clear(): void;
+}
+
+declare class CostTracker {
+    private store;
+    constructor(store: TraceStore);
+    report(period: CostPeriod): CostReport;
+}
+/** Convenience: create a CostTracker with the global store and generate a report. */
+declare function costReport(period: CostPeriod): CostReport;
+
+export { ActiveSpan, CostPeriod, CostReport, CostTracker, InMemoryTraceStore, Span, SpanFilter, TraceStore, costReport, trace };

package/dist/observability/index.d.ts

@@ -0,0 +1,30 @@
+import { A as ActiveSpan, a as TraceStore, S as Span, b as SpanFilter, C as CostPeriod, c as CostReport } from '../types-qfE32ADy.js';
+export { M as ModelCostBreakdown, T as TracingOptions } from '../types-qfE32ADy.js';
+import '../types-BJReASS-.js';
+
+declare function trace<T>(name: string, fn: (span: ActiveSpan) => Promise<T>, options?: {
+    metadata?: Record<string, unknown>;
+}): Promise<T>;
+
+declare class InMemoryTraceStore implements TraceStore {
+    private spans;
+    private order;
+    private maxSpans;
+    constructor(options?: {
+        maxSpans?: number;
+    });
+    add(span: Span): void;
+    get(id: string): Span | undefined;
+    list(filter?: SpanFilter): Span[];
+    clear(): void;
+}
+
+declare class CostTracker {
+    private store;
+    constructor(store: TraceStore);
+    report(period: CostPeriod): CostReport;
+}
+/** Convenience: create a CostTracker with the global store and generate a report. */
+declare function costReport(period: CostPeriod): CostReport;
+
+export { ActiveSpan, CostPeriod, CostReport, CostTracker, InMemoryTraceStore, Span, SpanFilter, TraceStore, costReport, trace };