@infinityi/engine-lib 1.0.0

package/dist/index-7690reng.js

@@ -0,0 +1,96 @@
+// src/errors.ts
+class AgentError extends Error {
+  usage;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "AgentError";
+  }
+}
+
+class ProviderError extends AgentError {
+  provider;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ProviderError";
+    if (options?.provider !== undefined)
+      this.provider = options.provider;
+  }
+}
+
+class ToolError extends AgentError {
+  toolName;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ToolError";
+    if (options?.toolName !== undefined)
+      this.toolName = options.toolName;
+  }
+}
+
+class SchemaValidationError extends AgentError {
+  issues;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "SchemaValidationError";
+    this.issues = options.issues;
+  }
+}
+
+class ToolValidationError extends SchemaValidationError {
+  toolName;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ToolValidationError";
+    if (options?.toolName !== undefined)
+      this.toolName = options.toolName;
+  }
+}
+
+class ExecutionError extends AgentError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ExecutionError";
+  }
+}
+
+class MaxStepsExceededError extends ExecutionError {
+  steps;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "MaxStepsExceededError";
+    if (options?.steps !== undefined)
+      this.steps = options.steps;
+  }
+}
+
+class MaxHandoffsExceededError extends ExecutionError {
+  handoffs;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "MaxHandoffsExceededError";
+    if (options?.handoffs !== undefined)
+      this.handoffs = options.handoffs;
+  }
+}
+
+class CancelledError extends AgentError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "CancelledError";
+  }
+}
+
+class ContextWindowError extends AgentError {
+  tokens;
+  limit;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ContextWindowError";
+    if (options?.tokens !== undefined)
+      this.tokens = options.tokens;
+    if (options?.limit !== undefined)
+      this.limit = options.limit;
+  }
+}
+
+export { AgentError, ProviderError, ToolError, SchemaValidationError, ToolValidationError, ExecutionError, MaxStepsExceededError, MaxHandoffsExceededError, CancelledError, ContextWindowError };

package/dist/index-bqg01r42.js

