akanjs 3.0.0-alpha.2 → 3.0.0-alpha.21

package/dictionary/agent.dictionary.ts

@@ -0,0 +1,31 @@
+import type { AgentEndpoint } from "akanjs/signal";
+
+import { serviceDictionary } from "./dictInfo";
+
+export const agentDictionary = serviceDictionary(["en", "ko"])
+  .endpoint<AgentEndpoint>((fn) => ({
+    runAgentTurn: fn(["Run Agent Turn", "에이전트 턴 실행"])
+      .desc([
+        "Relays one in-page agent turn to the model and returns its answer; tools execute in the caller's browser",
+        "인페이지 에이전트 턴 하나를 모델에 릴레이하고 응답을 돌려준다. 툴 실행은 호출자의 브라우저에서 한다",
+      ])
+      .arg((t) => ({
+        messages: t(["Messages", "메시지"]).desc(["The whole transcript in wire shape", "와이어 형태의 전체 대화"]),
+        tools: t(["Tools", "툴"]).desc(["The published tool catalogue, schemas only", "게시된 툴 카탈로그 (스키마만)"]),
+        context: t(["Context", "컨텍스트"]).desc([
+          "Screen context blocks, forwarded as data",
+          "화면 컨텍스트 블록 (데이터로 전달)",
+        ]),
+        instructions: t(["Instructions", "지시문"]).desc(["App-level system instructions", "앱 수준 시스템 지시문"]),
+      })),
+  }))
+  .error({
+    llmUnavailable: [
+      "The agent model is unavailable — no LLM adaptor answered this turn",
+      "에이전트 모델을 사용할 수 없습니다. 이번 턴에 응답한 LLM 어댑터가 없습니다",
+    ],
+    deepseekRequestFailed: [
+      "DeepSeek request failed with status {status}",
+      "DeepSeek 요청이 실패했습니다 (status {status})",
+    ],
+  });

package/dictionary/agentTurn.dictionary.ts

@@ -0,0 +1,29 @@
+import type { AgentStop, AgentTurn } from "akanjs/signal";
+
+import { scalarDictionary } from "./dictInfo";
+
+export const agentTurnDictionary = scalarDictionary(["en", "ko"])
+  .of((t) =>
+    t(["Agent Turn", "에이전트 턴"]).desc([
+      "One assistant answer of an in-page agent turn",
+      "인페이지 에이전트 턴의 어시스턴트 응답 하나",
+    ]),
+  )
+  .model<AgentTurn>((t) => ({
+    text: t(["Text", "텍스트"]).desc([
+      "What the assistant said; empty when the turn is only tool calls",
+      "어시스턴트가 말한 내용. 툴 호출뿐인 턴에서는 비어 있다",
+    ]),
+    toolCalls: t(["Tool Calls", "툴 호출"]).desc([
+      "Tool calls the client should execute, as { id, name, args }",
+      "클라이언트가 실행할 툴 호출 목록 ({ id, name, args })",
+    ]),
+    stop: t(["Stop", "종료 사유"]).desc([
+      "Why the turn ended — end, or toolUse when tool results are awaited",
+      "턴이 끝난 이유 — end 또는 툴 결과를 기다리는 toolUse",
+    ]),
+  }))
+  .enum<AgentStop>("agentStop", (t) => ({
+    end: t(["End", "종료"]).desc(["The final answer", "최종 응답"]),
+    toolUse: t(["Tool Use", "툴 사용"]).desc(["The model awaits tool results", "모델이 툴 결과를 기다린다"]),
+  }));

package/dictionary/base.dictionary.ts

@@ -48,6 +48,14 @@ export const baseDictionary = serviceDictionary(["en", "ko"])
     ok: ["OK", "확인"],
     cancel: ["Cancel", "취소"],
     unauthorized: ["Unauthorized", "권한 없음"],
