@economic/agents 2.7.2 → 3.0.0-alpha.32271766282.1.0

package/dist/index.d.mts

@@ -1,84 +1,91 @@
-import { n as JwtAuthConfig, t as routeAgentRequest } from "./route-agent-request-D2ll--nF.mjs";
-import { Agent as Agent$1, Connection, ConnectionContext, SubAgentClass } from "agents";
-import { ChatResponseResult, PrepareStepContext, Session, Think, ToolCallContext, ToolCallDecision, TurnConfig, TurnContext, skills } from "@cloudflare/think";
+import { ChatResponseResult, PrepareStepContext, Session, StepContext, Think, ToolCallContext, ToolCallDecision, ToolCallResultContext, TurnConfig, TurnContext, skills } from "@cloudflare/think";
 import { JSONValue, LanguageModel, ModelMessage, Tool as Tool$1, UIMessage } from "ai";
+import { Agent, AgentOptions, Connection, ConnectionContext, SubAgentClass } from "agents";
 import { createCompactFunction } from "agents/experimental/memory/utils";
 import { SkillSource as SkillSource$1 } from "agents/skills";
 
 //#region src/server/types.d.ts
 /**
- * The context object available throughout an agent's lifetime — passed via
- * `experimental_context` to tool `execute` functions. Contains the typed
- * request body merged with platform capabilities like `logEvent`.ext = AgentToolContext<MyBody>;
- * ```
+ * Context passed to tool `execute` functions through `experimental_context`.
+ * It contains the request context plus authenticated values supplied by the agent.
  */
 type ToolContext<RequestContext extends Record<string, unknown> = Record<string, unknown>, UserContext = Record<string, unknown> | undefined> = RequestContext & {
+  _token?: string;
   _userContext?: UserContext;
 };
 interface AgentEnv {
   AGENTS_DB: D1Database;
   AGENTS_AUDIT_LOGS: R2Bucket;
-  AGENTS_ANALYTICS: AnalyticsEngineDataset;
-  SKILLS_BUCKET: R2Bucket;
-  LOCAL_AGENT_DB?: D1Database;
+  AGENTS_ANALYTICS?: AnalyticsEngineDataset;
 }
 type AgentConnectionStatus = "connecting" | "connected" | "disconnected" | "unauthorized" | "error";
-type AgentConnectionType = "agent" | "chat" | "assistant";
+type AgentConnectionType = "chat" | "assistant";
 //#endregion
