@infinityi/engine-lib 1.0.0

package/dist/index-vnby35rm.js

@@ -0,0 +1,84 @@
+// src/session/store.ts
+class InMemorySessionStore {
+  entries = new Map;
+  load(id) {
+    const entry = this.entries.get(id);
+    if (entry === undefined)
+      return Promise.resolve(undefined);
+    const state = {
+      id,
+      messages: [...entry.messages],
+      ...entry.metadata !== undefined ? { metadata: { ...entry.metadata } } : {}
+    };
+    return Promise.resolve(state);
+  }
+  append(id, messages) {
+    const entry = this.entries.get(id);
+    if (entry === undefined) {
+      this.entries.set(id, { messages: [...messages] });
+    } else {
+      entry.messages.push(...messages);
+    }
+    return Promise.resolve();
+  }
+  save(state) {
+    this.entries.set(state.id, {
+      messages: [...state.messages],
+      ...state.metadata !== undefined ? { metadata: { ...state.metadata } } : {}
+    });
+    return Promise.resolve();
+  }
+  delete(id) {
+    this.entries.delete(id);
+    return Promise.resolve();
+  }
+}
+
+// src/session/session.ts
+function generateId() {
+  return `session_${crypto.randomUUID()}`;
+}
+function createSession(opts = {}) {
+  const id = opts.id ?? generateId();
+  const store = opts.store ?? new InMemorySessionStore;
+  const seed = opts.messages;
+  const metadata = opts.metadata;
+  let seedPromise;
+  const ensureSeeded = () => {
+    if (seedPromise !== undefined)
+      return seedPromise;
+    seedPromise = (async () => {
+      if (seed === undefined || seed.length === 0)
+        return;
+      const existing = await store.load(id);
+      if (existing === undefined || existing.messages.length === 0) {
+        await store.append(id, seed);
+      }
+    })();
+    return seedPromise;
+  };
+  return {
+    id,
+    ...metadata !== undefined ? { metadata } : {},
+    async messages() {
+      await ensureSeeded();
+      const state = await store.load(id);
+      return state === undefined ? [] : [...state.messages];
+    },
+    async append(messages) {
+      await ensureSeeded();
+      if (messages.length === 0)
+        return;
+      await store.append(id, messages);
+    },
+    async clear() {
+      const inflight = seedPromise;
+      seedPromise = Promise.resolve();
+      if (inflight !== undefined) {
+        await inflight.catch(() => {});
+      }
+      await store.delete(id);
+    }
+  };
+}
+export { InMemorySessionStore, createSession };

package/dist/index-w34cbktd.js

@@ -0,0 +1,14 @@
+// src/tools/define.ts
+function defineTool(spec) {
+  if (typeof spec.name !== "string" || spec.name.trim() === "") {
+    throw new TypeError("defineTool: `name` must be a non-empty string");
+  }
+  const tool = {
+    name: spec.name,
+    ...spec.description !== undefined ? { description: spec.description } : {},
+    parameters: spec.parameters,
+    execute: spec.execute
+  };
+  return Object.freeze(tool);
+}
+export { defineTool };

package/dist/index-xsv43c5j.js

@@ -0,0 +1,39 @@
+// node_modules/@infinityi/forge/dist/index-63ccs1gh.js
+var REDACTED = "[REDACTED]";
+var INSPECT_CUSTOM = Symbol.for("nodejs.util.inspect.custom");
+
+class Secret {
+  #value;
+  constructor(value) {
+    this.#value = value;
+  }
+  unwrap() {
+    return this.#value;
+  }
+  toString() {
+    return REDACTED;
+  }
+  toJSON() {
+    return REDACTED;
+  }
+  [INSPECT_CUSTOM]() {
+    return `Secret <${REDACTED}>`;
+  }
+}
+function isSecret(value) {
+  return value instanceof Secret;
+}
+
+// node_modules/@infinityi/forge/dist/index-y8kftjjy.js
+var LEAF_BRAND = Symbol.for("forge/config/leaf");
+
+// node_modules/@infinityi/forge/dist/index-yxhr4ame.js
+var TRUE_TOKENS = new Set(["true", "1", "yes"]);
+var FALSE_TOKENS = new Set(["false", "0", "no"]);
+
+// src/runtime/secret.ts
+function resolveSecret(value) {
+  return isSecret(value) ? value.unwrap() : value;
+}
+
+export { Secret, isSecret, resolveSecret };