+    agent: ["Agent", "에이전트"],
+    agentIntro: ["Ask about this page or tell the agent what to do.", "이 화면에 대해 묻거나 할 일을 지시해 보세요."],
+    agentPlaceholder: ["Message the agent...", "에이전트에게 메시지..."],
+    agentClear: ["Clear conversation", "대화 비우기"],
+    send: ["Send", "보내기"],
+    stop: ["Stop", "중지"],
+    approve: ["Approve", "승인"],
+    decline: ["Decline", "거절"],
     confirmClose: ["Are you sure you want to close the modal?", "모달을 닫으시겠습니까?"],
     textTooShortError: ["More than {minlength} characters needed.", "{minlength}자 이상 필요합니다."],
     textTooLongError: ["Less than {maxlength} characters needed.", "{maxlength}자 이하로 필요합니다."],

package/dictionary/dictInfo.ts

@@ -777,6 +777,7 @@ export class ModelDictInfo<
       });
     });
   }
+  /** Under its own `store` node rather than beside `signal`, because the two hold the same key by design. */
   #registerErrorToRoot(refName: string, rootDict: RootDictionary) {
     this.languages.forEach((language) => {
       ensureNode(getRootModelNode(rootDict, language, refName), "error");
@@ -803,6 +804,13 @@ export class ModelDictInfo<
   }
 }
 
+/**
+ * Every parameter of `ModelDictInfo` is listed here positionally, so a parameter added to the class has to be
+ * added to all three lists below in the same slot. Omitting one does not fail to compile — inference silently
+ * shifts, so the last parameter falls off the end and becomes its default `never`, which reads at the call site
+ * as `l("<model>.<key>")` no longer existing.
+ */
+
 type AnyModelDictInfo = ModelDictInfo<any, any, any, any, any, any, any, any, any, any, any>;
 
 type MergeTwoModelDicts<ModelDict1, ModelDict2> =

package/dictionary/dictionary.ts

@@ -1,10 +1,16 @@
-import type { BaseEndpoint } from "akanjs/signal";
+import type { AgentEndpoint, AgentTurn, BaseEndpoint } from "akanjs/signal";
 
+import { agentDictionary } from "./agent.dictionary";
+import { agentTurnDictionary } from "./agentTurn.dictionary";
 import { baseDictionary } from "./base.dictionary";
-import { registerServiceTrans } from "./locale";
+import { registerScalarTrans, registerServiceTrans } from "./locale";
 import { makeTrans } from "./trans";
 
-export const dictionary = { base: registerServiceTrans<"base", BaseEndpoint, typeof baseDictionary>(baseDictionary) };
+export const dictionary = {
+  base: registerServiceTrans<"base", BaseEndpoint, typeof baseDictionary>(baseDictionary),
+  agentTurn: registerScalarTrans<"agentTurn", AgentTurn, typeof agentTurnDictionary>(agentTurnDictionary),
+  agent: registerServiceTrans<"agent", AgentEndpoint, typeof agentDictionary>(agentDictionary),
+};
 
 export const { Err, translate, msg, getDictionary, getAllDictionary, __Dict_Key__, __Error_Key__ } =
   makeTrans(dictionary);

package/dictionary/index.ts

@@ -1,3 +1,4 @@
+export * from "./DictionaryLookup";
 export * from "./dictInfo";
 export {
   __Dict_Key__,

package/document/database.ts

@@ -3,6 +3,7 @@ import { Logger } from "akanjs/common";
 import type { DocumentModel, QueryOf } from "akanjs/constant";
 import type { CacheAdaptor, CacheSetOptions } from "akanjs/service";
 import type { DataLoader } from "./dataLoader";
+import type { DocumentUpdateInput } from "./documentQuery";
 import type { ExtractQuery, ExtractSort, FilterInstance } from "./filterMeta";
 import type { CRUDEventType, Mdl, SaveEventType, UpdateResult } from "./into";
 import type { DataInputOf, FindQueryOption, ListQueryOption } from "./types";
@@ -25,6 +26,15 @@ export class CacheDatabase<T = unknown> {
     await this.cache.delete(this.refName, `${topic}:${key}`);
   }
 }
