experimental-a2 0.16.1 → 0.18.0

package/dist/{ai-CrEf6p_W.d.ts → ai-DrUaMyRt.d.ts}

@@ -1,6 +1,26 @@
-import { h as StandardSchemaV1, i as Contract, s as EventDefs, t as Reducer } from "./reducer-otzHjuJj.js";
-import { s as HandlerContext } from "./server-DbD7IJVK.js";
-import { FinishReason, JSONValue, LanguageModelUsage, UIMessage, UIMessage as UIMessage$1, UIMessageChunk, UIMessageChunk as UIMessageChunk$1 } from "ai";
+import { c as ContractEvent, s as Contract, t as Reducer, u as EventDefs, v as StandardSchemaV1 } from "./reducer-CqA59Q6U.js";
+import { c as HandlerContext } from "./server-En7cbi3v.js";
+import { FinishReason, JSONValue as JSONValue$1, LanguageModelCallOptions, LanguageModelUsage, UIMessage, UIMessage as UIMessage$1, UIMessageChunk, UIMessageChunk as UIMessageChunk$1 } from "ai";
+//#region src/ai-message-base.d.ts
+type FieldUndo = {
+  value?: unknown;
+} | {
+  remove: true;
+} | {
+  length: number;
+};
+type FieldsUndo = Record<string, FieldUndo>;
+type PartUndo = {
+  value: UIMessage["parts"][number];
+} | {
+  fields: FieldsUndo;
+};
+type MessageBase = {
+  partCount: number;
+  fields?: FieldsUndo;
+  parts?: Record<string, PartUndo>;
+};
+//#endregion
 //#region src/ai-control.d.ts
 type InboxItem<M extends UIMessage = UIMessage> = {
   id: string;
@@ -161,56 +181,37 @@ type ProgressBatches = {
 };
 //#endregion
 //#region src/ai-message-projection.d.ts
-type MessageProjection<M extends UIMessage> = Omit<ActiveGenerationProjection<M>, "baseTools">;
-//#endregion
-//#region src/ai-stored-state.d.ts
-type Value = null | boolean | number | string | Value[] | {
-  [key: string]: Value;
-};
-type Payload = {
-  value?: unknown;
-};
-type Undo = {
-  value: Value;
-} | {
-  length: number;
-  items: Record<string, Undo>;
-} | {
-  fields: Record<string, Undo>;
-  remove: string[];
-};
-type Projection = {
-  fields: Value;
-  hasMessage: boolean;
-  message?: Undo;
-  tools?: Undo;
-};
-type AIStoredState = {
-  version: 2;
-  fields: Value;
-  projection: Projection | null;
-  values: Payload[];
-};
-type AIStoredView = {
-  messages: UIMessage[];
-  activeProjection: (MessageProjection<UIMessage> & {
-    baseTools?: AIState["tools"];
-  }) | null;
-  tools?: AIState["tools"];
-  usage?: AIState["usage"];
-};
-declare const aiStateReducer: unique symbol;
-type AIStoredReducer<D extends EventDefs, S extends AIStoredView> = Reducer<D, AIStoredState, Record<never, never>, S> & {
-  readonly [aiStateReducer]: Reducer<D, S>;
-  view(state: AIStoredState): S;
-  fromView(state: S): AIStoredState;
-};
+declare const isCompactionPart: (part: {
+  type: string;
+}) => part is CompactionPart;
 //#endregion
 //#region src/ai.d.ts
 type AgentStatus = "idle" | "generating" | "waiting" | "failed" | "closed" | "paused";
 type GenerationReason = "message" | "tool" | "input" | "retry" | "resume";
+type ReasoningLevel = NonNullable<LanguageModelCallOptions["reasoning"]>;
+declare const reasoningLevels: readonly ReasoningLevel[];
+type CompactionPartData = {
+  status: "running" | "completed" | "failed" | "interrupted";
+  inputTokens?: number;
+  thresholdTokens?: number;
+  summary?: string;
+  usage?: LanguageModelUsage;
+};
+/** The transcript part A2 adds to a response where its context was compacted. */
+type CompactionPart = {
+  type: "data-a2-compaction";
+  id: string;
+  data: CompactionPartData;
+};
+/**
+ * A transcript message: `M` plus the compaction part A2 adds, so
+ * `isCompactionPart` narrows even when `M` declares its own data parts.
+ */
+type TranscriptMessage<M extends UIMessage$1> = Omit<M, "parts"> & {
+  parts: Array<M["parts"][number] | CompactionPart>;
+};
 type SessionCreatedPayload = {
-  metadata?: JSONValue;
+  metadata?: JSONValue$1;
 };
 type SessionClosedPayload = {
   reason?: string;
@@ -258,15 +259,13 @@ type GenerationStartedPayload = {
   generationId: string;
   responseMessageId: string;
   attempt: number;
-  model: string;
+  /** Absent when the attempt failed before its model resolved. */
+  model?: string;
   promptThroughIndex?: number;
 };
 type GenerationProgressPayload = {
-  requestId: string;
-  messageId: string;
-  generationId: string;
-  responseMessageId: string;
-  sequence: number;
+  /** Log index of the generation's `ai.generation.started`. */
+  startIndex: number;
   chunks: UIMessageChunk$1[];
 };
 type GenerationCompletedPayload = {
@@ -343,7 +342,7 @@ type InputRequestedPayload = {
   generationId: string;
   inputId: string;
   name: string;
-  question?: JSONValue;
+  question?: JSONValue$1;
 };
 type InputRespondedPayload = {
   requestId: string;
@@ -351,7 +350,7 @@ type InputRespondedPayload = {
   generationId: string;
   inputId: string;
   name: string;
-  value: JSONValue;
+  value: JSONValue$1;
 };
 type ModelLimits = {
   contextWindow: number;
@@ -421,19 +420,22 @@ type AIEventDefs<M extends UIMessage$1 = UIMessage$1> = {
   "ai.model.metadata.requested": StandardSchemaV1<ModelMetadataRequestedPayload>;
   "ai.model.metadata.resolved": StandardSchemaV1<ModelMetadataResolvedPayload>;
 };
-type ActiveGeneration = GenerationStartedPayload;
-type ActiveGenerationProjection<M extends UIMessage$1 = UIMessage$1> = {
+type ActiveGeneration = GenerationStartedPayload & {
+  /** Log index of this generation's `ai.generation.started`. */
+  startIndex: number;
+};
+type ActiveGenerationProjection = {
   generationId: string;
   responseMessageId: string;
   /** Log index of the completed model step while its response remains interruptible. */
   completionIndex?: number;
-  baseMessage?: M;
+  base?: MessageBase;
   promptThroughIndex?: number;
   cursor?: {
     throughIndex: number;
     stream: UIMessageCursor;
   } | null;
-  baseCompaction?: CompactionState<M> | null;
+  baseCompaction?: CompactionState | null;
   batches: ProgressBatches;
   baseTools: ToolActivity[];
   toolEvents: Array<{
@@ -463,27 +465,19 @@ type ToolActivity = {
   generationId: string;
   toolCallId: string;
   toolName?: string;
-  input?: unknown;
-  rawInput?: unknown;
-  output?: unknown;
   error?: string;
   preliminary?: boolean;
   phase?: "input" | "execution";
   dynamic?: boolean;
   providerExecuted?: boolean;
-  callProviderMetadata?: unknown;
-  resultProviderMetadata?: unknown;
-  toolMetadata?: unknown;
   title?: string;
   status: "running" | "completed" | "failed" | "denied";
 };
-type CompactionState<M extends UIMessage$1> = {
+type CompactionState = {
   status: "running" | "completed";
   generationId: string;
   throughMessageId: string;
   throughIndex?: number;
-  messages?: M[];
-  retainedMessageIds?: string[];
   summary?: string;
   usage?: LanguageModelUsage;
 };
@@ -503,43 +497,68 @@ type AIState<M extends UIMessage$1 = UIMessage$1> = {
   pausedGenerationIds?: Record<string, true>;
   session: {
     created: boolean;
-    metadata?: JSONValue;
+    metadata?: JSONValue$1;
   };
-  messages: M[];
+  messages: TranscriptMessage<M>[];
   status: AgentStatus;
   activeGeneration: ActiveGeneration | null;
   activeRequestId: string | null;
   activeRequestReason: GenerationReason | null;
   activeRequestSourceGenerationId: string | null;
   activeResponseMessageId: string | null;
-  activeProjection: ActiveGenerationProjection<M> | null;
+  activeProjection: ActiveGenerationProjection | null;
   responseOwners: Record<string, Pick<GenerationStartedPayload, "generationId" | "requestId" | "attempt">>;
   terminalRequestIds?: Record<string, true>;
   terminalGenerations?: Record<string, "completed" | "failed" | "interrupted" | "superseded">;
   pendingApprovals: PendingApproval[];
   pendingInputs: PendingInput[];
   tools: ToolActivity[];
-  compaction: CompactionState<M> | null;
+  compaction: CompactionState | null;
   modelMetadata: Record<string, ModelMetadataState>;
   usage: GenerationUsage[];
   error: string | null;
 };
-type AgentDefinition<M extends UIMessage$1 = UIMessage$1, D extends EventDefs = AIEventDefs<M>> = {
-  readonly contract: Contract<D>;
-  readonly reducer: AIStoredReducer<D, AIState<M>>;
-};
+/** The `UIMessage` type a contract's `ai.message.created` schema carries. */
+type AIMessageOf<D> = D extends {
+  readonly "ai.message.created": infer S extends StandardSchemaV1;
+} ? StandardSchemaV1.InferOutput<S> extends MessageCreatedPayload<infer M extends UIMessage$1> ? M : UIMessage$1 : UIMessage$1;
+/** What `agentContract()` returns: the AI protocol, with `X` as application state. */
+type AgentContract<M extends UIMessage$1 = UIMessage$1, D extends EventDefs = AIEventDefs<M>, X extends object = Record<never, never>> = Contract<D, Record<never, never>, AgentReducer<M, D, X>>;
 type AgentToolEventDefs = EventDefs & Pick<AIEventDefs, "ai.tool.execution.requested">;
 /** The durable handler context supplied when A2 executes a local AI tool. */
 type AgentToolContext<D extends AgentToolEventDefs> = HandlerContext<D, "ai.tool.execution.requested">;
-type AgentOptions<M extends UIMessage$1, E extends EventDefs> = {
+/** Application state folded after the AI protocol, on the server and in clients. */
+/** Rejects application state keys that would shadow `AIState`'s. */
+type OwnKeys<X> = { [K in Extract<keyof X, keyof AIState>]: never; };
+/** Rejects a stateless application reducer, whose name would not be built in. */
+type NonEmpty<X> = keyof X extends never ? never : unknown;
+/**
+ * The reducer `agentContract()` builds. Without application state it carries
+ * the built-in name, which is what lets the contract-free client fold it.
+ * `~appState` is type-only, absent at runtime: it carries the application
+ * state's type to `agent()`, and marks the reducer as `agentContract()`'s.
+ */
+type AgentReducer<M extends UIMessage$1, D extends EventDefs, X extends object> = (keyof X extends never ? Reducer<D, AIState<M>> & {
+  readonly name: typeof AI_STATE_REDUCER;
+} : Reducer<D, AIState<M> & X>) & {
+  readonly "~appState": X;
+};
+type AgentContractOptions<M extends UIMessage$1, E extends EventDefs, X extends object> = {
   name: string;
   events?: E;
   /** Optional stricter schema for custom UIMessage metadata/data/tool types. */
   messageSchema?: StandardSchemaV1<M>;
-  /** Snapshot identity. Bump when application-level projection semantics change. */
-  reducerName?: string;
+  /**
+   * Application state, folded from events beside `AIState` and merged into
+   * it. `fold` sees only this state, never the transcript.
+   */
+  reducer?: {
+    /** Snapshot identity of the application state. Rename it when `fold` changes. */
+    name: string;
+    initialState: X & OwnKeys<X> & NonEmpty<X>;
+    fold: (state: NoInfer<X>, event: ContractEvent<AIEventDefs<M> & NoInfer<E>>) => NoInfer<X>;
+  };
 };
-type AIMessageFrom<D extends EventDefs> = D extends Record<"ai.message.created", infer S extends StandardSchemaV1> ? StandardSchemaV1.InferOutput<S> extends MessageCreatedPayload<infer M extends UIMessage$1> ? M : UIMessage$1 : UIMessage$1;
 declare function createEvents<M extends UIMessage$1 = UIMessage$1>(options?: {
   messageSchema?: StandardSchemaV1<M>;
 }): AIEventDefs<M>;
@@ -556,14 +575,7 @@ declare function deriveUIMessages<M extends UIMessage$1 = UIMessage$1>(history:
   type: string;
   payload: unknown;
   index: number;
-}[]): M[];
-/** Build the standard AI state projection for any contract containing the protocol. */
-declare function createReducer<D extends EventDefs>(options: {
-  contract: Contract<D>;
-  name?: string;
-  fold?: Reducer<D, AIState<AIMessageFrom<D>>>["fold"];
-  stateSchema?: StandardSchemaV1<unknown, AIState<AIMessageFrom<D>>>;
-}): AIStoredReducer<D, AIState<AIMessageFrom<D>>>;
+}[]): TranscriptMessage<M>[];
 type CommandInput<C> = {
   type: "ai.control.requested";
   payload: C;
@@ -622,18 +634,20 @@ declare const inputs: AIInputs;
  * Read the durable handler context ambient to the current AI tool
  * execution. A2 runs each local tool's `execute` inside this scope, so
  * plain AI SDK `tool()` definitions reach their `event`, `attempt`,
- * `session`, and `signal` without an A2-specific wrapper. The agent (or
- * contract) argument carries the event types and is verified against
- * the executing server's contract.
+ * `session`, and `signal` without an A2-specific wrapper. Pass the
+ * agent's contract to type application events; it is verified against
+ * the executing agent.
  */
-declare function handlerContext<D extends AgentToolEventDefs>(agentOrContract: Contract<D> | {
-  readonly contract: Contract<D>;
-}): AgentToolContext<D>;
+declare function handlerContext<D extends AgentToolEventDefs = AIEventDefs>(contract?: Contract<D>): AgentToolContext<D>;
+/** The built-in AI reducer's name, and so its checkpoint identity. */
+declare const AI_STATE_REDUCER = "a2.ai.state.v26";
 /**
- * Define an agent: built-in AI protocol + application events and one state
- * reducer. The result is isomorphic.
+ * The built-in AI protocol plus application events, as a core contract whose
+ * reducer folds `AIState`. Isomorphic: share it when a client needs
+ * application events or extended state; otherwise `agent({ name })` on the
+ * server builds one and clients use the built-in protocol.
  */
-declare function agent<M extends UIMessage$1 = UIMessage$1, E extends EventDefs = Record<never, never>>(options: AgentOptions<M, E>): AgentDefinition<M, AIEventDefs<M> & E>;
+declare function agentContract<M extends UIMessage$1 = UIMessage$1, E extends EventDefs = Record<never, never>, X extends object = Record<never, never>>(options: AgentContractOptions<M, E, X>): AgentContract<M, AIEventDefs<M> & E, X>;
 //#endregion
-export { reduceAIState as $, MessageInterruptedPayload as A, SessionCreatedPayload as B, GenerationUsage as C, LanguageModelUsage as D, JSONValue as E, PendingApproval as F, UIMessageChunk$1 as G, ToolCalledPayload as H, PendingInput as I, createReducer as J, agent as K, RetryGenerationOptions as L, ModelMetadataRequestedPayload as M, ModelMetadataResolvedPayload as N, MessageCompletedPayload as O, ModelMetadataState as P, inputs as Q, RetryRequestedPayload as R, GenerationStartedPayload as S, InputRespondedPayload as T, ToolResultPayload as U, ToolActivity as V, UIMessage$1 as W, events as X, deriveUIMessages as Y, handlerContext as Z, GenerationCompletedPayload as _, ActiveGenerationProjection as a, ControlReceipt as at, GenerationReason as b, AgentStatus as c, ApprovalRequestedPayload as d, AIStoredReducer as et, ApprovalRespondedPayload as f, FinishReason as g, CompactionState as h, ActiveGeneration as i, ControlCommand as it, ModelLimits as j, MessageCreatedPayload as k, AgentToolContext as l, CompactionRequestedPayload as m, AIInputs as n, PendingQueueCommand as nt, AgentDefinition as o, InboxItem as ot, CompactionCompletedPayload as p, createEvents as q, AIState as r, ActiveTurn as rt, AgentOptions as s, AIEventDefs as t, AIStoredState as tt, AgentToolEventDefs as u, GenerationFailedPayload as v, InputRequestedPayload as w, GenerationRequestedPayload as x, GenerationProgressPayload as y, SessionClosedPayload as z };
-//# sourceMappingURL=ai-CrEf6p_W.d.ts.map
+export { agentContract as $, InputRespondedPayload as A, PendingApproval as B, GenerationFailedPayload as C, GenerationStartedPayload as D, GenerationRequestedPayload as E, MessageInterruptedPayload as F, SessionClosedPayload as G, ReasoningLevel as H, ModelLimits as I, ToolCalledPayload as J, SessionCreatedPayload as K, ModelMetadataRequestedPayload as L, LanguageModelUsage as M, MessageCompletedPayload as N, GenerationUsage as O, MessageCreatedPayload as P, UIMessageChunk$1 as Q, ModelMetadataResolvedPayload as R, GenerationCompletedPayload as S, GenerationReason as T, RetryGenerationOptions as U, PendingInput as V, RetryRequestedPayload as W, TranscriptMessage as X, ToolResultPayload as Y, UIMessage$1 as Z, CompactionPart as _, AI_STATE_REDUCER as a, reasoningLevels as at, CompactionState as b, AgentContract as c, PendingQueueCommand as ct, AgentStatus as d, ControlReceipt as dt, createEvents as et, AgentToolContext as f, InboxItem as ft, CompactionCompletedPayload as g, ApprovalRespondedPayload as h, AIState as i, inputs as it, JSONValue$1 as j, InputRequestedPayload as k, AgentContractOptions as l, ActiveTurn as lt, ApprovalRequestedPayload as m, AIInputs as n, events as nt, ActiveGeneration as o, reduceAIState as ot, AgentToolEventDefs as p, ToolActivity as q, AIMessageOf as r, handlerContext as rt, ActiveGenerationProjection as s, isCompactionPart as st, AIEventDefs as t, deriveUIMessages as tt, AgentReducer as u, ControlCommand as ut, CompactionPartData as v, GenerationProgressPayload as w, FinishReason as x, CompactionRequestedPayload as y, ModelMetadataState as z };
+//# sourceMappingURL=ai-DrUaMyRt.d.ts.map

package/dist/ai-DrUaMyRt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-DrUaMyRt.d.ts","names":[],"sources":["../src/ai-message-base.ts","../src/ai-control.ts","../src/ai-client-state.ts","../src/ai-projector.ts","../src/ai-progress-batches.ts","../src/ai-message-projection.ts","../src/ai.ts"],"mappings":";;;;KAGK;EAAc;;EAAsB;;EAAmB;;KACvD,aAAa,eAAe;KAC5B;EAAa,OAAO;;EAAiC,QAAQ;;KAEtD;EACV;EACA,SAAS;EACT,QAAQ,eAAe;;;;KCIb,UAAU,UAAU,YAAY;EAC1C;EACA,SAAS;EACT;EACA;;KAGU,eAAe,UAAU,YAAY;EAC3C;EAAgB,SAAS;EAAG;;EAC5B;EAAgB,SAAS;;EACzB;EAAgB;EAAiB;;EACjC;EAAkB;;EAElB;EACA;EACA;EACA;;EAEA;EAAgB;EAAgB;;EAChC;EAAiB;EAAgB,SAAS;EAAG;;EAC7C;EAAiB;;EACjB;;EACA;EAAuB,QAAQ;;EAC/B;EAAoB,UAAU;;EAC9B;EAAiB,UAAU;;EAC3B;EAAyB,SAAS;;EAClC;EAAiB,SAAS;;EAC1B;EAAqB,SAAS;;KAExB;EACV;EACA;EACA;EACA;;KAUU,WAAW,UAAU,YAAY;EAC3C;EACA,OAAO,UAAU;EACjB;;KA+BU;EAAa;EAAc;EAAY;;KACvC;EACV;EACA;EACA;EACA;EACA;EACA;EACA,QAAQ;;KAGE;EACV;EACA;EACA,MAAM;EACN,YAAY;;KAYF;EACV;EACA;EACA;EACA;IAAW;IAAe;IAAqB;;EAC/C;IAAS;IAAc;;;KAGb;EACV,SAAS;EACT;IACE;IACA;IACA,OAAO;IACP;IACA;IACA;IACA,eAAe;IACf;IACA;;;;;KCjIQ,aAAa,UAAU,aAAa,QAC9C,eAAe;EAEb;;KAYQ,oBAAoB,UAAU;EACxC;EACA,SAAS,aAAa;;;;KCfnB;EACH;EACA;EACA;EACA;EACA;EACA;EACA;;KAwJU;EACV,MAAM;EACN,WAAW;EACX,OAAO,eAAe;;;;KChJZ;EAAkB;EAAe,QAAQ;;KAChD,aAAa;EAAoB,MAAM;EAAY,OAAO;;KAEnD;EACV;EACA,MAAM;EACN,QAAQ,MAAM;;;;cCmgBH,mBAAoB;EAC/B;MACE,QAAQ;;;KCtcA;KAGA;KAEA,iBAAiB,YAAY;cAE5B,0BAA0B;KAU3B;EACV;EACA;EACA;EACA;EACA,QAAQ;;;KAIE;EACV;EACA;EACA,MAAM;;;;;;KASI,kBAAkB,UAAU,eAAa,KAAK;EACxD,OAAO,MAAM,qBAAqB;;KAGxB;EAA0B,WAAW;;KACrC;EAAyB;;KACzB,sBAAsB,UAAU;EAC1C,SAAS;;EAET;;KAEU;EAA4B;;KACnC;EACH;EACA;;EAEA;;KAEU,4BAA4B;EAEhC;EAAsB;;EACtB;EAAmB;;KAEf;EACV;IAAY;IAAgB;;EAC5B;EACA,QAAQ;EACR;EACA;;KAEU;EACV;EACA;EACA;;KAEU,wBAAwB;KACxB;EACV;EACA;EACA;EACA;EACA;;EAEA;EACA;;KAEU;;EAEV;EACA,QAAQ;;KAEE;EACV;EACA;EACA;EACA;EACA,eAAe;EACf,QAAQ;EACR;;KAEU;EACV;EACA;EACA;EACA;EACA;;EAEA;EACA;;KAEU;EACV;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;KAEU;EACV;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;KAEU;EACV;EACA;EACA;EACA;EACA;EACA;EACA;;KAEU;EACV;EACA;EACA;EACA;EACA;EACA;;KAEU;EACV;EACA;EACA;EACA;EACA;EACA,WAAW;;KAED;EACV;EACA;EACA;EACA;EACA;EACA,OAAO;;KAEG;EACV;EACA;;KAEU;EAAkC;;KAClC;EACV;EACA,QAAQ;;KAEE;EACN;;EACA;EAAoB,QAAQ;;EAC5B;;KAEM;EACV;EACA;EACA;EACA;EACA;EACA;;KAEU,2BAA2B,UAAU;EAC/C;EACA;EACA;EACA,UAAU;EACV;EACA;EACA,QAAQ;;KAGE,YAAY,UAAU,cAAY;EAC5C,wBAAwB,iBAAiB,eAAe;EACxD,wBAAwB,iBAAiB;EACzC,sBAAsB,iBAAiB;EACvC,oBAAoB,iBAAiB;EACrC,+BAA+B,iBAAiB;EAChD,wBAAwB;IACtB;IACA;;EAEF,sBAAsB,iBAAiB;EACvC,qBAAqB,iBAAiB;EACtC,sBAAsB,iBAAiB,sBAAsB;EAC7D,wBAAwB,iBAAiB;EACzC,0BAA0B,iBAAiB;EAC3C,2BAA2B,iBAAiB;EAC5C,sBAAsB,iBAAiB;EACvC,yB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"}

package/dist/ai-client.d.ts

@@ -0,0 +1,27 @@
+import { s as CreateClientOptions, t as A2Client } from "./client-h_DKFAjj.js";
+import { a as AI_STATE_REDUCER, i as AIState, r as AIMessageOf, t as AIEventDefs } from "./ai-DrUaMyRt.js";
+//#region src/ai-client.d.ts
+/**
+ * The structural shape of `typeof` an `agent({ name })` server: one whose
+ * state the built-in reducer folds. Agents built from an extended contract
+ * use `createClient({ contract })` instead.
+ */
+type AnyAgent = {
+  readonly contract: {
+    readonly events: object;
+    readonly reducer: {
+      readonly name: typeof AI_STATE_REDUCER;
+    };
+  };
+};
+type AgentMessage<A extends AnyAgent> = AIMessageOf<A["contract"]["events"]>;
+type AgentClient<A extends AnyAgent = AnyAgent> = A2Client<AIEventDefs<AgentMessage<A>>, AIState<AgentMessage<A>>>;
+type CreateAgentClientOptions = Omit<CreateClientOptions<AIEventDefs, AIState>, "contract">;
+/**
+ * A client for the built-in AI protocol. Agents built from a shared
+ * `agentContract()` use `createClient({ contract })` instead.
+ */
+declare function createAgentClient<A extends AnyAgent = AnyAgent>(options: CreateAgentClientOptions): AgentClient<A>;
+//#endregion
+export { AgentClient, AgentMessage, AnyAgent, CreateAgentClientOptions, createAgentClient };
+//# sourceMappingURL=ai-client.d.ts.map

package/dist/ai-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-client.d.ts","names":[],"sources":["../src/ai-client.ts"],"mappings":";;;;;;;;KA8BY;WACD;aACE;aACA;eAAoB,aAAa;;;;KAIlC,aAAa,UAAU,YAAY,YAC7C;KAGU,YAAY,UAAU,WAAW,YAAY,SACvD,YAAY,aAAa,KACzB,QAAQ,aAAa;KAGX,2BAA2B,KACrC,oBAAoB,aAAa;;;;;iBAUnB,kBAAkB,UAAU,WAAW,UACrD,SAAS,2BACR,YAAY"}

package/dist/ai-client.js

@@ -0,0 +1,29 @@
+import { t as createClient } from "./client-BReKqwZC.js";
+import { n as agentContract } from "./ai-BpOGm-zB.js";
+//#region src/ai-client.ts
+/**
+* experimental-a2/ai/client — a client for an `agent()` route that needs no
+* contract: the AI protocol and its `AIState` reducer are library code, and
+* the agent's types arrive through a type-only `typeof` import.
+*
+* ```ts
+* import type { assistant } from '@/server/assistant' // erased at build
+* const client = createAgentClient<typeof assistant>({ api: '/api/agent' })
+* await client.session(id).push(...inputs.message(message))
+* ```
+*/
+const protocol = agentContract({ name: "a2.ai" });
+/**
+* A client for the built-in AI protocol. Agents built from a shared
+* `agentContract()` use `createClient({ contract })` instead.
+*/
+function createAgentClient(options) {
+	return createClient({
+		...options,
+		contract: protocol
+	});
+}
+//#endregion
+export { createAgentClient };
+
+//# sourceMappingURL=ai-client.js.map

package/dist/ai-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-client.js","names":[],"sources":["../src/ai-client.ts"],"sourcesContent":["/**\n * experimental-a2/ai/client — a client for an `agent()` route that needs no\n * contract: the AI protocol and its `AIState` reducer are library code, and\n * the agent's types arrive through a type-only `typeof` import.\n *\n * ```ts\n * import type { assistant } from '@/server/assistant' // erased at build\n * const client = createAgentClient<typeof assistant>({ api: '/api/agent' })\n * await client.session(id).push(...inputs.message(message))\n * ```\n */\n\nimport {\n  agentContract,\n  type AI_STATE_REDUCER,\n  type AIEventDefs,\n  type AIMessageOf,\n  type AIState,\n} from './ai.ts'\nimport {\n  createClient,\n  type A2Client,\n  type CreateClientOptions,\n} from './client.ts'\n\n/**\n * The structural shape of `typeof` an `agent({ name })` server: one whose\n * state the built-in reducer folds. Agents built from an extended contract\n * use `createClient({ contract })` instead.\n */\nexport type AnyAgent = {\n  readonly contract: {\n    readonly events: object\n    readonly reducer: { readonly name: typeof AI_STATE_REDUCER }\n  }\n}\n\nexport type AgentMessage<A extends AnyAgent> = AIMessageOf<\n  A['contract']['events']\n>\n\nexport type AgentClient<A extends AnyAgent = AnyAgent> = A2Client<\n  AIEventDefs<AgentMessage<A>>,\n  AIState<AgentMessage<A>>\n>\n\nexport type CreateAgentClientOptions = Omit<\n  CreateClientOptions<AIEventDefs, AIState>,\n  'contract'\n>\n\nconst protocol = agentContract({ name: 'a2.ai' })\n\n/**\n * A client for the built-in AI protocol. Agents built from a shared\n * `agentContract()` use `createClient({ contract })` instead.\n */\nexport function createAgentClient<A extends AnyAgent = AnyAgent>(\n  options: CreateAgentClientOptions,\n): AgentClient<A> {\n  return createClient({ ...options, contract: protocol }) as AgentClient<A>\n}\n"],"mappings":";;;;;;;;;;;;;;AAmDA,MAAM,WAAW,cAAc,EAAE,MAAM,QAAQ,CAAC;;;;;AAMhD,SAAgB,kBACd,SACgB;CAChB,OAAO,aAAa;EAAE,GAAG;EAAS,UAAU;CAAS,CAAC;AACxD"}

package/dist/ai-fx.browser.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/ai-fx.browser.js

@@ -0,0 +1,6 @@
+//#region src/ai-fx.browser.ts
+/** experimental-a2/ai/fx is server-only; browsers reach an agent through its route. */
+throw new Error("experimental-a2/ai/fx is server-only — a client bundle imported it. Keep agent({ harness: fx() }) in server code.");
+//#endregion
+
+//# sourceMappingURL=ai-fx.browser.js.map

package/dist/ai-fx.browser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-fx.browser.js","names":[],"sources":["../src/ai-fx.browser.ts"],"sourcesContent":["/** experimental-a2/ai/fx is server-only; browsers reach an agent through its route. */\nthrow new Error(\n  'experimental-a2/ai/fx is server-only — a client bundle imported it. Keep agent({ harness: fx() }) in server code.',\n)\nexport {}\n"],"mappings":";;AACA,MAAM,IAAI,MACR,mHACF"}

package/dist/ai-fx.d.ts

@@ -0,0 +1,10 @@
+import { t as Harness } from "./ai-harness-DvsPeJeB.js";
+//#region src/ai-fx.d.ts
+/**
+ * The FX harness. Every model call FX makes is one durable step; A2 rebuilds
+ * the kernel for each step from its latest checkpoint and the log since.
+ */
+declare function fx(): Harness<"fx", never>;
+//#endregion
+export { type Harness, fx };
+//# sourceMappingURL=ai-fx.d.ts.map

package/dist/ai-fx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-fx.d.ts","names":[],"sources":["../src/ai-fx.ts"],"mappings":";;;;;;iBAwCgB,MAAM"}