package/dist/index-yrqrxwjt.js

@@ -0,0 +1,148 @@
+import {
+  ContextWindowError
+} from "./index-7690reng.js";
+import {
+  system
+} from "./index-1p6mb2vz.js";
+
+// src/context/providers.ts
+function renderItem(item) {
+  const body = typeof item.content === "string" ? item.content : JSON.stringify(item.content, null, 2) ?? "";
+  return item.title !== undefined && item.title !== "" ? `## ${item.title}
+${body}` : body;
+}
+function staticContext(content, title) {
+  const item = { content, ...title !== undefined ? { title } : {} };
+  return {
+    name: "static",
+    resolve: () => [item]
+  };
+}
+function dynamicContext(name, fn, title) {
+  return {
+    name,
+    resolve: async (ctx) => {
+      const content = await fn(ctx);
+      return [{ content, ...title !== undefined ? { title } : {} }];
+    }
+  };
+}
+async function resolveContext(providers, ctx) {
+  if (providers === undefined || providers.length === 0)
+    return [];
+  const resolved = await Promise.all(providers.map((p) => p.resolve(ctx)));
+  const blocks = resolved.flat().map(renderItem).filter((s) => s !== "");
+  if (blocks.length === 0)
+    return [];
+  return [system(blocks.join(`
+
+`))];
+}
+
+// src/context/window.ts
+function partChars(part) {
+  switch (part.type) {
+    case "text":
+      return part.text.length;
+    case "tool_result":
+      return part.content.reduce((n, t) => n + t.text.length, 0);
+    case "tool_call":
+      return part.name.length + JSON.stringify(part.arguments ?? null).length;
+    case "image":
+      return part.data.length;
+  }
+}
+function estimateTokens(messages) {
+  let chars = 0;
+  for (const message of messages) {
+    for (const part of message.content)
+      chars += partChars(part);
+  }
+  return Math.ceil(chars / 4);
+}
+function transcript(messages) {
+  return messages.map((m) => {
+    const body = m.content.map((p) => {
+      if (p.type === "text")
+        return p.text;
+      if (p.type === "tool_result")
+        return p.content.map((t) => t.text).join(" ");
+      if (p.type === "tool_call")
+        return `[tool_call ${p.name} ${JSON.stringify(p.arguments)}]`;
+      return "";
+    }).filter((s) => s !== "").join(" ");
+    return `${m.role}: ${body}`;
+  }).join(`
+`);
+}
+function truncateOldest() {
+  return {
+    name: "truncate-oldest",
+    reduce(messages, ctx) {
+      const systemMsgs = messages.filter((m) => m.role === "system");
+      const rest = messages.filter((m) => m.role !== "system");
+      const kept = [...rest];
+      while (kept.length > 0 && ctx.countTokens([...systemMsgs, ...kept]) > ctx.maxTokens) {
+        kept.shift();
+      }
+      const result = [...systemMsgs, ...kept];
+      const tokens = ctx.countTokens(result);
+      if (tokens > ctx.maxTokens) {
+        throw new ContextWindowError(`context window exceeded: ${tokens} tokens > limit ${ctx.maxTokens} (irreducible)`, { tokens, limit: ctx.maxTokens });
+      }
+      return result;
+    }
+  };
+}
+function summarizeOldest(opts = {}) {
+  const keepRecent = opts.keepRecent ?? 4;
+  return {
+    name: "summarize-oldest",
+    async reduce(messages, ctx) {
+      const systemMsgs = messages.filter((m) => m.role === "system");
+      const rest = messages.filter((m) => m.role !== "system");
+      const splitAt = Math.max(0, rest.length - keepRecent);
+      const older = rest.slice(0, splitAt);
+      const recent = rest.slice(splitAt);
+      let result;
+      if (older.length === 0) {
+        result = [...systemMsgs, ...recent];
+      } else {
+        const req = {
+          model: ctx.model,
+          messages: [
+            system("Summarize the following conversation transcript concisely, preserving " + "facts, decisions, and open questions. Output only the summary."),
+            { role: "user", content: [{ type: "text", text: transcript(older) }] }
+          ]
+        };
+        const completion = await ctx.provider.complete(req, ctx.engine);
+        const summaryText = completion.message.content.filter((p) => p.type === "text").map((p) => p.text).join("");
+        const summary = system(`Summary of earlier conversation:
+${summaryText}`);
+        result = [...systemMsgs, summary, ...recent];
+      }
+      const tokens = ctx.countTokens(result);
+      if (tokens > ctx.maxTokens) {
+        throw new ContextWindowError(`context window exceeded: ${tokens} tokens > limit ${ctx.maxTokens} (irreducible)`, { tokens, limit: ctx.maxTokens });
+      }
+      return result;
+    }
+  };
+}
+async function applyContextWindow(messages, window, ctx) {
+  if (window === undefined)
+    return messages;
+  const countTokens = window.countTokens ?? estimateTokens;
+  if (countTokens(messages) <= window.maxTokens)
+    return messages;
+  const strategy = window.strategy ?? truncateOldest();
+  return strategy.reduce([...messages], {
+    maxTokens: window.maxTokens,
+    countTokens,
+    provider: ctx.provider,
+    model: ctx.model,
+    engine: ctx.engine
+  });
+}
+
+export { staticContext, dynamicContext, resolveContext, estimateTokens, truncateOldest, summarizeOldest, applyContextWindow };