+/**
+ * What `update<Filter>` returns. The patch cannot be a trailing parameter — a filter's own args may be optional,
+ * and no tuple type puts a required element after those — and leading it reads backwards. So it lands here, on a
+ * terminal `.set()` that mirrors the `UPDATE … SET …` it compiles to.
+ */
+export interface UpdateChain<Doc = any> {
+  set(update: DocumentUpdateInput<Doc>): Promise<UpdateResult>;
+}
+
 type QueryMethodOfKey<
   CapitalizedK extends string,
   Doc,
@@ -53,6 +63,14 @@ type QueryMethodOfKey<
   [K in `insight${CapitalizedK}`]: (...args: _Args) => Promise<Insight>;
 } & {
   [K in `query${CapitalizedK}`]: (...args: _Args) => _QueryOfDoc;
+} & {
+  [K in `remove${CapitalizedK}`]: (...args: _Args) => Promise<UpdateResult>;
+} & {
+  [K in `removeOne${CapitalizedK}`]: (...args: _Args) => Promise<UpdateResult>;
+} & {
+  [K in `update${CapitalizedK}`]: (...args: _Args) => UpdateChain<Doc>;
+} & {
+  [K in `updateOne${CapitalizedK}`]: (...args: _Args) => UpdateChain<Doc>;
 };
 type QueryMethodMap<Query, Doc, Insight, _FindQueryOption, _ListQueryOption, _QueryOfDoc> = {
   [K in keyof Query]: K extends string
@@ -106,6 +124,9 @@ type DatabaseModelWithQuerySort<
   __update: (id: string, data: Partial<Doc>) => Promise<Doc>;
   __remove: (id: string) => Promise<Doc>;
   __removeMany: (query: _QueryOfDoc) => Promise<UpdateResult>;
+  __removeOne: (query: _QueryOfDoc) => Promise<UpdateResult>;
+  __updateMany: (query: _QueryOfDoc, update: DocumentUpdateInput<Doc>) => Promise<UpdateResult>;
+  __updateOne: (query: _QueryOfDoc, update: DocumentUpdateInput<Doc>) => Promise<UpdateResult>;
   __list(query: _QueryOfDoc, queryOption?: _ListQueryOption): Promise<Doc[]>;
   __listIds(query: _QueryOfDoc, queryOption?: _ListQueryOption): Promise<string[]>;
   __find(query: _QueryOfDoc, queryOption?: _FindQueryOption): Promise<Doc | null>;

package/document/filterMeta.ts

@@ -98,6 +98,13 @@ export const fillMissingFilterArgs = (filterInfo: FilterInfo, args: unknown[]) =
   return [...args, ...Array(filterInfo.args.length - args.length).fill(undefined)];
 };
 
+export const assertFilterFitsCrud = (refName: string, queryKey: string, className: string) => {
+  if (queryKey.toLowerCase() !== refName.toLowerCase()) return;
+  throw new Error(
+    `Filter "${queryKey}" on "${refName}" generates remove${className}/update${className}, which are the generated CRUD methods; rename the filter`,
+  );
+};
+
 export type BaseFilterSortKey = "latest" | "oldest" | "relevance";
 export type BaseFilterQueryKey = "any";
 export type BaseFilterKey = BaseFilterSortKey | BaseFilterQueryKey;

package/document/index.ts

@@ -7,5 +7,6 @@ export * from "./documentSchema";
 export * from "./filterMeta";
 export * from "./into";
 export * from "./loaderInfo";
+export * from "./noDocumentError";
 export * from "./schema";
 export * from "./types";

package/document/into.ts