@@ -0,0 +1,354 @@
+// node_modules/@infinityi/forge/dist/index-ft2g12w9.js
+var realClock = {
+  now() {
+    return Date.now();
+  },
+  sleep(ms, signal) {
+    if (signal?.aborted) {
+      return Promise.reject(signal.reason);
+    }
+    if (ms <= 0) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
+        resolve();
+      }, ms);
+      const onAbort = () => {
+        clearTimeout(timer);
+        reject(signal.reason);
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+};
+
+// node_modules/@infinityi/forge/dist/index-sw7jeh00.js
+class ResilienceError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ResilienceError";
+  }
+}
+
+// node_modules/@infinityi/forge/dist/index-f41wfqnm.js
+function buildInstruments(telemetry) {
+  const meter = telemetry?.meter;
+  const tracer = telemetry?.tracer;
+  let attempts;
+  let retries;
+  let timeouts;
+  let circuitState;
+  let bulkheadQueueSize;
+  return {
+    attempts() {
+      if (!meter)
+        return;
+      attempts ??= meter.createCounter("forge_resilience_attempts_total", {
+        description: "Total execution attempts (including retries).",
+        unit: "1"
+      });
+      return attempts;
+    },
+    retries() {
+      if (!meter)
+        return;
+      retries ??= meter.createCounter("forge_resilience_retries_total", {
+        description: "Total retry attempts triggered.",
+        unit: "1"
+      });
+      return retries;
+    },
+    timeouts() {
+      if (!meter)
+        return;
+      timeouts ??= meter.createCounter("forge_resilience_timeout_total", {
+        description: "Total operations aborted due to timeout.",
+        unit: "1"
+      });
+      return timeouts;
+    },
+    circuitState() {
+      if (!meter)
+        return;
+      circuitState ??= meter.createGauge("forge_resilience_circuit_state", {
+        description: "Current circuit-breaker state (0=Closed, 1=HalfOpen, 2=Open).",
+        unit: "1"
+      });
+      return circuitState;
+    },
+    bulkheadQueueSize() {
+      if (!meter)
+        return;
+      bulkheadQueueSize ??= meter.createGauge("forge_resilience_bulkhead_queue_size", {
+        description: "Current number of tasks waiting in a bulkhead queue.",
+        unit: "1"
+      });
+      return bulkheadQueueSize;
+    },
+    addEvent(name, attributes) {
+      if (!tracer)
+        return;
+      const span = tracer.startSpan(name, attributes ? { attributes } : undefined);
+      span.end();
+    }
+  };
+}
+
+// node_modules/@infinityi/forge/dist/index-yh6c6ebj.js
+import { AsyncLocalStorage } from "node:async_hooks";
+var INVALID_TRACE_ID = "0".repeat(32);
+var INVALID_SPAN_ID = "0".repeat(16);
+var contextStorage = new AsyncLocalStorage;
+function currentContext() {
+  return contextStorage.getStore();
+}
+
+// node_modules/@infinityi/forge/dist/index-0jqvt0fs.js
+function buildRootContext() {
+  const controller = new AbortController;
+  const telemetry = currentContext();
+  const context = telemetry ? { signal: controller.signal, attempt: 1, context: telemetry } : { signal: controller.signal, attempt: 1 };
+  return { context, controller };
+}
+function withExecutionContext(base, overrides) {
+  const next = {
+    signal: overrides.signal ?? base.signal,
+    attempt: overrides.attempt ?? base.attempt
+  };
+  const telemetry = "context" in overrides ? overrides.context : base.context;
+  if (telemetry !== undefined) {
+    next.context = telemetry;
+  }
+  return next;
+}
+
+// node_modules/@infinityi/forge/dist/index-br4e2rnq.js
+function ok(value) {
+  return {
+    ok: true,
+    value,
+    isOk() {
+      return true;
+    },
+    isErr() {
+      return false;
+    }
+  };
+}
+function err(error) {
+  return {
+    ok: false,
+    error,
+    isOk() {
+      return false;
+    },
+    isErr() {
+      return true;
+    }
+  };
+}
+function combine(...policies) {
+  return createPipeline(policies);
+}
+function createPipeline(policies) {
+  function buildChain(op) {
+    let chain = op;
+    for (let i = policies.length - 1;i >= 0; i--) {
+      const policy = policies[i];
+      const inner = chain;
+      chain = (ctx) => policy.execute(inner, ctx);
+    }
+    return chain;
+  }
+  async function execute(op) {
+    const { context } = buildRootContext();
+    return buildChain(op)(context);
+  }
+  async function executeResult(op) {
+    try {
+      const value = await execute(op);
+      return ok(value);
+    } catch (error) {
+      if (error instanceof ResilienceError)
+        return err(error);
+      return err(new ResilienceError("operation failed", { cause: error }));
+    }
+  }
+  return { execute, executeResult };
+}
+function constantBackoff(delayMs) {
+  const ms = Math.max(0, delayMs);
+  return { delay: () => ms };
+}
+function exponentialBackoff(options) {
+  const initial = Math.max(0, options.initial);
+  const max = options.max !== undefined ? Math.max(initial, options.max) : Number.POSITIVE_INFINITY;
+  const factor = options.factor ?? 2;
+  const jitter = options.jitter ?? true;
+  return {
+    delay(attempt) {
+      const exponent = Math.max(0, attempt - 1);
+      const raw = Math.min(max, initial * Math.pow(factor, exponent));
+      return jitter ? applyFullJitter(raw) : raw;
+    }
+  };
+}
+function applyFullJitter(base) {
+  if (base <= 0)
+    return 0;
+  return Math.random() * base;
+}
+
+class RetryExhaustedError extends ResilienceError {
+  attempts;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "RetryExhaustedError";
+    this.attempts = options.attempts;
+  }
+}
+function retry(options) {
+  if (!Number.isInteger(options.maxAttempts) || options.maxAttempts < 1) {
+    throw new RangeError(`retry: maxAttempts must be an integer >= 1, got ${options.maxAttempts}`);
+  }
+  const maxAttempts = options.maxAttempts;
+  const backoff = options.backoff ?? constantBackoff(0);
+  const shouldRetry = options.shouldRetry ?? (() => true);
+  const retryOn = options.retryOn;
+  const clock = options.clock ?? realClock;
+  const instruments = buildInstruments(options.telemetry);
+  async function execute(next, ctx) {
+    let lastError;
+    for (let attempt = 1;attempt <= maxAttempts; attempt++) {
+      if (ctx.signal.aborted) {
+        throw ctx.signal.reason;
+      }
+      const attemptCtx = attempt === ctx.attempt ? ctx : withExecutionContext(ctx, { attempt });
+      instruments.attempts()?.add(1, { policy: "retry" });
+      try {
+        const value = await next(attemptCtx);
+        if (retryOn && retryOn(value, attempt)) {
+          const synthetic = new Error("operation returned a retryable value");
+          synthetic.cause = value;
+          lastError = synthetic;
+        } else {
+          return value;
+        }
+      } catch (error) {
+        lastError = error;
+        if (!shouldRetry(error, attempt))
+          throw error;
+      }
+      if (attempt >= maxAttempts)
+        break;
+      const delayMs = Math.max(0, backoff.delay(attempt));
+      instruments.retries()?.add(1, { policy: "retry" });
+      instruments.addEvent("resilience.retry.attempt", {
+        attempt_number: attempt,
+        delay_ms: delayMs,
+        error_message: lastError instanceof Error ? lastError.message : String(lastError)
+      });
+      if (delayMs > 0) {
+        await clock.sleep(delayMs, ctx.signal);
+      } else if (ctx.signal.aborted) {
+        throw ctx.signal.reason;
+      }
+    }
+    throw new RetryExhaustedError(`retry: exhausted ${maxAttempts} attempt(s)`, { attempts: maxAttempts, cause: lastError });
+  }
+  return {
+    name: "retry",
+    maxAttempts,
+    execute
+  };
+}
+
+class TimeoutError extends ResilienceError {
+  timeoutMs;
+  strategy;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "TimeoutError";
+    this.timeoutMs = options.timeoutMs;
+    this.strategy = options.strategy;
+  }
+}
+function timeout(options) {
+  if (!Number.isFinite(options.ms) || options.ms < 0) {
+    throw new RangeError(`timeout: ms must be a finite non-negative number, got ${options.ms}`);
+  }
+  const ms = options.ms;
+  const strategy = options.strategy ?? "optimistic";
+  const clock = options.clock ?? realClock;
+  const instruments = buildInstruments(options.telemetry);
+  async function execute(next, ctx) {
+    const inner = new AbortController;
+    const onParentAbort = () => {
+      inner.abort(ctx.signal.reason);
+    };
+    if (ctx.signal.aborted) {
+      throw ctx.signal.reason;
+    }
+    ctx.signal.addEventListener("abort", onParentAbort, { once: true });
+    const childCtx = withExecutionContext(ctx, { signal: inner.signal });
+    const timerController = new AbortController;
+    let timedOut = false;
+    const timerPromise = clock.sleep(ms, timerController.signal).then(() => {
+      timedOut = true;
+      const err2 = new TimeoutError(`timeout: operation exceeded ${ms}ms`, { timeoutMs: ms, strategy });
+      inner.abort(err2);
+      instruments.timeouts()?.add(1, { policy: "timeout", strategy });
+      instruments.addEvent("resilience.timeout.triggered", {
+        timeout_ms: ms,
+        strategy
+      });
+      return err2;
+    }, (reason) => {
+      throw reason;
+    });
+    let opSettled = false;
+    const opPromise = (async () => {
+      try {
+        const value = await next(childCtx);
+        opSettled = true;
+        timerController.abort();
+        return value;
+      } catch (error) {
+        opSettled = true;
+        timerController.abort();
+        throw error;
+      }
+    })();
+    try {
+      const winner = await Promise.race([
+        opPromise.then((value) => ({ kind: "ok", value })),
+        timerPromise.then((err2) => ({ kind: "timeout", err: err2 }))
+      ]);
+      if (winner.kind === "ok") {
+        return winner.value;
+      }
+      if (strategy === "pessimistic") {
+        try {
+          await opPromise;
+        } catch {}
+      } else {
+        opPromise.catch(() => {});
+      }
+      throw winner.err;
+    } finally {
+      ctx.signal.removeEventListener("abort", onParentAbort);
+      if (!opSettled && !timedOut) {
+        timerController.abort();
+      }
+    }
+  }
+  return {
+    name: "timeout",
+    ms,
+    strategy,
+    execute
+  };
+}
+export { currentContext, combine, exponentialBackoff, retry, timeout };