package/dist/index-zfgr4xx3.js

@@ -0,0 +1,90 @@
+// src/providers/stream.ts
+function parseArguments(text) {
+  if (text.trim() === "")
+    return;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return;
+  }
+}
+
+class StreamAccumulator {
+  model;
+  text = "";
+  finishReason = "stop";
+  usage;
+  toolCalls = new Map;
+  push(event) {
+    switch (event.type) {
+      case "message_start":
+        this.model = event.model;
+        break;
+      case "text_delta":
+        this.text += event.text;
+        break;
+      case "tool_call_start":
+        this.toolCalls.set(event.index, {
+          id: event.id,
+          name: event.name,
+          argumentsText: ""
+        });
+        break;
+      case "tool_call_delta": {
+        const call = this.toolCalls.get(event.index);
+        if (call)
+          call.argumentsText += event.argumentsTextDelta;
+        break;
+      }
+      case "tool_call_end":
+        break;
+      case "finish":
+        this.finishReason = event.finishReason;
+        if (event.usage !== undefined)
+          this.usage = event.usage;
+        break;
+      case "error":
+        this.finishReason = "error";
+        break;
+    }
+  }
+  result(model, raw) {
+    const resolvedModel = this.model ?? model;
+    const ordered = [...this.toolCalls.entries()].sort(([a], [b]) => a - b).map(([, c]) => c);
+    const content = [];
+    if (this.text !== "")
+      content.push({ type: "text", text: this.text });
+    for (const call of ordered) {
+      const part = {
+        type: "tool_call",
+        id: call.id,
+        name: call.name,
+        arguments: parseArguments(call.argumentsText)
+      };
+      content.push(part);
+    }
+    const message = { role: "assistant", content };
+    const toolCalls = ordered.map((call) => ({
+      id: call.id,
+      name: call.name,
+      arguments: parseArguments(call.argumentsText),
+      argumentsText: call.argumentsText
+    }));
+    return {
+      message,
+      toolCalls,
+      finishReason: this.toolCalls.size > 0 && this.finishReason === "stop" ? "tool_calls" : this.finishReason,
+      ...this.usage !== undefined ? { usage: this.usage } : {},
+      model: resolvedModel,
+      raw
+    };
+  }
+}
+async function collectStream(events, model, raw) {
+  const accumulator = new StreamAccumulator;
+  for await (const event of events)
+    accumulator.push(event);
+  return accumulator.result(model, raw);
+}
+
+export { StreamAccumulator, collectStream };