@@ -77,16 +77,22 @@ export type Mdl<
   find(query: _RawQuery, projection?: _Projection): FindManyChain<Doc>;
   findOne(query: _RawQuery, projection?: _Projection): FindOneChain<Doc>;
   findById(id: string | undefined, projection?: _Projection): Promise<Doc | null>;
-  countDocuments(query: _RawQuery): Promise<number>;
+  count(query: _RawQuery): Promise<number>;
   exists(query: _RawQuery): Promise<string | null>;
+
   updateOne(
     query: _RawQuery,
     update: DocumentUpdateInput<_RawDoc>,
     options?: DocumentUpdateOptions,
   ): Promise<UpdateResult>;
   updateMany(query: _RawQuery, update: DocumentUpdateInput<_RawDoc>): Promise<UpdateResult>;
+  removeOne(query: _RawQuery): Promise<UpdateResult>;
   removeMany(query: _RawQuery): Promise<UpdateResult>;
+  updateById(id: string, update: DocumentUpdateInput<_RawDoc>, options?: DocumentUpdateOptions): Promise<UpdateResult>;
+  removeById(id: string): Promise<UpdateResult>;
   bulkWrite(operations: BulkWriteOperation<Raw, _RawDoc, _RawQuery>[]): Promise<UpdateResult>;
