@copilotkit/runtime 2.0.0-next.1 → 2.0.0-rc.0

package/dist/runtime/core/runtime.d.cts

@@ -0,0 +1,481 @@
+import { AgentRunner } from "../runner/agent-runner.cjs";
+import { ThreadAccessMode, ThreadsConfig } from "../handlers/shared/thread-access.cjs";
+import { ForwardHeadersConfig, ResolvedForwardHeadersPolicy } from "../handlers/header-utils.cjs";
+import { AfterRequestMiddleware, BeforeRequestMiddleware } from "./middleware.cjs";
+import { CopilotRuntimeLogger } from "./logger.cjs";
+import { TranscriptionService } from "../transcription-service/transcription-service.cjs";
+import { DebugEventBus } from "./debug-event-bus.cjs";
+import { CopilotRuntimeLearningConfig, CopilotRuntimeLearningContext, CopilotRuntimeUser, GetLearningContainerId, GetTrajectoryLearningContainerIds, LearningContainerSelectorInput, TrajectoryLearningContainerSelectorInput } from "./learning.cjs";
+import { CopilotKitIntelligence } from "../intelligence-platform/client.cjs";
+import "../intelligence-platform/index.cjs";
+import { TelemetryCapture } from "../telemetry/telemetry-client.cjs";
+import { DebugConfig, MaybePromise, NonEmptyRecord, RUNTIME_MODE_INTELLIGENCE, RUNTIME_MODE_SSE, ResolvedDebugConfig, RuntimeMode } from "@copilotkit/shared";
+import { LicenseChecker } from "@copilotkit/license-verifier";
+import { AbstractAgent } from "@ag-ui/client";
+import { MCPClientConfig } from "@ag-ui/mcp-apps-middleware";
+import { A2UIMiddlewareConfig } from "@ag-ui/a2ui-middleware";
+import { Channel } from "@copilotkit/channels-core";
+
+//#region src/runtime/core/runtime.d.ts
+declare const VERSION: string;
+interface BaseCopilotRuntimeMiddlewareOptions {
+  /** If set, middleware only applies to these named agents. Applies to all agents if omitted. */
+  agents?: string[];
+}
+/** Per-server tool policy belongs to the external middleware, and the release the runtime depends on does not support it. */
+type McpAppsServerConfig = MCPClientConfig & {
+  /** Intelligence-only HTTP/SSE credentials from trusted server config, never iframe input. */headers?: Record<string, string>; /** Agent to bind this server to. If omitted, the server is available to all agents. */
+  agentId?: string;
+};
+interface McpAppsConfig {
+  /** List of MCP server configurations. */
+  servers: McpAppsServerConfig[];
+}
+interface OpenGenerativeUIOptions extends BaseCopilotRuntimeMiddlewareOptions {}
+type OpenGenerativeUIConfig = boolean | OpenGenerativeUIOptions;
+interface CopilotRuntimeMiddlewares {
+  /**
+   * Auto-apply A2UIMiddleware to agents at run time.
+   * Pass an object to enable and customise behaviour, or omit to disable.
+   */
+  a2ui?: BaseCopilotRuntimeMiddlewareOptions & A2UIMiddlewareConfig & {
+    /**
+     * Explicit on/off switch. Omit (or set `true`) to enable; set `false`
+     * to disable A2UI for this runtime while keeping the rest of the config
+     * (e.g. a `schema`/`catalog`) in place. A bare `a2ui: {}` stays enabled
+     * for backwards compatibility.
+     */
+    enabled?: boolean;
+  };
+  /** Auto-apply MCPAppsMiddleware to agents at run time. */
+  mcpApps?: McpAppsConfig;
+  /** Auto-apply OpenGenerativeUIMiddleware to agents at run time. */
+  openGenerativeUI?: OpenGenerativeUIConfig;
+  /**
+   * Experimental: CopilotKit generative UI surfaces (`render_ui`).
+   *
+   * - Omitted: applied to a run when the React provider sends a
+   *   tool-transport envelope (`forwardedProps.copilotkit.ui`).
+   * - `true`: applied to every run.
+   * - `{ agents }`: applied to every run of the named agents.
+   * - `false`: never applied.
+   *
+   * A run with a markdown-transport envelope never gets it: the model writes
+   * the UI in a2ui code fences, and the client renders them.
+   */
+  generativeUI?: boolean | BaseCopilotRuntimeMiddlewareOptions;
+}
+/**
+ * Context passed to agent factory functions for per-request agent resolution.
+ */
+interface AgentFactoryContext {
+  /** The incoming HTTP request. */
+  request: Request;
+}
+/**
+ * A function that dynamically creates agents on a per-request basis.
+ * Useful for multi-tenant scenarios or request-scoped agent configuration.
+ */
+type AgentsFactory = (ctx: AgentFactoryContext) => MaybePromise<NonEmptyRecord<Record<string, AbstractAgent>>>;
+/**
+ * Agents can be provided as:
+ * - A static record of agents
+ * - A Promise that resolves to a record of agents
+ * - A factory function that receives request context and returns agents (or a Promise of agents)
+ */
+type AgentsConfig = MaybePromise<NonEmptyRecord<Record<string, AbstractAgent>>> | AgentsFactory;
+/**
+ * Resolve an AgentsConfig value to a concrete record of agents.
+ * If the config is a factory function, it is called with the given request context.
+ * Otherwise it is awaited directly (static record or Promise).
+ */
+declare function resolveAgents(agents: AgentsConfig, request?: Request): Promise<Record<string, AbstractAgent>>;
+interface BaseCopilotRuntimeOptions extends CopilotRuntimeMiddlewares {
+  /**
+   * Map of available agents, or a factory function for per-request agent resolution.
+   *
+   * Static record:
+   * ```ts
+   * agents: { support: new SupportAgent(), technical: new TechnicalAgent() }
+   * ```
+   *
+   * Factory function (called per-request):
+   * ```ts
+   * agents: ({ request }) => {
+   *   const tenantId = request.headers.get("x-tenant-id");
+   *   return { default: createAgentForTenant(tenantId) };
+   * }
+   * ```
+   */
+  agents: AgentsConfig;
+  /** Optional transcription service for audio processing. */
+  transcriptionService?: TranscriptionService;
+  /** Optional *before* middleware – callback function or webhook URL. */
+  beforeRequestMiddleware?: BeforeRequestMiddleware;
+  /** Optional *after* middleware – callback function or webhook URL. */
+  afterRequestMiddleware?: AfterRequestMiddleware;
+  /** Signed license token for server-side feature verification. Falls back to COPILOTKIT_LICENSE_TOKEN env var. */
+  licenseToken?: string;
+  /** Standalone telemetry identity. Falls back to CPK_TELEMETRY_ID before legacy license identity. */
+  telemetryId?: string;
+  /**
+   * Properties added to every telemetry event this runtime sends.
+   *
+   * For what is true of the whole process rather than of one event. A product
+   * built on this runtime can name itself here and then be told apart in the
+   * events that already go, rather than sending events of its own.
+   *
+   * No effect when telemetry is off: nothing is sent, so nothing carries this.
+   */
+  telemetryProperties?: Record<string, unknown>;
+  /**
+   * A capture scope to emit this runtime's telemetry through, instead of one
+   * built from the identity options above.
+   *
+   * @internal Set by the deprecated v1 entrypoint, which delegates every
+   * request to this runtime. Handing its own scope down is what collapses
+   * the duplicate: the v1 entrypoint no longer emits the same events itself,
+   * and the events this runtime sends still reach Segment and still report
+   * the v1 surface. There is no reason for an application to pass this.
+   */
+  ɵtelemetry?: TelemetryCapture;
+  /** Enable debug logging for the event pipeline. */
+  debug?: DebugConfig;
+  /**
+   * Policy controlling which inbound HTTP headers are forwarded onto the
+   * outgoing agent call. By default a built-in denylist strips known
+   * infrastructure/proxy/platform headers (`x-forwarded-*`, `x-real-ip`,
+   * `x-vercel-*`, `x-copilotcloud-*`, etc.) while `authorization` and custom
+   * `x-*` application headers continue to forward (#5712). Set
+   * `{ useDefaultDenylist: false }` to restore the previous wide-open behavior.
+   */
+  forwardHeaders?: ForwardHeadersConfig;
+  /**
+   * Seconds of silence on an SSE response before the runtime writes a
+   * `: keep-alive` comment, so proxies and browsers with idle timeouts keep
+   * the connection open through long reasoning or tool phases. Comments are
+   * transport frames and never become AG-UI events. `0` disables it.
+   * @default 15
+   */
+  sseKeepAliveIntervalSeconds?: number;
+  /**
+   * Opt-in flag exposing the client-facing memory proxy routes
+   * (`/memories`, `/memories/recall`, `/memories/subscribe`, `/memories/:id`).
+   *
+   * Defaults to `false` — a **secure default**. When off, every `/memories/*`
+   * request 404s as if the route did not exist, so an un-opted-in deployment
+   * reveals nothing about memory even when Intelligence is configured. This does
+   * NOT affect the agent's own server-side memory tooling (`recall_memory` runs
+   * via the Intelligence MCP path, separate from this client REST proxy).
+   *
+   * Flip to `true` to power a client memory inspector (e.g. the dev console's
+   * Memory tab). Existing Intelligence deployments relying on the previously
+   * always-on Learning tab must set this to restore it.
+   *
+   * @deprecated Configure `memory.access` on an Intelligence Runtime. That one
+   * policy enables and limits both agent and browser Memory.
+   */
+  exposeMemoryRoutes?: boolean;
+  /**
+   * How local Threads are shared among callers that `identifyUser` does not
+   * identify, when no Intelligence is configured. Has no effect on an
+   * Intelligence runtime, where the platform scopes Threads per user.
+   *
+   * With `identifyUser`, every Thread operation (list, read, connect, run,
+   * stop, clear) reaches only the caller's own Threads, whatever this says.
+   * Without it, by default (`access: "owner"`), a Thread id works as a
+   * capability: whoever holds it may read, connect to, continue and stop that
+   * Thread, but listing and clearing Threads are refused with HTTP 403.
+   * `access: "open"` also lets every caller list and clear the Threads created
+   * without identity, as in earlier releases. That is insecure for any
+   * deployment that more than one person can reach. A Thread created by an
+   * identified user is never reachable without that identity.
+   */
+  threads?: ThreadsConfig;
+}
+type IdentifyUserCallback = (request: Request) => MaybePromise<CopilotRuntimeUser>;
+type MemoryAccess = "none" | "read" | "read-write";
+interface MemoryGrant {
+  readonly user: MemoryAccess;
+  readonly project: MemoryAccess;
+}
+type MemoryConsumer = "agent" | "client";
+interface CopilotRuntimeMemoryConfig {
+  /** Resolves immutable Memory access for one authenticated web request. */
+  access(input: {
+    readonly request: Request;
+    readonly user: CopilotRuntimeUser;
+    readonly consumer: MemoryConsumer;
+  }): MaybePromise<MemoryGrant | null>;
+}
+interface CopilotSseRuntimeOptions extends BaseCopilotRuntimeOptions {
+  /** The runner to use for running agents in SSE mode. */
+  runner?: AgentRunner;
+  /**
+   * Resolves the authenticated user for a request. When set, each Thread
+   * belongs to the user whose request created it, and only that user can list,
+   * read, replay, clear, continue or stop it. The runner must enforce owners
+   * (InMemoryAgentRunner and SqliteAgentRunner do); with a runner that does
+   * not, those requests are refused. See `threads`.
+   *
+   * Threads that SqliteAgentRunner stored before it recorded owners belong to
+   * nobody: as before the upgrade, whoever holds such a Thread's id can reach
+   * it, and continuing it does not claim it. The runner logs how many it holds
+   * when it opens the database. Every new Thread is owned. InMemoryAgentRunner
+   * keeps no Threads across a restart, so it holds no such Threads.
+   */
+  identifyUser?: IdentifyUserCallback;
+  intelligence?: undefined;
+  generateThreadNames?: undefined;
+  /** Intelligence Channels require the Intelligence runtime; not available in SSE mode. */
+  channels?: undefined;
+}
+interface CopilotIntelligenceRuntimeBaseOptions extends BaseCopilotRuntimeOptions {
+  /** Configures Intelligence mode for durable threads and realtime events. */
+  intelligence: CopilotKitIntelligence;
+  /**
+   * Chooses one stable Learning Container ID for each web or Channel run.
+   * @deprecated Configure `getLearningContainerId` on `CopilotKitIntelligence`.
+   */
+  ɵlearning?: CopilotRuntimeLearningConfig;
+  /** Auto-generate short names for newly created threads. */
+  generateThreadNames?: boolean;
+  /** Max delay (ms) for WebSocket reconnect backoff. @default 10_000 */
+  maxReconnectMs?: number;
+  /** Max delay (ms) for channel rejoin backoff. @default 30_000 */
+  maxRejoinMs?: number;
+  /**
+   * Interval (ms) between Phoenix heartbeats on the runner WebSocket. Keep it
+   * below the idle timeout of any proxy between the runtime and Intelligence.
+   * @default 15_000
+   */
+  heartbeatIntervalMs?: number;
+  /** Lock TTL in seconds. Clamped to a maximum of 3600 (1 hour). @default 20 */
+  lockTtlSeconds?: number;
+  /** Custom Redis key prefix for the thread lock. */
+  lockKeyPrefix?: string;
+  /** Interval in seconds at which the runtime renews the thread lock. Clamped to a maximum of 3000 (50 minutes). @default 15 */
+  lockHeartbeatIntervalSeconds?: number;
+}
+type NonEmptyChannels = readonly [Channel, ...Channel[]];
+/** Intelligence runtime options with web identity, Channels, or both. */
+type CopilotIntelligenceRuntimeOptions = CopilotIntelligenceRuntimeBaseOptions & ({
+  /** Resolves the authenticated user for web requests. */identifyUser: IdentifyUserCallback; /** Enables agent and browser Memory under one request policy. */
+  memory?: CopilotRuntimeMemoryConfig;
+  channels?: readonly Channel[];
+} | {
+  /** Channels-only runtimes expose no functional web surface. */identifyUser?: undefined;
+  memory?: undefined;
+  channels: NonEmptyChannels;
+});
+type CopilotRuntimeOptions = CopilotSseRuntimeOptions | CopilotIntelligenceRuntimeOptions;
+interface CopilotRuntimeLike {
+  agents: CopilotRuntimeOptions["agents"];
+  transcriptionService: CopilotRuntimeOptions["transcriptionService"];
+  beforeRequestMiddleware: CopilotRuntimeOptions["beforeRequestMiddleware"];
+  afterRequestMiddleware: CopilotRuntimeOptions["afterRequestMiddleware"];
+  runner: AgentRunner;
+  a2ui: CopilotRuntimeOptions["a2ui"];
+  mcpApps: CopilotRuntimeOptions["mcpApps"];
+  openGenerativeUI: CopilotRuntimeOptions["openGenerativeUI"];
+  generativeUI?: CopilotRuntimeOptions["generativeUI"];
+  intelligence?: CopilotKitIntelligence;
+  identifyUser?: IdentifyUserCallback;
+  mode: RuntimeMode;
+  licenseChecker?: LicenseChecker;
+  debugEventBus?: DebugEventBus;
+  debug: ResolvedDebugConfig;
+  debugLogger?: CopilotRuntimeLogger;
+  /**
+   * Runtime-bound telemetry capture. Optional so external implementations of
+   * this published interface remain source-compatible.
+   */
+  telemetry?: TelemetryCapture;
+  /**
+   * Resolved inbound-header forwarding policy read by the /run and /connect call
+   * sites. Optional on the published interface so an external `CopilotRuntimeLike`
+   * implementor predating this field stays source-compatible (non-breaking minor
+   * release). Concrete runtimes (`BaseCopilotRuntime`) always resolve and set it;
+   * the call sites coalesce a missing value to the default resolved policy
+   * (`resolveForwardHeadersPolicy(undefined)` — default-on denylist).
+   */
+  forwardHeadersPolicy?: ResolvedForwardHeadersPolicy;
+  /**
+   * Resolved SSE keep-alive interval in seconds; `0` disables it. Optional on
+   * the published interface for the same source-compatibility reason as
+   * `forwardHeadersPolicy`; the SSE call sites fall back to the default.
+   */
+  sseKeepAliveIntervalSeconds?: number;
+  /**
+   * Resolved opt-in flag for the client-facing memory proxy routes. Optional on
+   * the published interface so an external `CopilotRuntimeLike` implementor
+   * predating this field stays source-compatible; the dispatcher coalesces a
+   * missing value to `false` (secure default — routes hidden). Concrete runtimes
+   * (`BaseCopilotRuntime`) always resolve and set it.
+   */
+  exposeMemoryRoutes?: boolean;
+  /**
+   * Resolved local Thread access mode. Optional on the published interface so
+   * an external implementor stays source-compatible; a missing value means
+   * the default (`DEFAULT_THREAD_ACCESS`).
+   */
+  threadAccess?: ThreadAccessMode;
+  memory?: CopilotRuntimeMemoryConfig;
+  learning?: CopilotRuntimeLearningConfig;
+}
+interface CopilotSseRuntimeLike extends CopilotRuntimeLike {
+  intelligence?: undefined;
+  mode: typeof RUNTIME_MODE_SSE;
+}
+interface CopilotIntelligenceRuntimeLike extends CopilotRuntimeLike {
+  intelligence: CopilotKitIntelligence;
+  identifyUser?: IdentifyUserCallback;
+  generateThreadNames: boolean;
+  lockTtlSeconds: number;
+  lockKeyPrefix?: string;
+  lockHeartbeatIntervalSeconds: number;
+  channels: Channel[];
+  learning?: CopilotRuntimeLearningConfig;
+  mode: typeof RUNTIME_MODE_INTELLIGENCE;
+}
+declare abstract class BaseCopilotRuntime implements CopilotRuntimeLike {
+  agents: CopilotRuntimeOptions["agents"];
+  transcriptionService: CopilotRuntimeOptions["transcriptionService"];
+  beforeRequestMiddleware: CopilotRuntimeOptions["beforeRequestMiddleware"];
+  afterRequestMiddleware: CopilotRuntimeOptions["afterRequestMiddleware"];
+  runner: AgentRunner;
+  a2ui: CopilotRuntimeOptions["a2ui"];
+  mcpApps: CopilotRuntimeOptions["mcpApps"];
+  openGenerativeUI: CopilotRuntimeOptions["openGenerativeUI"];
+  generativeUI: CopilotRuntimeOptions["generativeUI"];
+  licenseChecker?: LicenseChecker;
+  readonly debugEventBus?: DebugEventBus;
+  debug: ResolvedDebugConfig;
+  debugLogger?: CopilotRuntimeLogger;
+  readonly telemetry: TelemetryCapture;
+  readonly forwardHeadersPolicy: ResolvedForwardHeadersPolicy;
+  readonly sseKeepAliveIntervalSeconds: number;
+  readonly exposeMemoryRoutes: boolean;
+  readonly threadAccess: ThreadAccessMode;
+  readonly memory?: CopilotRuntimeMemoryConfig;
+  /**
+   * License token resolved once with the env fallback, so telemetry
+   * attribution (below) and subclass feature gating
+   * (CopilotIntelligenceRuntime's licenseChecker) read the exact same value
+   * instead of each re-applying `?? COPILOTKIT_LICENSE_TOKEN`.
+   */
+  protected readonly resolvedLicenseToken?: string;
+  abstract readonly intelligence?: CopilotKitIntelligence;
+  abstract readonly mode: RuntimeMode;
+  constructor(options: BaseCopilotRuntimeOptions, runner: AgentRunner);
+}
+declare class CopilotSseRuntime extends BaseCopilotRuntime implements CopilotSseRuntimeLike {
+  readonly intelligence: any;
+  readonly mode: "sse";
+  readonly identifyUser?: IdentifyUserCallback;
+  constructor(options: CopilotSseRuntimeOptions);
+}
+declare class CopilotIntelligenceRuntime extends BaseCopilotRuntime implements CopilotIntelligenceRuntimeLike {
+  readonly intelligence: CopilotKitIntelligence;
+  readonly identifyUser?: IdentifyUserCallback;
+  readonly generateThreadNames: boolean;
+  readonly lockTtlSeconds: number;
+  readonly lockKeyPrefix?: string;
+  readonly lockHeartbeatIntervalSeconds: number;
+  readonly channels: Channel[];
+  readonly learning?: CopilotRuntimeLearningConfig;
+  readonly mode: "intelligence";
+  /** Maximum allowed lock TTL in seconds (1 hour). */
+  static readonly MAX_LOCK_TTL_SECONDS = 3600;
+  /** Maximum allowed heartbeat interval in seconds (50 minutes). */
+  static readonly MAX_HEARTBEAT_INTERVAL_SECONDS = 3000;
+  constructor(options: CopilotIntelligenceRuntimeOptions);
+}
+declare function isIntelligenceRuntime(runtime: CopilotRuntimeLike): runtime is CopilotIntelligenceRuntimeLike;
+/**
+ * Single source of truth for "is A2UI on for this runtime?". Both the run path
+ * (which applies `A2UIMiddleware`) and the `/info` response (which tells the
+ * client whether to mount the A2UI renderer + catalog context) MUST go through
+ * this, so they can never disagree — the divergence between them was the root
+ * of CopilotKit/CopilotKit#5369.
+ *
+ * Backwards compatible: any config object is enabled (matching the historical
+ * `!!runtime.a2ui`); only an explicit `enabled: false` turns it off.
+ */
+declare function isA2UIEnabled(a2ui: CopilotRuntimeOptions["a2ui"]): a2ui is NonNullable<CopilotRuntimeOptions["a2ui"]>;
+/**
+ * Compile-time phantom brand marking a {@link CopilotRuntime} that was
+ * constructed with at least one declared Intelligence Channel. It has no runtime
+ * representation — the shim never sets this property; it exists purely so
+ * `createCopilotRuntimeHandler` can tell, at the type level, that the resulting
+ * handler will carry a non-optional `.channels` control surface.
+ */
+interface RuntimeWithDeclaredChannels {
+  /**
+   * @internal Phantom brand key. Never present at runtime; do not read or set.
+   */
+  readonly __copilotkitChannelsDeclared: true;
+}
+/**
+ * Instance shape of the {@link CopilotRuntime} compatibility shim. Extends
+ * {@link CopilotRuntimeLike} with the Intelligence-only accessors the shim
+ * surfaces (all `undefined` in SSE mode). Declared explicitly so the exported
+ * `CopilotRuntime` name resolves as a type as well as a value.
+ */
+interface CopilotRuntime extends CopilotRuntimeLike {
+  /** Telemetry capture bound to this runtime's construction-time identity. */
+  telemetry: TelemetryCapture;
+  /** Auto-generate short thread names; `undefined` in SSE mode. */
+  generateThreadNames?: boolean;
+  /** Thread lock TTL in seconds; `undefined` in SSE mode. */
+  lockTtlSeconds?: number;
+  /** Custom Redis key prefix for the thread lock; `undefined` in SSE mode. */
+  lockKeyPrefix?: string;
+  /** Thread lock heartbeat interval in seconds; `undefined` in SSE mode. */
+  lockHeartbeatIntervalSeconds?: number;
+  /** Declared Intelligence Channels; `undefined` in SSE mode. */
+  channels?: Channel[];
+  /** Learning Container selector; `undefined` in SSE mode. */
+  learning?: CopilotRuntimeLearningConfig;
+}
+/**
+ * Constructor type for the {@link CopilotRuntime} compatibility shim.
+ *
+ * The first overload fires when the caller passes `intelligence` together with a
+ * non-empty `channels` tuple: it returns a {@link RuntimeWithDeclaredChannels}-
+ * branded runtime, which `createCopilotRuntimeHandler` maps to a handler whose
+ * `.channels` is non-optional. Every other configuration (SSE, or Intelligence
+ * without channels, or an empty `channels: []`) falls through to the second
+ * overload and stays unbranded, so its handler keeps `.channels` optional.
+ *
+ * A class constructor cannot vary its return type across overloads (it is pinned
+ * to the instance type), so the branding lives on this construct-signature
+ * interface instead of on the class itself.
+ */
+interface CopilotRuntimeConstructor {
+  new (options: CopilotIntelligenceRuntimeBaseOptions & ({
+    identifyUser: IdentifyUserCallback;
+    memory?: CopilotRuntimeMemoryConfig;
+    channels: NonEmptyChannels;
+  } | {
+    identifyUser?: undefined;
+    memory?: undefined;
+    channels: NonEmptyChannels;
+  })): CopilotRuntime & RuntimeWithDeclaredChannels;
+  new (options: CopilotRuntimeOptions): CopilotRuntime;
+}
+/**
+ * The public `CopilotRuntime` constructor. Backed by {@link CopilotRuntimeShim}
+ * but typed as {@link CopilotRuntimeConstructor} so that constructing with a
+ * non-empty `channels` array yields a {@link RuntimeWithDeclaredChannels}-branded
+ * runtime type.
+ *
+ * The `as unknown as` cast is required (not dishonest widening): the brand is a
+ * phantom, compile-time-only marker with no runtime representation, so the shim
+ * instances legitimately do not carry the brand property. Behavior is identical
+ * to the former `class CopilotRuntime` — this only refines the static type.
+ */
+declare const CopilotRuntime: CopilotRuntimeConstructor;
+//#endregion
+export { AgentFactoryContext, AgentsConfig, AgentsFactory, CopilotIntelligenceRuntime, CopilotIntelligenceRuntimeLike, CopilotIntelligenceRuntimeOptions, CopilotRuntime, CopilotRuntimeConstructor, CopilotRuntimeLike, CopilotRuntimeMemoryConfig, CopilotRuntimeOptions, CopilotSseRuntime, CopilotSseRuntimeLike, CopilotSseRuntimeOptions, IdentifyUserCallback, McpAppsConfig, McpAppsServerConfig, MemoryAccess, MemoryConsumer, MemoryGrant, OpenGenerativeUIConfig, OpenGenerativeUIOptions, RuntimeWithDeclaredChannels, VERSION, isA2UIEnabled, isIntelligenceRuntime, resolveAgents };
+//# sourceMappingURL=runtime.d.cts.map

package/dist/runtime/core/runtime.d.cts.map

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