package/dist/index.d.ts

@@ -0,0 +1,45 @@
+/**
+ * `@infinityi/engine-lib` — agent infrastructure for TypeScript, built on
+ * `@infinityi/forge`.
+ *
+ * This root barrel re-exports the stable, ergonomic public surface: schemas,
+ * messages, errors, provider factories, tools, agents, multi-agent helpers, the
+ * execution loop, sessions, context helpers, and event subscribers.
+ *
+ * Lower-level adapter and transport helpers are intentionally kept off the root
+ * import. Every domain is importable from its own subpath for tree-shaking and
+ * for advanced integrations:
+ * `@infinityi/engine-lib/schema`, `@infinityi/engine-lib/messages`, `@infinityi/engine-lib/errors`,
+ * `@infinityi/engine-lib/runtime`, `@infinityi/engine-lib/providers`, `@infinityi/engine-lib/tools`,
+ * `@infinityi/engine-lib/agent`, `@infinityi/engine-lib/execution`, `@infinityi/engine-lib/session`,
+ * `@infinityi/engine-lib/context`, `@infinityi/engine-lib/events`, and `@infinityi/engine-lib/lifecycle`
+ * (forge lifecycle adapter). Test-only helpers live on `@infinityi/engine-lib/testing`,
+ * and the fixture-driven provider battery on `@infinityi/engine-lib/testing/conformance`
+ * (the only subpath that imports a test runner).
+ *
+ * @module
+ */
+export { AgentError, CancelledError, ContextWindowError, ExecutionError, MaxHandoffsExceededError, MaxStepsExceededError, ProviderError, SchemaValidationError, ToolError, ToolValidationError, } from "./errors";
+export type { SchemaIssue } from "./errors";
+export { asSchema, fromJsonSchema, s, toJsonSchema, validateJsonSchema } from "./schema/index";
+export type { Infer, JsonSchema, SafeParseResult, Schema } from "./schema/index";
+export { assistant, normalizeContent, system, text, toolResult, user, } from "./messages/index";
+export type { ContentPart, ImagePart, Message, Role, TextPart, ToolCallPart, ToolResultPart, } from "./messages/index";
+export { isSecret, resolveSecret, Secret } from "./runtime/index";
+export type { EngineContext, TelemetryHandle } from "./runtime/index";
+export { createAnthropic, createGoogle, createOpenAI, createOpenAICompatible, } from "./providers/index";
+export type { AnthropicOptions, CompletionRequest, CompletionResult, FinishReason, GoogleOptions, OpenAICompatibleOptions, OpenAIOptions, Provider, ProviderCapabilities, ProviderTool, ResponseSchema, StreamEvent, ToolCall, ToolChoice, Usage, } from "./providers/index";
+export { defineTool } from "./tools/index";
+export type { ToolContext, ToolDefinition, ToolFailure, ToolResult, ToolSpec, ToolSuccess, } from "./tools/index";
+export { defineAgent } from "./agent/index";
+export type { AgentDefinition, AgentHooks, GenerationSettings, InstructionContext, Instructions, } from "./agent/index";
+export { asTool, createAgentRegistry } from "./agent/index";
+export type { AgentRegistry, AsToolOptions } from "./agent/index";
+export { runAgent } from "./execution/index";
+export type { AnyRunOptions, BufferedRunOptions, RunBridge, RunEvent, RunHandle, RunInput, RunOptions, RunResult, StreamingRunOptions, } from "./execution/index";
+export { createSession, InMemorySessionStore } from "./session/index";
+export type { CreateSessionOptions, Session, SessionState, SessionStore, } from "./session/index";
+export { dynamicContext, staticContext, summarizeOldest, truncateOldest, } from "./context/index";
+export type { ContextItem, ContextProvider, ContextStrategy, ContextStrategyContext, ContextWindowOptions, TokenCounter, } from "./context/index";
+export { createEventHub, loggingSubscriber, messageBusSubscriber, } from "./events/index";
+export type { EventHub, EventHubOptions, LoggingSubscriberOptions, LogLevel, MessageBusSubscriberOptions, RunSubscriber, } from "./events/index";