package/dist/index-dexgmwg6.js

@@ -0,0 +1,148 @@
+import {
+  InMemorySessionStore
+} from "./index-vnby35rm.js";
+import {
+  collectStream
+} from "./index-zfgr4xx3.js";
+
+// src/testing/index.ts
+function conversation(...messages) {
+  return messages;
+}
+var MOCK_CAPABILITIES = {
+  tools: true,
+  streaming: true,
+  multimodalInput: true,
+  parallelToolCalls: true,
+  structuredOutput: true
+};
+function mockProvider(opts = {}) {
+  const name = opts.name ?? "mock";
+  const defaultModel = opts.defaultModel ?? "mock-model";
+  const resultFor = (req) => {
+    if (typeof opts.result === "function")
+      return opts.result(req);
+    if (opts.result !== undefined)
+      return opts.result;
+    return {
+      message: { role: "assistant", content: [{ type: "text", text: "ok" }] },
+      toolCalls: [],
+      finishReason: "stop",
+      model: req.model ?? defaultModel,
+      raw: {}
+    };
+  };
+  const eventsFor = (req) => {
+    if (typeof opts.events === "function")
+      return opts.events(req);
+    if (opts.events !== undefined)
+      return opts.events;
+    const result = resultFor(req);
+    const text = result.message.content.filter((p) => p.type === "text").map((p) => p.text).join("");
+    const events = [{ type: "message_start", model: result.model }];
+    if (text !== "")
+      events.push({ type: "text_delta", text });
+    result.toolCalls.forEach((call, index) => {
+      const argumentsText = call.argumentsText ?? (call.arguments === undefined ? "" : JSON.stringify(call.arguments) ?? "");
+      events.push({ type: "tool_call_start", index, id: call.id, name: call.name });
+      if (argumentsText !== "")
+        events.push({ type: "tool_call_delta", index, argumentsTextDelta: argumentsText });
+      events.push({ type: "tool_call_end", index });
+    });
+    events.push({
+      type: "finish",
+      finishReason: result.finishReason,
+      ...result.usage !== undefined ? { usage: result.usage } : {}
+    });
+    return events;
+  };
+  return {
+    name,
+    defaultModel,
+    capabilities: { ...MOCK_CAPABILITIES, ...opts.capabilities },
+    async complete(req, ctx) {
+      opts.onRequest?.(req, ctx);
+      return resultFor(req);
+    },
+    async* stream(req, ctx) {
+      opts.onRequest?.(req, ctx);
+      for (const event of eventsFor(req))
+        yield event;
+    }
+  };
+}
+async function collectProviderStream(provider, req, ctx) {
+  return collectStream(provider.stream(req, ctx), req.model ?? provider.defaultModel);
+}
+function expectValid(schema, input) {
+  const result = schema.safeParse(input);
+  if (result.success)
+    return result.data;
+  const detail = result.error.issues.map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`).join("; ");
+  throw new Error(`expected input to be valid, but: ${detail}`);
+}
+function byteStreamOf(...chunks) {
+  const encoder = new TextEncoder;
+  return new ReadableStream({
+    start(controller) {
+      for (const chunk of chunks)
+        controller.enqueue(encoder.encode(chunk));
+      controller.close();
+    }
+  });
+}
+function jsonFetch(body, init) {
+  const calls = [];
+  const fetchImpl = async (input, requestInit) => {
+    calls.push({ url: String(input), init: requestInit });
+    return new Response(JSON.stringify(body), {
+      status: init?.status ?? 200,
+      headers: { "content-type": "application/json" }
+    });
+  };
+  return { fetch: fetchImpl, calls };
+}
+function sseFetch(sse) {
+  const calls = [];
+  const fetchImpl = async (input, requestInit) => {
+    calls.push({ url: String(input), init: requestInit });
+    return new Response(byteStreamOf(sse), {
+      status: 200,
+      headers: { "content-type": "text/event-stream" }
+    });
+  };
+  return { fetch: fetchImpl, calls };
+}
+var SCRIPTED_MODEL = "mock-model";
+function textResult(text, usage) {
+  return {
+    message: { role: "assistant", content: [{ type: "text", text }] },
+    toolCalls: [],
+    finishReason: "stop",
+    model: SCRIPTED_MODEL,
+    raw: {},
+    ...usage !== undefined ? { usage } : {}
+  };
+}
+function toolCallResult(calls, usage) {
+  return {
+    message: {
+      role: "assistant",
+      content: calls.map((c) => ({ type: "tool_call", id: c.id, name: c.name, arguments: c.arguments }))
+    },
+    toolCalls: calls,
+    finishReason: "tool_calls",
+    model: SCRIPTED_MODEL,
+    raw: {},
+    ...usage !== undefined ? { usage } : {}
+  };
+}
+function scriptedProvider(results, opts) {
+  let i = 0;
+  return mockProvider({ ...opts, result: () => results[Math.min(i++, results.length - 1)] });
+}
+function inMemorySessionStore() {
+  return new InMemorySessionStore;
+}
+
+export { conversation, mockProvider, collectProviderStream, expectValid, byteStreamOf, jsonFetch, sseFetch, textResult, toolCallResult, scriptedProvider, inMemorySessionStore };

package/dist/index-fkr3rcq9.js

@@ -0,0 +1,97 @@
+// src/events/hub.ts
+function createEventHub(opts = {}) {
+  const subscribers = (opts.subscribers ?? []).filter((s) => s !== undefined);
+  const onSubscriberError = opts.onSubscriberError;
+  return {
+    async emit(event) {
+      for (let i = 0;i < subscribers.length; i++) {
+        try {
+          await subscribers[i](event);
+        } catch (error) {
+          try {
+            onSubscriberError?.(error, event, i);
+          } catch {}
+        }
+      }
+    }
+  };
+}
+
+// src/events/telemetry.ts
+var SPAN_RUN = "agent.run";
+var SPAN_PROVIDER = "agent.provider.call";
+var SPAN_TOOL = "agent.tool.execute";
+var NOOP_SPAN = {
+  setAttributes() {},
+  ok() {},
+  fail() {},
+  end() {}
+};
+function wrapSpan(span) {
+  return {
+    setAttributes(attrs) {
+      span.setAttributes(attrs);
+    },
+    ok() {
+      span.setStatus({ code: "ok" });
+    },
+    fail(message) {
+      span.setStatus({ code: "error", message });
+    },
+    end() {
+      span.end();
+    }
+  };
+}
+function tokenTotal(usage) {
+  return usage.totalTokens + usage.inputTokens + usage.outputTokens;
+}
+function createRunTelemetry(telemetry) {
+  const tracer = telemetry?.tracer;
+  const meter = telemetry?.meter;
+  const runDuration = meter?.createHistogram("agent.run.duration", {
+    description: "Wall-clock duration of an agent run.",
+    unit: "ms"
+  });
+  const toolDuration = meter?.createHistogram("agent.tool.duration", {
+    description: "Wall-clock duration of a single tool execution.",
+    unit: "ms"
+  });
+  const tokens = meter?.createCounter("agent.tokens", {
+    description: "LLM tokens consumed by agent runs.",
+    unit: "1"
+  });
+  const runs = meter?.createCounter("agent.runs", {
+    description: "Completed agent runs, tagged by outcome.",
+    unit: "1"
+  });
+  return {
+    async withSpan(name, attrs, fn) {
+      if (tracer === undefined)
+        return fn(NOOP_SPAN);
+      return tracer.withSpan(name, (span) => {
+        span.setAttributes(attrs);
+        return fn(wrapSpan(span));
+      });
+    },
+    startSpan(name, attrs) {
+      if (tracer === undefined)
+        return NOOP_SPAN;
+      const span = tracer.startSpan(name, { attributes: attrs });
+      return wrapSpan(span);
+    },
+    recordRun(attrs, durationMs, usage) {
+      runDuration?.record(durationMs, attrs);
+      runs?.add(1, attrs);
+      if (tokenTotal(usage) > 0) {
+        tokens?.add(usage.inputTokens, { ...attrs, "token.type": "input" });
+        tokens?.add(usage.outputTokens, { ...attrs, "token.type": "output" });
+      }
+    },
+    recordTool(attrs, durationMs) {
+      toolDuration?.record(durationMs, attrs);
+    }
+  };
+}
+
+export { createEventHub, SPAN_RUN, SPAN_PROVIDER, SPAN_TOOL, createRunTelemetry };