-//#region src/server/features/auth/tokenExchange.d.ts
-interface TokenExchangeConfig {
-  /** Identity server token endpoint, e.g. `${identityOrigin}/connect/token`. */
-  tokenUrl: string;
-  /** OAuth client the agent authenticates as. */
-  clientId: string;
-  /**
-   * Plain secret, or a binding resolved with `get()` (e.g. a Cloudflare
-   * Secrets Store binding). Resolved on every exchange so rotation is
-   * picked up without a redeploy.
-   */
-  clientSecret: string | {
-    get(): Promise<string>;
-  };
-  /**
-   * Space-separated scopes for the exchanged token. Always sent explicitly:
-   * omitting `scope` would make the identity server issue every scope the
-   * client is allowed, the opposite of least privilege.
-   */
-  scopes: string;
-  /**
-   * Key under the request-context `tokens` record that tools read the token
-   * from. Defaults to {@link DEFAULT_TOKEN_HEADER}.
-   */
-  tokenHeader?: string;
+//#region src/server/features/messages.d.ts
+type MessageFeedbackRating = 1 | -1 | 0;
+type MessageFeedback = {
+  message_id: string;
+  rating: Exclude<MessageFeedbackRating, 0>;
+  comment?: string;
+  created_at: number;
+  updated_at: number;
+};
+//#endregion
+//#region src/server/features/auth/index.d.ts
+interface JwtVerificationOptions {
+  /** Issuers whose tokens are accepted (exact string or RegExp). */
+  allowedIssuers: readonly (string | RegExp)[];
+  /** Expected `aud` claim. */
+  audience: string;
+  /** Required OAuth scopes; token `scope` must include all (empty = no scope check). */
+  requiredScopes?: readonly string[];
 }
-interface ExchangedToken {
-  accessToken: string;
-  /** Unix ms; already includes {@link EXPIRY_MARGIN_MS}. */
-  expiresAt: number;
+type ClaimsMapper<TClaims extends Record<string, unknown>> = Record<string, unknown> extends TClaims ? {
+  /** Extract selected claims, or omit this to receive the complete verified payload. */getClaims?: (payload: Record<string, unknown>) => TClaims;
+} : {
+  /** Extract and validate the custom claims exposed by this configuration. */getClaims: (payload: Record<string, unknown>) => TClaims;
+};
+type JwtVerificationConfig<TClaims extends Record<string, unknown> = Record<string, unknown>> = JwtVerificationOptions & ClaimsMapper<TClaims>;
+//#endregion
+//#region src/server/features/auth/authenticate.d.ts
+interface Authenticated<TUserContext extends Record<string, unknown> = Record<string, unknown>> {
+  authenticated: true;
+  /** Optional downstream credential exposed to tools as `ctx._token`. */
+  token?: string;
+  userContext?: TUserContext;
 }
-type TokenExchangeResult = ({
-  success: true;
-} & ExchangedToken) | {
-  success: false;
-  status: number;
-  errorCode: string;
+interface AuthenticationDenied {
+  authenticated: false;
+  status: 401 | 403;
   message: string;
+}
+type AuthenticationResult<TUserContext extends Record<string, unknown> = Record<string, unknown>> = Authenticated<TUserContext> | AuthenticationDenied;
+/** A generic authentication mechanism used by ChatAgent, Assistant, and TaskAgent. */
+interface Authenticator<TUserContext extends Record<string, unknown> = Record<string, unknown>> {
+  authenticate(request: Request): Promise<AuthenticationResult<TUserContext>>;
+}
+interface JwtAuthenticationContext<TClaims extends Record<string, unknown>> {
+  /** The verified token, or the value returned by `getExchangedToken`. */
+  token: string;
+  claims: TClaims;
+}
+type GetExchangedToken<TClaims extends Record<string, unknown>> = (context: JwtAuthenticationContext<TClaims>) => Promise<string> | string;
+interface JwtAuthenticatorConfig<TClaims extends Record<string, unknown> = Record<string, unknown>, TUserContext extends Record<string, unknown> = Record<string, unknown>> {
+  /** Configuration consumed by the SDK's built-in JWT verification. */
+  verificationConfig: JwtVerificationConfig<TClaims>;
   /**
-   * True when the identity server rejected the subject token itself
-   * (RFC 6749 `invalid_grant`: expired or revoked). Re-authenticating is
-   * the only fix — other failures (`invalid_client`, `invalid_scope`,
-   * 5xx) are deployment or identity-server faults the user cannot fix by
-   * logging in again.
+   * Optional consumer-defined exchange. It runs once after verification and
+   * receives the verified token and claims.
    */
-  subjectTokenRejected: boolean;
-};
+  getExchangedToken?: GetExchangedToken<TClaims>;
+  getUserContext?: (context: JwtAuthenticationContext<TClaims>) => Promise<TUserContext> | TUserContext;
+}
 /**
- * Exchange `subjectToken` for a token issued to the agent's own OAuth client.
- *
- * Expected identity-server rejections return a failure result; unexpected
- * failures (network error, timeout, malformed success response) throw.
+ * Creates an authenticator that extracts a bearer JWT, verifies it once,
+ * optionally lets the consumer exchange it once, then uses the final token
+ * for user-context resolution and tool calls.
  */
-declare function exchangeToken(subjectToken: string, config: TokenExchangeConfig): Promise<TokenExchangeResult>;
+declare function createJwtAuthenticator<TClaims extends Record<string, unknown>, TUserContext extends Record<string, unknown> = Record<string, unknown>>(config: JwtAuthenticatorConfig<TClaims, TUserContext>): Authenticator<TUserContext>;
 //#endregion
 //#region src/server/util/tools.d.ts
 type ToolSet = Record<string, Tool>;
@@ -87,8 +94,81 @@ type Tool<Context extends Record<string, unknown> = Record<string, unknown>, INP
 };
 declare function tool<Context extends Record<string, unknown> = Record<string, unknown>, INPUT extends JSONValue | unknown | never = any, OUTPUT extends JSONValue | unknown | never = any>(tool: Tool<Context, INPUT, OUTPUT>): Tool$1<INPUT, OUTPUT>;
 //#endregion
-//#region src/server/agents/Agent.d.ts
-/** What the model would see on its next step — returned by {@link Agent.inspectTurn}. */
+//#region src/server/features/analytics/types.d.ts
+type AnalyticsAttribute = string | number | boolean;
+type AnalyticsAttributes = Readonly<Record<string, AnalyticsAttribute>>;
+interface AnalyticsUsage {
+  inputTokens: number;
+  outputTokens: number;
+  totalTokens: number;
+  cachedInputTokens?: number;
+  cacheWriteTokens?: number;
+  reasoningTokens?: number;
+}
+type AnalyticsEventPayload = {
+  type: "prompt.received";
+  /**
+   * The raw model messages received for the prompt. They may contain user
+   * or customer data and must be treated as sensitive by every handler.
+   * The built-in Analytics Engine handler records only their size.
+   */
+  messages: readonly ModelMessage[];
+  continuation: boolean;
+} | {
+  type: "turn.completed";
+  requestId: string;
+  status: "completed" | "error" | "aborted";
+  continuation: boolean;
+  responseSize: number;
+} | {
+  type: "llm.completed";
+  model: string;
+  provider: string;
+  finishReason: string;
+  usage: AnalyticsUsage;
+  durationMs: number;
+  inputSize: number;
+  responseSize: number;
+  stepNumber: number;
+} | {
+  type: "tool.completed";
+  toolCallId: string;
+  toolName: string;
+  skillNames: readonly string[];
+  success: boolean;
+  durationMs: number;
+  inputSize: number;
+  outputSize: number;
+  stepNumber?: number;
+} | {
+  type: "feedback.submitted";
+  messageId: string; /** `0` means the user cleared their existing feedback. */
+  rating: 1 | -1 | 0;
+};
+type AnalyticsEvent = AnalyticsEventPayload & {
+  schemaVersion: 1;
+  eventId: string;
+  timestamp: number;
+  agentName: string;
+  durableObjectName: string;
+  actorId: string;
+  attributes: AnalyticsAttributes;
+};
+/** Receives typed product-analytics events emitted by the SDK. */
+interface AnalyticsHandler {
+  readonly name?: string;
+  handle(event: AnalyticsEvent): void | Promise<void>;
+}
+//#endregion
+//#region src/server/features/analytics/analytics-engine.d.ts
+/**
+ * Creates an explicit Cloudflare Analytics Engine destination for SDK events.
+ * Prompt content is deliberately never written; only its serialized size is.
+ */
+declare function createAnalyticsEngineHandler(dataset: AnalyticsEngineDataset): AnalyticsHandler;
+//#endregion
+//#region src/server/agents/ChatAgent.d.ts
+/** What the model would see on its next step — returned by {@link ChatAgent.inspectTurn}. */
 interface TurnSnapshot {
   system: string;
   tools: ToolSet;
@@ -97,15 +177,16 @@ interface TurnSnapshot {
   frameworkToolNames: string[];
   messages: ModelMessage[];
 }
-declare abstract class Agent<RequestContext extends Record<string, unknown> = Record<string, unknown>, UserContext extends Record<string, unknown> = Record<string, unknown>, State = unknown> extends Think<Cloudflare.Env & AgentEnv, State> {
-  protected agentType: AgentConnectionType;
-  protected clientIp?: string;
-  protected forwardedFor?: string;
+declare abstract class ChatAgent<RequestContext extends Record<string, unknown> = Record<string, unknown>, UserContext extends Record<string, unknown> = Record<string, unknown>, State = unknown> extends Think<Cloudflare.Env & AgentEnv, State> {
+  private readonly inspectionContext;
+  /** Stable logical identity used in analytics, audit logs, and operational logs. */
+  abstract get agentName(): string;
+  observability: import("agents/observability").Observability;
   /**
    * Returns the user ID from the durable object name.
    */
   protected getActorIdFromDurableObjectName(): string;
-  protected getParentAgent<T extends Agent$1>(): T | undefined;
+  protected getParentAgent<T extends Agent>(): T | undefined;
   abstract getModel(ctx?: ToolContext<RequestContext, UserContext>): LanguageModel;
   abstract getSystemPrompt(ctx?: ToolContext<RequestContext, UserContext>): string;
   onStart(): Promise<void>;
@@ -114,6 +195,8 @@ declare abstract class Agent<RequestContext extends Record<string, unknown> = Re
   private _toolsForCurrentTurn;
   private _authorizedToolsForCurrentTurn;
   private _toolContextForCurrentTurn?;
+  private _analyticsHandlers?;
+  private getTurnConnectionState;
   private getToolContextForCurrentTurn;
   /**
    * Merges the client request `body` into `experimental_context` for tools
@@ -137,6 +220,9 @@ declare abstract class Agent<RequestContext extends Record<string, unknown> = Re
     experimental_context: {};
   }>;
   beforeToolCall(ctx: ToolCallContext): Promise<ToolCallDecision | void>;
+  onStepFinish(ctx: StepContext): void;
+  afterToolCall(ctx: ToolCallResultContext): void;
+  onChatResponse(result: ChatResponseResult): Promise<void>;
   getTools(): ToolSet;
   /**
    * Read-only: what the model would see on its next step for the given history
@@ -153,11 +239,6 @@ declare abstract class Agent<RequestContext extends Record<string, unknown> = Re
   }): Promise<TurnSnapshot>;
   workspaceBash: boolean;
   getSkillScriptRunner(): skills.SkillScriptRunner | null;
-  /**
-   * Returns the remote skills to be loaded from SKILLS_BUCKET.
-   * @returns The remote skills to be loaded from SKILLS_BUCKET.
-   */
-  protected getRemoteSkills(): string[];
   private _pruneTurnMessages;
   private _getAuthorizedTools;
   /**
@@ -185,60 +266,15 @@ declare abstract class Agent<RequestContext extends Record<string, unknown> = Re
    * `async function*` `execute`'s streaming shape.
    */
   private _withTurnContextFallback;
-  private _getLastActivatedSkillName;
   /**
-   * Override to enable JWT authentication on WebSocket connections.
-   * Return the auth config based on the incoming request, or undefined to skip auth.
-   * Do not add side effects to this method - return a single JwtAuthConfig from it.
-   *
-   * @param env - The worker environment variables
-   * @returns JWT auth config or undefined to skip authentication
+   * Generic authentication for this agent. If implemented, the authenticator
+   * runs once when a client connects. Omitting the method leaves the agent open.
    */
-  static getJwtAuthConfig?(env: Cloudflare.Env): JwtAuthConfig<Record<string, unknown>> | undefined;
+  protected getAuthenticator?(env: Cloudflare.Env): Authenticator<UserContext>;
   /**
-   * Override to exchange the verified connect token (RFC 8693) for a token
-   * issued to this agent's own OAuth client. Requires {@link getJwtAuthConfig}.
-   *
-   * When configured, the exchanged token is passed to {@link getUserContext}
-   * and injected into the tool context every turn under
-   * `tokens[config.tokenHeader]` — client-sent request-body tokens for that
-   * key are ignored. Renewal is connection-based: a client presenting a new
-   * token reconnects, and the connect flow re-verifies and re-exchanges.
-   *
-   * Do not add side effects to this method - return a single config from it,
-   * or undefined to disable the exchange.
-   *
-   * @param env - The worker environment variables
-   * @returns Token exchange config or undefined to disable
-   */
-  static getTokenExchangeConfig?(env: Cloudflare.Env): TokenExchangeConfig | undefined;
-  /**
-   * The exchanged token for this agent, refreshed on every authenticated
-   * connect. Kept in memory for the hot path and mirrored to DO storage so
-   * turns that run after hibernation (or without a connection at all) still
-   * have it. Short-lived by construction — at most the identity server's
-   * token lifetime.
-   */
-  private _exchangedToken?;
-  private _storeExchangedToken;
-  private _getExchangedToken;
-  /**
-   * Swaps the client-sent token for the exchanged one in a copy of the turn
-   * body. No-op when token exchange is not configured.
-   */
-  private _applyTokenExchange;
-  /**
-   * The user context for the session.
-   * Define getUserContext to set a user context.
+   * User context returned by the configured authenticator for this connection.
    */
   protected userContext?: UserContext;
-  /**
-   * Returns the identity following verification of the JWT token - getJwtAuthConfig is required.
-   * This method should not have side effects - return a single object from it.
-   * @returns The user context from the request.
-   * @param jwtToken - A valid JWT token following authentication.
-   */
-  protected getUserContext?(jwtToken: string): Promise<UserContext>;
   /**
    * Self-registers this DO in the global `agent_registry`. Only top-level DOs
    * are registered — facets are enumerable via their parent's own index, so
@@ -265,46 +301,19 @@ declare abstract class Agent<RequestContext extends Record<string, unknown> = Re
    */
   protected registerInstanceActivity(): Promise<void>;
   /**
-   * Resolves the analytics/telemetry agent name to the entry-point agent: the
-   * top-level DO registered in the `agent` catalog table.
-   *
-   * `parentPath` is root-first and empty for top-level DOs, so:
-   * - chat agent running under an Assistant → the Assistant's class name
-   *   (e.g. `EvaAssistant`), since the Assistant is the catalog entry point;
-   * - standalone chat agent → its own class name (e.g. `EvaAgent`).
-   */
-  protected getTelemetryAgentName(): string;
-  protected getTelemetryActorId(): string;
-}
-//#endregion
-//#region src/server/features/messages.d.ts
-type MessageFeedback = {
-  message_id: string;
-  rating: number;
-  comment?: string;
-  created_at: number;
-  updated_at: number;
-};
-//#endregion
-//#region src/server/agents/ChatAgent.d.ts
-declare abstract class ChatAgent<RequestContext extends Record<string, unknown> = Record<string, unknown>, UserContext extends Record<string, unknown> = Record<string, unknown>, State = unknown> extends Agent<RequestContext, UserContext, State> {
-  protected agentType: AgentConnectionType;
-  onStart(): Promise<void>;
-  configureSession(session: Session): Session;
-  beforeTurn(ctx: TurnContext): Promise<void | TurnConfig>;
-  onChatResponse(_result: ChatResponseResult): Promise<void>;
-  /**
-   * Submit feedback for a message by its id.
-   * @param messageId - The id of the message to give feedback on.
-   * @param rating - The rating to give the message. 1 = thumbs up, -1 = thumbs down.
-   * @returns The message id and the rating.
-   */
-  submitMessageFeedback(messageId: string, rating: number, comment?: string): Promise<void>;
-  /**
-   * Returns all message feedback for the current chat.
-   * @returns All message feedback for the current chat.
+   * Product-analytics destinations for this agent. Nothing is emitted unless
+   * a consumer explicitly returns one or more handlers here.
    */
+  protected getAnalyticsHandlers(): readonly AnalyticsHandler[];
+  /** Business dimensions added to every analytics event (for example tenant or user type). */
+  protected getAnalyticsAttributes(): AnalyticsAttributes;
+  /** Emits a typed SDK product event to configured handlers. */
+  protected emitAnalyticsEvent(payload: AnalyticsEventPayload | (() => AnalyticsEventPayload)): void;
+  /** Submit or replace feedback for a persisted assistant message. */
+  submitMessageFeedback(messageId: string, rating: MessageFeedbackRating, comment?: string): Promise<void>;
+  /** Returns all feedback stored for this chat, keyed by message id. */
   getMessageFeedback(): Promise<Record<string, MessageFeedback>>;
+  protected getTelemetryActorId(): string;
 }
 //#endregion
 //#region src/server/features/chats.d.ts
@@ -321,10 +330,14 @@ type Chat = {
 declare const DELETE_CHAT_CALLBACK: "deleteChatCallback";
 //#endregion
 //#region src/server/agents/Assistant.d.ts
-declare abstract class Assistant<State = unknown> extends Agent$1<Cloudflare.Env & AgentEnv, State> {
-  private _fix;
+declare abstract class Assistant<State = unknown> extends Agent<Cloudflare.Env & AgentEnv, State> {
+  /** Stable logical identity used in operational logs. */
+  abstract get agentName(): string;
+  observability: import("agents/observability").Observability;
   protected abstract fastModel: LanguageModel;
   protected abstract agent: SubAgentClass<ChatAgent>;
+  /** Generic authentication for the assistant connection itself. */
+  protected getAuthenticator?(env: Cloudflare.Env): Authenticator<Record<string, unknown>>;
   onStart(): void;
   onConnect(connection: Connection, ctx: ConnectionContext): Promise<void>;
   createChat(): Promise<string>;
@@ -334,7 +347,7 @@ declare abstract class Assistant<State = unknown> extends Agent$1<Cloudflare.Env
   getChatAgentClassName(): Promise<string>;
   registerChat(durableObjectName: string): Promise<void>;
   recordChatTurn(durableObjectName: string, messages: UIMessage[]): Promise<void>;
-  recordChatFeedback(durableObjectName: string, messageId: string, rating: number): Promise<void>;
+  recordChatFeedback(durableObjectName: string, messageId: string, rating: MessageFeedbackRating): Promise<void>;
   private [DELETE_CHAT_CALLBACK];
   private scheduleChatForAutoDeletion;
   /**
@@ -349,7 +362,8 @@ declare abstract class Assistant<State = unknown> extends Agent$1<Cloudflare.Env
   /**
    * Records activity against this Assistant's registry row by advancing its
    * `updated_at`, so instances can be ordered by recency of activity. An
-   * Assistant is a top-level DO, so its row is keyed by its own class + name.
+   * Assistant is a top-level DO, so its row is keyed by its logical agent name
+   * and Durable Object name.
    * Best-effort and non-blocking.
    */
   private touchInstance;
@@ -369,7 +383,111 @@ interface SkillSource<Context extends Record<string, unknown> = Record<string, u
 }
 declare function skill<Context extends Record<string, unknown> = Record<string, unknown>>(definition: Skill<Context>): SkillSource<Context>;
 //#endregion
-//#region src/server/index.d.ts
-declare function getCurrentToolContext(): any;
+//#region src/server/agents/TaskAgent.d.ts
+/** The run's input: plain text, or an assembled user message. */
+type TaskRunInput = UIMessage[] | string;
+type TaskRunResult = {
+  status: "completed";
+  output: string;
+  outputType: "text" | "json";
+} | {
+  status: "error";
+  error: string;
+} /** This instance (runId) already executed — the caller should not retry it. */ | {
+  status: "duplicate";
+};
+type TaskAuthentication<TUserContext extends Record<string, unknown> = Record<string, unknown>> = Authenticated<TUserContext>;
+/** Persisted claim on the run id — the at-most-once guard across evictions. */
+interface TaskAgentState {
+  claimed: boolean;
+}
+declare abstract class TaskAgent<RequestContext extends Record<string, unknown> = Record<string, unknown>, UserContext extends Record<string, unknown> = Record<string, unknown>> extends Agent<Cloudflare.Env & AgentEnv, TaskAgentState> {
+  /** Stable logical identity used in analytics, audit logs, and operational logs. */
+  abstract get agentName(): string;
+  observability: import("agents/observability").Observability;
+  initialState: TaskAgentState;
+  protected userContext?: UserContext;
+  /** Max tool-call rounds per run. Same name and default as Think's. */
+  maxSteps: number;
+  /**
+   * How long a finished run is retained — same days-based knob as chat's
+   * retention. For a task, retention IS the at-most-once window: it is how
+   * long the used run id is remembered. After it the instance destroys
+   * itself — the id's only afterlife is this guard.
+   */
+  retentionDays: number;
+  abstract getModel(ctx?: ToolContext<RequestContext, UserContext>): LanguageModel;
+  abstract getSystemPrompt(ctx?: ToolContext<RequestContext, UserContext>): string;
+  /** Generic request authentication. Absent means this task agent is open. */
+  protected getAuthenticator?(env: Cloudflare.Env): Authenticator<UserContext>;
+  getTools(): ToolSet;
+  getSkills(): SkillSource[] | Promise<SkillSource[]>;
+  getSkillScriptRunner(): import("agents/skills").SkillScriptRunner | null;
+  /** JSON Schema the run's output must conform to; undefined = plain text. */
+  protected getOutputSchema(): Record<string, unknown> | undefined;
+  /** Extra validation of a produced JSON output — return an error message to fail the run. */
+  protected validateOutput(_value: unknown): string | null;
+  protected getTelemetryActorId(): string;
+  /** Extra metadata stamped onto the run's telemetry (e.g. environment). */
+  protected getTelemetryMetadata(): Record<string, string>;
+  private _analyticsHandlers?;
+  /** Product-analytics destinations for this task agent. Disabled by default. */
+  protected getAnalyticsHandlers(): readonly AnalyticsHandler[];
+  /** Business dimensions added to every analytics event (for example tenant or user type). */
+  protected getAnalyticsAttributes(): AnalyticsAttributes;
+  /** Emits a typed product event to the configured handlers. */
+  protected emitAnalyticsEvent(payload: AnalyticsEventPayload | (() => AnalyticsEventPayload)): void;
+  onStart(): void;
+  /**
+   * Runs the configured authenticator for one task request. Custom transports
+   * call this before passing a successful result to {@link runTask}.
+   */
+  protected authenticateRequest(request: Request): Promise<Response | TaskAuthentication<UserContext> | undefined>;
+  /** Default transport: gate only. Override with your wire protocol. */
+  onRequest(request: Request): Promise<Response>;
+  /**
+   * Execute the run. Runs at most once per instance — the instance name is
+   * the run id, so a repeat POST of the same run id (in flight or finished)
+   * reports `duplicate` instead of re-executing (and re-billing) the run.
+   * The run executes as a durable fiber: ledgered in SQLite and holding a
+   * keepAlive so the instance is not idle-evicted mid-run.
+   *
+   * `requestContext` is the transport's contribution to the run's ToolContext
+   * (chat merges the client turn body the same way); the harness adds `_token`
+   * and `_userContext` from request-scoped authentication.
+   *
+   * This method trusts the supplied `authenticated` value. A transport exposed
+   * to untrusted callers must obtain it from {@link authenticateRequest}; callers
+   * must not be allowed to provide a fabricated authentication result over RPC.
+   */
+  runTask(input: TaskRunInput, requestContext?: RequestContext, authenticated?: TaskAuthentication<UserContext>): Promise<TaskRunResult>;
+  /** Scheduled callback — removes the run's state and evicts the instance. */
+  expireRun(): Promise<void>;
+  private scheduleSelfDestruction;
+  private executeRun;
+  /**
+   * Same authorization behaviour as the chat harness: unauthorized tools stay
+   * callable but their execution is replaced with an explanatory refusal, so
+   * the model reports the missing access instead of flailing into other tools.
+   */
+  private authorizedTools;
+  /**
+   * Refuses activation of an unauthorized skill — the same check the chat
+   * harness runs in beforeToolCall, applied to the registry's activate_skill
+   * tool (a task has no beforeToolCall interception point).
+   */
+  private guardSkillActivation;
+}
+//#endregion
+//#region src/server/util/prompts.d.ts
+/**
+ * Render a system-prompt block in the same layout the session memory renders
+ * its context blocks with (═-ruled header, UPPERCASE label, optional
+ * description, [readonly] tag). Returns an empty string for empty content.
+ */
+declare function renderPromptBlock(label: string, content: string, description?: string): string;
+//#endregion
+//#region src/server/route-agent-request.d.ts
+declare function routeAgentRequest<Env>(request: Request, env: Env, options?: AgentOptions<Env>): Promise<Response | null>;
 //#endregion
-export { Agent, type AgentConnectionStatus, type AgentConnectionType, type AgentEnv, Assistant, ChatAgent, type ExchangedToken, type Skill, type SkillSource, type TokenExchangeConfig, type TokenExchangeResult, type Tool, type ToolContext, type ToolSet, type TurnSnapshot, exchangeToken, getCurrentToolContext, routeAgentRequest, skill, tool };
+export { type AgentConnectionStatus, type AgentConnectionType, type AgentEnv, type AnalyticsAttribute, type AnalyticsAttributes, type AnalyticsEvent, type AnalyticsEventPayload, type AnalyticsHandler, type AnalyticsUsage, Assistant, type Authenticated, type AuthenticationDenied, type AuthenticationResult, type Authenticator, ChatAgent, type GetExchangedToken, type JwtAuthenticationContext, type JwtAuthenticatorConfig, type JwtVerificationConfig, type Skill, type SkillSource, TaskAgent, type TaskAuthentication, type TaskRunInput, type TaskRunResult, type Tool, type ToolContext, type ToolSet, type TurnSnapshot, createAnalyticsEngineHandler, createJwtAuthenticator, renderPromptBlock, routeAgentRequest, skill, tool };