package/dist/index.js

@@ -0,0 +1,117 @@
+import"./index-kte2h4k2.js";
+import"./index-d4xz3abn.js";
+import {
+  loggingSubscriber,
+  messageBusSubscriber
+} from "./index-jxgj4z08.js";
+import {
+  InMemorySessionStore,
+  createSession
+} from "./index-vnby35rm.js";
+import"./index-19pwq79t.js";
+import"./index-jg19te9v.js";
+import {
+  createAnthropic,
+  createGoogle,
+  createOpenAI,
+  createOpenAICompatible
+} from "./index-64tt9696.js";
+import"./index-bqg01r42.js";
+import {
+  Secret,
+  isSecret,
+  resolveSecret
+} from "./index-xsv43c5j.js";
+import {
+  asTool,
+  createAgentRegistry,
+  defineAgent
+} from "./index-jp2b31xs.js";
+import {
+  runAgent
+} from "./index-pwr8179t.js";
+import {
+  dynamicContext,
+  staticContext,
+  summarizeOldest,
+  truncateOldest
+} from "./index-yrqrxwjt.js";
+import {
+  createEventHub
+} from "./index-fkr3rcq9.js";
+import {
+  asSchema,
+  fromJsonSchema,
+  s,
+  toJsonSchema,
+  validateJsonSchema
+} from "./index-02s1fjxr.js";
+import"./index-zfgr4xx3.js";
+import {
+  AgentError,
+  CancelledError,
+  ContextWindowError,
+  ExecutionError,
+  MaxHandoffsExceededError,
+  MaxStepsExceededError,
+  ProviderError,
+  SchemaValidationError,
+  ToolError,
+  ToolValidationError
+} from "./index-7690reng.js";
+import {
+  defineTool
+} from "./index-w34cbktd.js";
+import"./index-rentvdpp.js";
+import {
+  assistant,
+  normalizeContent,
+  system,
+  text,
+  toolResult,
+  user
+} from "./index-1p6mb2vz.js";
+export {
+  validateJsonSchema,
+  user,
+  truncateOldest,
+  toolResult,
+  toJsonSchema,
+  text,
+  system,
+  summarizeOldest,
+  staticContext,
+  s,
+  runAgent,
+  resolveSecret,
+  normalizeContent,
+  messageBusSubscriber,
+  loggingSubscriber,
+  isSecret,
+  fromJsonSchema,
+  dynamicContext,
+  defineTool,
+  defineAgent,
+  createSession,
+  createOpenAICompatible,
+  createOpenAI,
+  createGoogle,
+  createEventHub,
+  createAnthropic,
+  createAgentRegistry,
+  assistant,
+  asTool,
+  asSchema,
+  ToolValidationError,
+  ToolError,
+  Secret,
+  SchemaValidationError,
+  ProviderError,
+  MaxStepsExceededError,
+  MaxHandoffsExceededError,
+  InMemorySessionStore,
+  ExecutionError,
+  ContextWindowError,
+  CancelledError,
+  AgentError
+};

package/dist/lifecycle/component.d.ts

