@copilotkit/runtime 1.83.0 → 2.0.0-rc.0

package/dist/v2/runtime/runner/in-memory.d.mts

@@ -1,428 +0,0 @@
-
-import { AgentRunner, AgentRunnerConnectRequest, AgentRunnerIsRunningRequest, AgentRunnerRunRequest, AgentRunnerStopRequest, LocalThreadEndpointScope } from "./agent-runner.mjs";
-import { Observable, ReplaySubject } from "rxjs";
-import { AbstractAgent, BaseEvent, Message } from "@ag-ui/client";
-
-//#region src/v2/runtime/runner/in-memory.d.ts
-interface InMemoryLimits {
-  /** LRU cap on distinct threads. */
-  maxThreads?: number;
-  /** FIFO cap on runs kept per thread. `Infinity` or `0` disables the cap. */
-  maxRunsPerThread?: number;
-  /**
-   * Approximate byte ceiling on RETAINED thread/run history. Enforced at run
-   * completion (in `appendRun`), where LRU non-running threads are evicted to
-   * keep the total under this limit.
-   *
-   * Limitation: this bounds only history that has already been committed. A
-   * single in-flight run's buffered events (`currentRunEvents` and the two
-   * `ReplaySubject<BaseEvent>(Infinity)` buffers in `run()`) are NOT counted
-   * until that run completes, so `maxBytes` does not bound a single runaway
-   * run mid-stream.
-   *
-   * Limitation: byte eviction drops only other LRU non-running threads and
-   * never self-evicts the active/just-appended thread, so a single dominant
-   * thread's own retained history is not byte-trimmed (bounded only by
-   * `maxRunsPerThread`). `maxBytes` is thus a cross-thread ceiling enforced by
-   * evicting OTHER threads, not a per-thread cap.
-   */
-  maxBytes?: number;
-}
-/**
- * Constructor options for {@link InMemoryAgentRunner}.
- *
- * Extends {@link InMemoryLimits} so bounds can be passed inline alongside the
- * per-runner behavior flags. Be aware of the scope difference: the limits
- * reconfigure the process-global store shared by every runner, whereas
- * `onConcurrentRun` applies only to the runner instance it is passed to.
- */
-interface InMemoryAgentRunnerOptions extends InMemoryLimits {
-  /**
-   * How to handle a `run()` for a thread that already has an in-flight run.
-   * `"throw"` (default) rejects with "Thread already running". `"supersede"`
-   * aborts the prior run and starts the new one.
-   */
-  onConcurrentRun?: "throw" | "supersede";
-}
-declare const ɵINMEMORY_DEFAULTS: Required<InMemoryLimits>;
-/**
- * Normalize a fully-resolved limits bag so every field is well-formed before it
- * can reach an enforcement loop. Each field is validated independently against
- * {@link ɵisValidLimit}; an invalid value is CLAMPED to its
- * {@link ɵINMEMORY_DEFAULTS} floor and a single `console.warn` naming the field
- * and the received value is emitted.
- *
- * Clamp-and-warn (rather than throw) is deliberate and matches this file's
- * established posture toward bad input: `ɵestimateBytes` swallows serialization
- * failures and returns 0, the limits-clobber path warns rather than throwing,
- * and both the eviction and clobber logs are wrapped so "logging must never
- * break construction/a run". Constructing a bounded in-memory runner is a
- * best-effort, non-durable convenience; a typo'd bound must degrade to a safe
- * default, never abort construction or (worse) surface later as an unhandled
- * rejection from the fire-and-forget finalize path.
- */
-declare function ɵnormalizeLimits(limits: Required<InMemoryLimits>): Required<InMemoryLimits>;
-/**
- * Best-effort approximate byte size of a value, via serialized length.
- * Never throws — returns 0 when the value cannot be serialized. This is an
- * approximation (UTF-16 length, not exact heap bytes), used only for relative
- * accounting against `maxBytes`.
- */
-declare function ɵestimateBytes(value: unknown): number;
-/**
- * Per-run finalize intent, captured once when a run starts and mutated (only)
- * by whoever aborts THAT run — `stop()` or a superseding `run()`. The run's own
- * teardown reads this captured holder instead of the shared, mutable
- * `store.stopRequested`, so a later run that resets store state can never cause
- * an intentionally-stopped run to be finalized as an error (or vice versa).
- */
-interface RunFinalizeControl {
-  /** True once THIS run has been asked to stop (clean stop, not an error). */
-  stopRequested: boolean;
-}
-interface HistoricRun {
-  threadId: string;
-  runId: string;
-  /** ID of the agent that executed this run. */
-  agentId: string;
-  parentRunId: string | null;
-  events: BaseEvent[];
-  /**
-   * Snapshot of all messages (input + generated) at the end of this run, as
-   * passed in by the caller. NOTE: `BoundedThreadStore.appendRun` moves this
-   * snapshot to the THREAD level (`InMemoryEventStore.messagesSnapshot`) and
-   * clears this field to `[]`, so a stored HistoricRun never carries messages.
-   * The thread-messages fallback reads the thread-level snapshot, not this.
-   */
-  messages: Message[];
-  createdAt: number;
-  /** Approximate retained byte size of `events`; set by BoundedThreadStore at append. */
-  approxEventBytes?: number;
-  /**
-   * Legacy field retained for shape compatibility. `appendRun` always zeroes it
-   * because message bytes are accounted at the thread level, not per run.
-   */
-  approxMessageBytes?: number;
-}
-/**
- * Lightweight thread summary returned by {@link InMemoryAgentRunner.listThreads}.
- * Shape matches CopilotKit Intelligence's ThreadRecord so the same HTTP
- * response envelope can be used for both backends.
- */
-interface InMemoryThread {
-  id: string;
-  name: string | null;
-  agentId: string;
-  organizationId: "";
-  /** Identity that owns the thread; `""` for a thread created without identity. */
-  createdById: string;
-  archived: false;
-  createdAt: string;
-  updatedAt: string;
-}
-declare class InMemoryEventStore {
-  threadId: string;
-  readonly ownerId: string;
-  /**
-   * @param ownerId Identity that owns this thread, recorded when the thread is
-   * created by its first run. `""` is the anonymous owner;
-   * {@link ɵSERVER_THREAD_OWNER} is the owner of a thread created server-side.
-   */
-  constructor(threadId: string, ownerId: string);
-  /** The subject that current consumers subscribe to. */
-  subject: ReplaySubject<BaseEvent> | null;
-  /** True while a run is actively producing events. */
-  isRunning: boolean;
-  /** Current run ID */
-  currentRunId: string | null;
-  /** Historic completed runs */
-  historicRuns: HistoricRun[];
-  /** Currently running agent instance (if any). */
-  agent: AbstractAgent | null;
-  /** Subject returned from run() while the run is active. */
-  runSubject: ReplaySubject<BaseEvent> | null;
-  /**
-   * Thread-level lifecycle flag: true once a stop/supersede has been requested
-   * for the currently-owning run but that run has not yet finalized. Drives
-   * eviction protection, the connect() bridge, and stop() de-dup. This is NOT
-   * the finalize intent read by a run's teardown — that lives per-run on
-   * {@link activeFinalize}, so a superseding run resetting this field cannot
-   * mislabel the run it replaced. A new run resets this to false when it takes
-   * ownership.
-   */
-  stopRequested: boolean;
-  /**
-   * Finalize control of the currently-owning run. `stop()` and a superseding
-   * `run()` flip the owning run's flag through this reference; each run also
-   * captures the SAME object in its closure, so its teardown finalizes against
-   * its own intent regardless of what a later run does to the store.
-   */
-  activeFinalize: RunFinalizeControl | null;
-  /** Reference to the events emitted in the current run. */
-  currentEvents: BaseEvent[] | null;
-  /**
-   * The thread's single latest NON-EMPTY message snapshot, held at the THREAD
-   * level (independent of `historicRuns` lifecycle). Decoupling the snapshot
-   * from per-run storage means run-cap FIFO eviction and interleaved
-   * empty-snapshot runs can never drop or pin the thread's message history.
-   */
-  messagesSnapshot: Message[];
-  /** Approximate retained byte size of `messagesSnapshot`. */
-  approxMessagesSnapshotBytes: number;
-  /**
-   * The thread's true creation timestamp (epoch ms), captured from the FIRST
-   * run ever appended and held at the THREAD level (independent of
-   * `historicRuns` lifecycle). Decoupling it from per-run storage means run-cap
-   * FIFO eviction — which shifts the oldest entries off `historicRuns` — can
-   * never move the reported creation time forward. `null` until the first run
-   * lands. Mirrors the `messagesSnapshot` thread-level decoupling.
-   */
-  createdAt: number | null;
-}
-/**
- * How long, and how many, owner records the store keeps for threads that left
- * it through LRU eviction or a scoped clear. See
- * {@link ɵBoundedThreadStore.ownerOf}.
- *
- * When a record is added over a limit, expired records go first; then, when
- * the record's owner holds more than `maxEntriesPerOwner`, that owner's
- * oldest record; then, over `maxEntries`, the oldest record of any owner. So
- * one identity that churns threads (anonymous callers share one identity)
- * only displaces its own records. Residual risk: many distinct identities
- * together can still exceed `maxEntries` and push out another identity's
- * live record. That frees the id for a new owner but leaks nothing, since
- * the removed thread's history is already gone, and it needs the victim's
- * thread id.
- */
-interface ɵOwnerRetention {
-  /** Milliseconds an owner record is kept after its thread was removed. */
-  ttlMs: number;
-  /** Most owner records kept in all. */
-  maxEntries: number;
-  /** Most owner records kept for one owner. */
-  maxEntriesPerOwner: number;
-  /** Clock, replaceable in tests. */
-  now: () => number;
-}
-declare const ɵOWNER_RETENTION_DEFAULTS: ɵOwnerRetention;
-declare class ɵBoundedThreadStore {
-  private readonly map;
-  /**
-   * Owners of threads that were removed from `map`, oldest first. A removed
-   * thread's history is gone, but its id stays reserved for its owner until
-   * the record expires, so another identity cannot claim the id and receive
-   * the owner's next runs or later replays.
-   */
-  private readonly removedOwners;
-  /** The ids in `removedOwners`, per owner, oldest first. */
-  private readonly removedOwnersByOwner;
-  private ownerRetention;
-  private totalBytes;
-  private warned;
-  /** True once limits have been EXPLICITLY set (via setLimits), not just the constructor default. */
-  private limitsExplicitlySet;
-  /** Warn-once latch for the clobber warning, kept distinct from the eviction `warned` latch. */
-  private clobberWarned;
-  private limits;
-  constructor(limits: Required<InMemoryLimits>);
-  get byteTotal(): number;
-  /**
-   * The store's CURRENT effective bounds. Exposed (with the `ɵ` internal-API
-   * prefix) so a partial `setLimits` can coalesce unspecified fields against the
-   * live config rather than the hardcoded {@link ɵINMEMORY_DEFAULTS} — a partial
-   * update must be a partial update, never a silent reset of the fields the
-   * caller did not mention. Returns a copy so callers cannot mutate the store's
-   * bounds through it.
-   */
-  get ɵlimits(): Required<InMemoryLimits>;
-  /**
-   * Reconfigure the process-global store's bounds. Called by the
-   * {@link InMemoryAgentRunner} constructor when limits are passed. Because the
-   * store is a per-process singleton, this replaces the bounds for ALL in-memory
-   * threads. Emits {@link LIMITS_CLOBBER_GUIDANCE} at most ONCE per store when a
-   * SECOND (or later) explicit set arrives whose resolved values differ from the
-   * prior explicit set — i.e. a genuine clobber of an already-customized config.
-   * The first explicit customization (defaults → custom) is the intended
-   * override and never warns; identical re-sets never warn.
-   */
-  setLimits(limits: Required<InMemoryLimits>): void;
-  get size(): number;
-  /** Re-insert at the tail so Map iteration order stays LRU-first. */
-  private touchOrder;
-  /**
-   * The thread's store, created and owned by `ownerId` when it does not exist
-   * yet. An existing store keeps its owner; callers check access first.
-   */
-  getOrCreate(threadId: string, ownerId?: string): InMemoryEventStore;
-  get(threadId: string, opts: {
-    touch: boolean;
-  }): InMemoryEventStore | undefined;
-  peek(threadId: string): InMemoryEventStore | undefined;
-  /**
-   * Evict the least-recently-used thread that is neither running NOR
-   * mid-finalization. Returns false if none evictable. The `protect` thread
-   * (typically the one just created) is never evicted, so a fresh thread is not
-   * immediately dropped when it is the only non-running candidate.
-   *
-   * A thread is skipped while `isRunning` OR `stopRequested` is set.
-   * `stop()` flips `isRunning` to false the moment it aborts the agent, but the
-   * run keeps finalizing asynchronously (the abort trips the `catch` in
-   * `runAgent`, which later calls `appendRun`). During that window
-   * `stopRequested` stays true; evicting the thread then would make the pending
-   * `appendRun` hit `if (!store) return` and silently drop the aborted run's
-   * history. Guarding on `stopRequested` keeps the thread alive until
-   * finalization completes.
-   */
-  private evictOneLru;
-  /**
-   * Append a finished run to `writer`, the store its run started on. Nothing is
-   * written when `writer` is no longer the live store for `threadId` (the thread
-   * was removed, or removed and claimed again): a run must never write into a
-   * thread it did not start on, which may now belong to another owner.
-   */
-  appendRun(threadId: string, writer: InMemoryEventStore | undefined, run: HistoricRun): void;
-  private enforceRunCap;
-  /**
-   * Trim the store back under the byte ceiling by evicting LRU non-running
-   * threads. `protect` (the just-appended thread) is never self-evicted, so a
-   * fresh run pushes OTHER threads out rather than dropping itself.
-   */
-  private evictByBytesIfNeeded;
-  private removeThread;
-  /**
-   * Keep the owner of a removed thread, within the retention bounds. See
-   * {@link ɵOwnerRetention} for which records go first over a limit.
-   */
-  private rememberOwner;
-  /** Remove the owner record of `threadId`, if any. */
-  private forgetOwner;
-  /** Drop expired owner records. They are oldest first, so stop at the first live one. */
-  private pruneRemovedOwners;
-  /**
-   * Owner of `threadId`: the live thread's owner, or the retained owner of a
-   * thread that was evicted or cleared. `undefined` when nobody owns the id, so
-   * the next run may claim it.
-   */
-  ownerOf(threadId: string): string | undefined;
-  /** True when a caller acting as `owner` may run on, or claim, `threadId`. */
-  canClaim(threadId: string, owner: string): boolean;
-  /**
-   * Replace the owner-record retention. Omitted fields fall back to
-   * {@link ɵOWNER_RETENTION_DEFAULTS}. Internal: for tests.
-   */
-  ɵsetOwnerRetention(retention: Partial<ɵOwnerRetention>): void;
-  private evictThreadsIfNeeded;
-  private noteEviction;
-  listThreads(scope?: LocalThreadEndpointScope): InMemoryThread[];
-  /**
-   * Removes every thread visible to `scope`, except threads that are running
-   * or still finalizing: removing one would drop its owner record while its
-   * run still writes, so another identity could claim the id. Those threads
-   * stay, as in `evictOneLru`. A scoped clear leaves other owners' threads
-   * untouched.
-   *
-   * Without a scope the whole store is reset, running threads included. That
-   * is an internal reset for tests; `appendRun` keeps an orphaned run from
-   * writing into a thread created after the reset.
-   */
-  clear(scope?: LocalThreadEndpointScope): void;
-}
-/**
- * Process-wide singleton backing every {@link InMemoryAgentRunner}. Exported
- * (with the `ɵ` internal-API prefix) so tests can inspect the exact store the
- * runner writes to; not part of the public API.
- */
-declare const ɵGLOBAL_STORE: ɵBoundedThreadStore;
-declare class InMemoryAgentRunner extends AgentRunner {
-  readonly ɵsupportsLocalThreadEndpoints = true;
-  /**
-   * How to handle a `run()` for a thread that already has an in-flight run.
-   * `"throw"` (default) preserves the historic behavior. `"supersede"` aborts
-   * the prior run (mirroring `stop()`) and starts the new one — opted into by
-   * the hosted-bot listener so a fast follow-up turn on the same thread cleanly
-   * replaces a still-running (or wedged) prior turn instead of erroring with
-   * "Thread already running".
-   */
-  private readonly onConcurrentRun;
-  /**
-   * @param options Per-runner behavior (`onConcurrentRun`) plus optional bounds
-   * for the in-memory store ({@link InMemoryLimits}).
-   *
-   * Note the differing scopes: `onConcurrentRun` is per-runner instance, while
-   * the limits reconfigure the PROCESS-GLOBAL store shared by every
-   * `InMemoryAgentRunner`. Omit the limits for safe defaults
-   * ({@link ɵINMEMORY_DEFAULTS}); passing none leaves the store untouched. When
-   * multiple runners are constructed with differing limits, the last-constructed
-   * wins — in practice the OSS/SSE default construction passes nothing. If a
-   * second (or later) runner is constructed with limits that DIFFER from an
-   * already-customized store, a one-time `console.warn` is emitted to signal that
-   * the shared store's bounds are being clobbered for ALL in-memory threads.
-   */
-  constructor(options?: InMemoryAgentRunnerOptions);
-  run(request: AgentRunnerRunRequest): Observable<BaseEvent>;
-  connect(request: AgentRunnerConnectRequest): Observable<BaseEvent>;
-  isRunning(request: AgentRunnerIsRunningRequest): Promise<boolean>;
-  stop(request: AgentRunnerStopRequest): Promise<boolean | undefined>;
-  /**
-   * Returns a summary of every thread that `scope`'s owner holds in the
-   * process-wide store, which every InMemoryAgentRunner shares. Without a
-   * scope, the server owner's threads ({@link ɵSERVER_THREAD_OWNER}).
-   *
-   * This powers the local-dev fallback for `GET /threads` when the Intelligence
-   * platform is not configured. Each entry mirrors the shape of a platform
-   * `ThreadRecord` so the HTTP handler can use the same response envelope.
-   */
-  listThreads(scope?: LocalThreadEndpointScope): InMemoryThread[];
-  /**
-   * Returns all messages for a thread, using the snapshot captured at the end
-   * of the most recent run.
-   *
-   * This powers the local-dev fallback for `GET /threads/:threadId/messages`
-   * when CopilotKit Intelligence is not configured. The returned `Message[]`
-   * objects come directly from the ag-ui agent, so their shape is compatible
-   * with CopilotKit Intelligence's `ThreadMessage` type.
-   */
-  getThreadMessages(threadId: string, scope?: LocalThreadEndpointScope): Message[];
-  /**
-   * Returns all AG-UI events for a thread, compacted across historic runs.
-   *
-   * Powers the local-dev fallback for `GET /threads/:threadId/events` when the
-   * CopilotKit Intelligence is not configured. The compaction logic matches
-   * the connection-replay path in {@link connect}, so the stream a
-   * late-joining inspector sees matches what this method returns.
-   */
-  getThreadEvents(threadId: string, scope?: LocalThreadEndpointScope): BaseEvent[];
-  /**
-   * Returns the agent state snapshot for a thread.
-   *
-   * Derived from the last `STATE_SNAPSHOT` in the compacted event stream. The
-   * AG-UI `compactEvents` helper consolidates STATE_DELTA events and produces
-   * a single trailing STATE_SNAPSHOT when state changes exist, so this is a
-   * faithful view of state at the end of the most recent run.
-   *
-   * Returns `null` when the thread has never emitted a STATE_SNAPSHOT.
-   */
-  getThreadState(threadId: string, scope?: LocalThreadEndpointScope): Record<string, unknown> | null;
-  /**
-   * Clears the in-memory history of `scope`'s threads (without a scope, the
-   * server owner's). A thread with a run still active or finalizing is kept;
-   * see {@link ɵBoundedThreadStore.clear}.
-   *
-   * Powers the local-dev fallback for `POST /threads/clear`, letting consumers
-   * (e.g. the demo's Clear button) reset to an empty thread list without
-   * restarting the runtime. Intentionally not exposed on the Intelligence
-   * platform path: there, thread history lives in a real database and must
-   * not be wiped this way.
-   */
-  clearThreads(scope?: LocalThreadEndpointScope): void;
-  /**
-   * False when the thread id is held by an owner other than `scope`'s: a
-   * live thread, or the retained owner of an evicted or cleared one.
-   */
-  isThreadAccessible(threadId: string, scope: LocalThreadEndpointScope): boolean;
-  /** The thread's store, or `undefined` when unknown or not visible to `scope`. */
-  private peekVisible;
-}
-//#endregion
-export { InMemoryAgentRunner, InMemoryAgentRunnerOptions, InMemoryLimits, InMemoryThread, ɵBoundedThreadStore, ɵGLOBAL_STORE, ɵINMEMORY_DEFAULTS, ɵOWNER_RETENTION_DEFAULTS, ɵOwnerRetention, ɵestimateBytes, ɵnormalizeLimits };
-//# sourceMappingURL=in-memory.d.mts.map

package/dist/v2/runtime/runner/in-memory.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"in-memory.d.mts","names":[],"sources":["../../../../src/v2/runtime/runner/in-memory.ts"],"mappings":"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"}