+  /** @deprecated Renamed to `count`. */
+  countDocuments(query: _RawQuery): Promise<number>;
 };
 
 interface IntoConstantModel<T extends string, _CapitalizedRefName extends string, Raw, Insight> {

package/document/noDocumentError.ts

@@ -0,0 +1,12 @@
+/**
+ * A `pick` or a `get` that matched nothing. Typed so a caller can tell "you asked for something that is not
+ * there" from "we broke" — an agent-facing transport in particular must not log a stack and answer "the server
+ * failed" every time a model guesses an id.
+ *
+ * The message is unchanged from the bare `Error` this replaces, because callers already match on it, and the
+ * `statusCode` does not reach the HTTP layer: `isExceptionLike` wants a `toJSON` too, so a missing document
+ * stays a 500 there until someone decides framework-wide that it should be a 404.
+ */
+export class NoDocumentError extends Error {
+  readonly statusCode = 404;
+}

package/fetch/agentTurn.ts

@@ -0,0 +1,19 @@
+import { Any, enumOf } from "akanjs/base";
+import { ConstantRegistry, via } from "akanjs/constant";
+
+export class AgentStop extends enumOf("agentStop", ["end", "toolUse"] as const) {}
+
+export class AgentTurn extends via((field) => ({
+  text: field(String, { default: "" }), // the assistant's words; empty when the turn is only tool calls
+  toolCalls: field([Any]), // { id, name, args } per call — args carries the tool's own schema, not a model's
+  stop: field(AgentStop, { default: "end" }),
+})) {
+  isToolUse() {
+    return this.stop === "toolUse";
+  }
+}
+
+export const agentTurnConstant = ConstantRegistry.buildScalar("agentTurn" as const, AgentTurn, {
+  AgentTurn,
+  AgentStop,
+});

package/fetch/client/fetchClient.ts

@@ -10,6 +10,7 @@ import type {
   SerializedSlice,
   ServiceSignal,
 } from "akanjs/signal";
+import { agentTurnConstant } from "../agentTurn";
 import type { ClientSignal, FetchClientType, FetchSignalInput, MergeAllFetchTypes, SliceMeta } from "../fetchType";
 import { memoizeRequestQuery, cookies as requestCookies, headers as requestHeaders } from "../requestStorage";
 import type { GetSliceMetaObjFromDatabaseSignals } from "../types";
@@ -37,6 +38,29 @@ export type FetchProxy<
   FetchClient &
   FetchType & { slice: SliceMetaObj; instance: FetchClient; _FetchType: FetchType; _SliceMetaObj: SliceMetaObj };
 
+interface SharedClientState {
+  proxy: FetchProxy | null;
+  origin: string | null;
+}
+
+const SHARED_CLIENT_KEY = Symbol.for("akanjs.fetch.sharedClient");
+const globalWithSharedClient = globalThis as typeof globalThis & { [SHARED_CLIENT_KEY]?: SharedClientState };
+const sharedClientState: SharedClientState = globalWithSharedClient[SHARED_CLIENT_KEY] ?? { proxy: null, origin: null };
+globalWithSharedClient[SHARED_CLIENT_KEY] = sharedClientState;
+
+interface SharedSignalRegistry {
+  signal: { [key: string]: SerializedSignal };
+  version: number;
+}
+
+const SHARED_SIGNAL_KEY = Symbol.for("akanjs.fetch.sharedSignalRegistry");
+const globalWithSharedSignal = globalThis as typeof globalThis & { [SHARED_SIGNAL_KEY]?: SharedSignalRegistry };
+const sharedSignalRegistry: SharedSignalRegistry = globalWithSharedSignal[SHARED_SIGNAL_KEY] ?? {
+  signal: {},
+  version: 0,
+};
+globalWithSharedSignal[SHARED_SIGNAL_KEY] = sharedSignalRegistry;
+
 type ClientSignalMap<SigType extends { fetch: any }> = {
   [K in keyof SigType as SigType[K] extends DatabaseSignal<any, any, any, any>
     ? K
@@ -47,8 +71,9 @@ type ClientSignalMap<SigType extends { fetch: any }> = {
 
 /** Runtime fetch client that registers serialized Akan signals as HTTP/WebSocket methods. */
 export class FetchClient {
-  static #sharedSerializedSignal: { [key: string]: SerializedSignal } = {};
-  static #sharedRegistryVersion = 0;
+  static {
+    ConstantRegistry.setScalar(agentTurnConstant.refName, agentTurnConstant);
+  }
   readonly logger = new Logger("FetchClient");
   readonly origin: string;
   readonly http: HttpClient;
@@ -76,9 +101,31 @@ export class FetchClient {
     this.handler = this.#makeHandlerProxy();
     this.applySignal(serializedSignal);
   }
+  /**
+   * Every signal any client in this process has applied, which is the whole callable surface of the app.
+   *
+   * A copy, because this is the registry each client merges its own signals into and a reader that mutated it
+   * would change what the next client applies. Read by the agent catalogue, which needs the argument schemas.
+   */
+  static get sharedSerializedSignal(): { [key: string]: SerializedSignal } {
+    return { ...sharedSignalRegistry.signal };
+  }
   static resetSharedRegistry() {
-    FetchClient.#sharedSerializedSignal = {};
-    FetchClient.#sharedRegistryVersion++;
+    sharedSignalRegistry.signal = {};
+    sharedSignalRegistry.version++;
+  }
+  static resetSharedClient() {
+    sharedClientState.proxy = null;
+    sharedClientState.origin = null;
+  }
+  static #resolveSharedClientProxy(origin: string, Err?: ErrorConstructor) {
+    if (typeof window === "undefined") return null;
+    
+    if (sharedClientState.proxy) return sharedClientState.origin === origin ? sharedClientState.proxy : null;
+    const proxy = FetchClient.#makeProxy<unknown, Record<string, SliceMeta>>(new FetchClient(origin, {}, {}, Err));
+    sharedClientState.proxy = proxy;
+    sharedClientState.origin = origin;
+    return proxy;
   }
   static #mergeSerializedSignalInto(
     serializedSignal: { [key: string]: SerializedSignal },
@@ -115,9 +162,9 @@ export class FetchClient {
   applySignal(serializedSignal: { [key: string]: SerializedSignal }, { share = true }: { share?: boolean } = {}) {
     if (share && Object.keys(serializedSignal).length > 0) {
       for (const [refName, signal] of Object.entries(serializedSignal))
-        FetchClient.#mergeSerializedSignalInto(FetchClient.#sharedSerializedSignal, refName, signal);
-      FetchClient.#sharedRegistryVersion++;
-      this.#sharedRegistryAppliedVersion = FetchClient.#sharedRegistryVersion;
+        FetchClient.#mergeSerializedSignalInto(sharedSignalRegistry.signal, refName, signal);
+      sharedSignalRegistry.version++;
+      this.#sharedRegistryAppliedVersion = sharedSignalRegistry.version;
     }
     for (const [refName, signal] of Object.entries(serializedSignal))
       FetchClient.#mergeSerializedSignalInto(this.serializedSignal, refName, signal);
@@ -151,9 +198,9 @@ export class FetchClient {
     });
   }
   #syncSharedRegistry() {
-    if (this.#sharedRegistryAppliedVersion === FetchClient.#sharedRegistryVersion) return;
-    this.applySignal(FetchClient.#sharedSerializedSignal, { share: false });
-    this.#sharedRegistryAppliedVersion = FetchClient.#sharedRegistryVersion;
+    if (this.#sharedRegistryAppliedVersion === sharedSignalRegistry.version) return;
+    this.applySignal(sharedSignalRegistry.signal, { share: false });
+    this.#sharedRegistryAppliedVersion = sharedSignalRegistry.version;
   }
   #getOrCreateHandler(key: string): FetchHandler | undefined {
     const current = this.#handlerStore[key];
@@ -223,6 +270,8 @@ export class FetchClient {
     const parseReturn = this.#makeReturnParser(endpoint.returns);
     const { bodyArgs, uploadArgs } = FetchClient.classifyHttpArgs(endpoint.args);
     switch (endpoint.type) {
+      
+      case "prompt":
       case "query": {
         const queryFn = async (...argData: unknown[]) => {
           const args = argData.slice(0, argLength);
@@ -263,6 +312,7 @@ export class FetchClient {
   }
   #registerEndpoint(key: string, endpoint: SerializedEndpoint, prefix?: string) {
     switch (endpoint.type) {
+      case "prompt":
       case "query": {
         this.#setHandlerFactory(key, () => this.#makeHttpFn(key, endpoint, prefix));
         return;
@@ -684,9 +734,16 @@ export class FetchClient {
         });
       }
     });
-    const instance = new FetchClient(getEnv().serverHttpUri, handler, serializedSignal);
+    const instance = new FetchClient(FetchClient.#originFromEnv(), handler, serializedSignal);
     return FetchClient.#makeProxy<MergeAllFetchTypes<Signals>, GetSliceMetaObjFromDatabaseSignals<Signals>>(instance);
   }
+  static #originFromEnv() {
+    try {
+      return getEnv().serverHttpUri;
+    } catch {
+      return "";
+    }
+  }
   static build<SigType extends { fetch: any }>(
     constant: object,
     serializedSignal: { [key: string]: SerializedSignal },
@@ -700,10 +757,11 @@ export class FetchClient {
     sig: ClientSignalMap<SigType>;
     fetch: SigType["fetch"];
   } {
-    if (base) base.instance.applySignal(serializedSignal);
+    const shared = base ?? FetchClient.#resolveSharedClientProxy(origin, Err);
+    if (shared) shared.instance.applySignal(serializedSignal);
     if (base && Err) base.instance.setErrorConstructor(Err);
     const proxy =
-      base ??
+      shared ??
       FetchClient.#makeProxy<unknown, Record<string, SliceMeta>>(new FetchClient(origin, {}, serializedSignal, Err));
     if (connect) proxy.instance.connect();
     const sig = {} as any;

package/fetch/client/wsClient.ts

@@ -40,6 +40,8 @@ export class WsClient {
   #roomSubscribeMap = new Map<string, SubscribeOption>();
   #listenerMap = new Map<string, Set<Listener>>();
   #destroyed = false;
+  #connectRequested = false;
+  #unconnectedWarnTimers = new Map<string, ReturnType<typeof setTimeout>>();
   #jwt: string | null = null;
   connected = false;
 
@@ -70,6 +72,7 @@ export class WsClient {
   }
 
   connect() {
+    this.#connectRequested = true;
     if (this.#ws && this.#ws.readyState !== WebSocket.CLOSED) return;
     this.logger.debug(`Connecting to ${this.url}`);
     this.#destroyed = false;
@@ -187,10 +190,13 @@ export class WsClient {
   destroy() {
     this.logger.debug(`WebSocket destroying`);
     this.#destroyed = true;
+    this.#connectRequested = false;
     if (this.#reconnectTimer) {
       clearTimeout(this.#reconnectTimer);
       this.#reconnectTimer = null;
     }
+    for (const timer of this.#unconnectedWarnTimers.values()) clearTimeout(timer);
+    this.#unconnectedWarnTimers.clear();
     this.#ws?.close();
     this.#ws = null;
   }
@@ -231,9 +237,18 @@ export class WsClient {
   }
   #warnNotConnected(action: "emit" | "subscribe", key: string) {
     console.warn(
-      `[akanjs] WebSocket is not connected. Call fetch.instance.connect() or enable root layout "wsConnect" before ${action} "${key}".`,
+      `[akanjs] WebSocket is not connected. Call fetch.instance.connect(), or drop the root layout "wsConnect = false", before ${action} "${key}".`,
     );
   }
+  #warnUnconnectedSubscribe(key: string) {
+    if (this.#connectRequested || this.#unconnectedWarnTimers.has(key)) return;
+    const timer = setTimeout(() => {
+      this.#unconnectedWarnTimers.delete(key);
+      if (this.#connectRequested || this.#destroyed) return;
+      this.#warnNotConnected("subscribe", key);
+    }, 0);
+    this.#unconnectedWarnTimers.set(key, timer);
+  }
   emit(key: string, data: WsRequestPayload) {
     if (this.#ws?.readyState !== WebSocket.OPEN) {
       this.logger.warn("WebSocket not connected");
@@ -246,7 +261,7 @@ export class WsClient {
   }
   subscribe(option: { key: string; data: unknown[]; handleEvent: (data: unknown) => void }) {
     const roomId = WsClient.makeRoomId(option.key, option.data);
-    if (!this.#ws) this.#warnNotConnected("subscribe", option.key);
+    if (!this.#ws) this.#warnUnconnectedSubscribe(option.key);
     if (!this.#roomSubscribeMap.has(roomId)) {
       this.#roomSubscribeMap.set(roomId, { key: option.key, data: option.data, listener: new Set() });
       if (this.#ws?.readyState === WebSocket.OPEN) {

package/fetch/fetchType/endpointFetch.type.ts

@@ -7,6 +7,7 @@ import type {
   EndpInfoReqType,
   EndpointCls,
   EndpointInfo,
+  PromptMessage,
   SlceCnstFull,
   SlceCnstInsight,
   SlceCnstLight,
@@ -40,6 +41,9 @@ type QueryOrMutationFetchFn<E, SlceCls extends SliceCls | never> = (
   ...args: [...EndpInfoArgs<E>, fetchPolicy?: FetchPolicy]
 ) => Promise<EndpInfoReturns<E, SlceCls>>;
 
+/** Typed off `PromptResult` rather than the endpoint's return ref, which is the `Any` carrier a prompt rides on. */
+type PromptFetchFn<E> = (...args: [...EndpInfoArgs<E>, fetchPolicy?: FetchPolicy]) => Promise<PromptMessage[]>;
+
 type MessageEmitFn<E> = (...args: EndpInfoArgs<E>) => void;
 
 type MessageListenFn<E, SlceCls extends SliceCls | never> = (
@@ -58,12 +62,14 @@ type PubsubSubscribeFn<E, SlceCls extends SliceCls | never> = (
 type PrimaryFetchFn<E, SlceCls extends SliceCls | never> =
   EndpInfoReqType<E> extends "query" | "mutation"
     ? QueryOrMutationFetchFn<E, SlceCls>
-    : EndpInfoReqType<E> extends "message"
-      ? MessageEmitFn<E>
-      : never;
+    : EndpInfoReqType<E> extends "prompt"
+      ? PromptFetchFn<E>
+      : EndpInfoReqType<E> extends "message"
+        ? MessageEmitFn<E>
+        : never;
 
 type PrimaryFetchType<EInfoObj extends { [key: string]: EndpointInfo }, SlceCls extends SliceCls | never> = {
-  [K in keyof EInfoObj as EndpInfoReqType<EInfoObj[K]> extends "query" | "mutation" | "message"
+  [K in keyof EInfoObj as EndpInfoReqType<EInfoObj[K]> extends "query" | "mutation" | "prompt" | "message"
     ? K
     : never]: PrimaryFetchFn<EInfoObj[K], SlceCls>;
 };

package/fetch/index.ts

@@ -1,3 +1,4 @@
+export * from "./agentTurn";
 export * from "./client";
 export * from "./fetchType";
 export * from "./requestStorage";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akanjs",
-  "version": "3.0.0-alpha.2",
+  "version": "3.0.0-alpha.21",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {
@@ -180,7 +180,6 @@
   "dependencies": {
     "dayjs": "^1.11.20",
     "immer": "^11.1.8",
-    "sharp": "^0.34.5",
     "tailwind-merge": "^3.3.1",
     "tailwind-variants": "^3.3.0"
   },
@@ -202,6 +201,7 @@
     "@capacitor/preferences": "^8.0.1",
     "@capacitor/push-notifications": "^8.1.1",
     "@capgo/capacitor-updater": "^8.46.1",
+    "@happy-dom/global-registrator": "^20.11.2",
     "@libsql/client": "^0.17.3",
     "@playwright/test": "^1.60.0",
     "@react-spring/web": "^10.1.0",
@@ -210,8 +210,8 @@
     "capacitor-plugin-safe-area": "^5.0.0",
     "chance": "^1.1.13",
     "cordova-plugin-purchase": "^13.16.0",
-    "croner": "^10.0.1",
     "firebase": "^12.13.0",
+    "happy-dom": "^20.11.2",
     "ioredis": "^5.10.1",
     "mermaid": "^11.15.0",
     "postgres": "^3.4.9",
@@ -225,7 +225,6 @@
     "react-simple-pull-to-refresh": "^1.3.4",
     "react-spring": "^10.0.4",
     "scheduler": "^0.27.0",
-    "sharp": "^0.34.5",
     "tailwind-scrollbar": "^4.0.2",
     "typescript": "^6.0.3"
   },
@@ -281,6 +280,9 @@
     "@capgo/capacitor-updater": {
       "optional": true
     },
+    "@happy-dom/global-registrator": {
+      "optional": true
+    },
     "@libsql/client": {
       "optional": true
     },
@@ -305,10 +307,10 @@
     "cordova-plugin-purchase": {
       "optional": true
     },
-    "croner": {
+    "firebase": {
       "optional": true
     },
-    "firebase": {
+    "happy-dom": {
       "optional": true
     },
     "ioredis": {
@@ -358,14 +360,14 @@
     }
   },
   "devDependencies": {
-    "@biomejs/biome": "2.4.4",
-    "@types/bun": "^1.3.14"
+    "@biomejs/biome": "2.5.8",
+    "@types/bun": "^1.4.0"
   },
   "bun": {
     "platform": "bun"
   },
   "engines": {
-    "bun": ">=1.3.13"
+    "bun": ">=1.4.0"
   },
   "main": "./index.ts"
 }