@@ -0,0 +1,74 @@
+/**
+ * `agentRuntimeComponent` — adapt the engine-lib runtime to a
+ * `@infinityi/forge/lifecycle` {@link Component} (Phase 8).
+ *
+ * engine-lib itself is mostly stateless — providers are HTTP clients, sessions
+ * live behind a {@link SessionStore} — so this adapter doesn't invent a runtime
+ * object. Instead it bundles the pieces an app wires up (providers, an optional
+ * session store, telemetry) into the tiny `{ name, start?, stop?, healthcheck? }`
+ * seam Forge orchestrates, so the runtime boots and drains cleanly alongside the
+ * rest of a Forge application (Principle 6 — composable; Principle 7 — no global
+ * state, just a plain object).
+ *
+ * - `start()` fail-fast validates the config (unique provider names, non-empty
+ *   default models) and, if `probeOnStart`, probes every provider so a bad
+ *   deployment rolls back during `forge.boot` instead of failing the first run.
+ * - `healthcheck()` maps provider probes to a Forge {@link HealthResult}
+ *   (`healthy` / `degraded` / `unhealthy`) for readiness/liveness routes.
+ * - `stop()` runs the optional `onStop` hook (e.g. flush/close a durable session
+ *   store), bounded by the shutdown `signal`.
+ *
+ * @example
+ * ```ts
+ * import { forge } from "@infinityi/forge/lifecycle";
+ * import { agentRuntimeComponent } from "@infinityi/engine-lib/lifecycle";
+ *
+ * const app = await forge.boot({
+ *   components: [
+ *     agentRuntimeComponent({
+ *       providers: [openai],
+ *       sessionStore: store,
+ *       probe: (p, signal) => p.complete({ messages: [user("ping")] }, { signal }).then(() => {}),
+ *       probeOnStart: true,
+ *       onStop: () => store.close(),
+ *     }),
+ *   ],
+ * });
+ * ```
+ *
+ * @module
+ */
+import type { Component } from "@infinityi/forge/lifecycle";
+import type { Provider } from "../providers/types";
+import type { TelemetryHandle } from "../runtime/types";
+import type { SessionStore } from "../session/types";
+/** Probe a single provider for readiness; rejects/throws when unhealthy. */
+export type ProviderProbe = (provider: Provider, signal: AbortSignal) => Promise<void> | void;
+/** Configuration for {@link agentRuntimeComponent}. */
+export interface AgentRuntimeOptions {
+    /** Component id used in logs / health output. Default `"agent-runtime"`. */
+    readonly name?: string;
+    /** Providers the runtime serves; validated on start and probed on health. */
+    readonly providers?: readonly Provider[];
+    /** Session store the runtime uses; surfaced for health/reporting. */
+    readonly sessionStore?: SessionStore;
+    /** Telemetry handle (reserved for runtime wiring; not required). */
+    readonly telemetry?: TelemetryHandle;
+    /**
+     * Optional readiness probe run per provider during `healthcheck` (and during
+     * `start` when {@link AgentRuntimeOptions.probeOnStart} is set).
+     */
+    readonly probe?: ProviderProbe;
+    /** Probe every provider during `start`, failing boot if any probe rejects. */
+    readonly probeOnStart?: boolean;
+    /** Flush/close hook run on `stop` (e.g. close a durable session store). */
+    readonly onStop?: (signal: AbortSignal) => Promise<void> | void;
+}
+/**
+ * Adapt an engine-lib runtime into a Forge lifecycle {@link Component}.
+ *
+ * The returned object only contributes the seams it can implement: `start`
+ * (always), `stop` (always — runs `onStop` when provided), and `healthcheck`
+ * (always — a no-op-healthy probe when none is configured).
+ */
+export declare function agentRuntimeComponent(opts: AgentRuntimeOptions): Component;

package/dist/lifecycle/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `@infinityi/engine-lib/lifecycle` — Forge lifecycle integration (Phase 8).
+ *
+ * Opt-in subpath that adapts the engine-lib runtime to a
+ * `@infinityi/forge/lifecycle` {@link Component} via {@link agentRuntimeComponent},
+ * so the runtime starts, health-checks, and drains inside a Forge app. Importing
+ * it is the only thing that pulls in the forge lifecycle surface.
+ *
+ * @module
+ */
+export { agentRuntimeComponent } from "./component";
+export type { AgentRuntimeOptions, ProviderProbe } from "./component";