akanjs 3.0.0-beta.2 → 3.0.0-beta.20

package/constant/textFieldPaths.ts

@@ -17,7 +17,7 @@ export class TextFieldPaths extends TextFieldPathSet {
         this.#assertIndexable(key, field.text, field);
         this[field.text].add(key);
       }
-
+      
       if (field.isClass && field.isScalar) this.#mergeChild(key, field);
     }
     return this;
@@ -34,7 +34,6 @@ export class TextFieldPaths extends TextFieldPathSet {
   }
 
   #assertReachable(path: string, parent: ConstantField) {
-
     const fix = `Drop the text role on "${path}", or leave the parent unmasked.`;
     if (parent.fieldType === "secret") throw new Error(`Text field "${path}" is under a secret field. ${fix}`);
     if (parent.fieldType === "hidden") throw new Error(`Text field "${path}" is under a hidden field. ${fix}`);
@@ -43,7 +42,7 @@ export class TextFieldPaths extends TextFieldPathSet {
   }
 
   #assertIndexable(key: string, role: TextFieldRole, field: ConstantField) {
-
+    
     const masked = `The search mirror stores plaintext. Drop the text role on "${key}", or make the field plain.`;
     if (field.fieldType === "secret")
       throw new Error(`Text field "${key}" is secret and must not be indexed. ${masked}`);

package/constant/types.ts

@@ -109,12 +109,8 @@ export interface ProtoPatch {
 
 export const DEFAULT_PAGE_SIZE = 20;
 /**
- * The most rows one list request may take, whatever it asks for.
- *
- * A page size arrives from the client, so without a ceiling anyone who may read one page may read the whole
- * table in a single request — and `LIMIT 0` or `LIMIT -1` reaches SQLite as "no limit at all", so the two ways
- * of asking for nothing were the two ways of asking for everything. `resolvePageLimit` is the one place that
- * decides; a caller wanting more pages asks for more pages.
+ * The most rows one list request may take: the page size is client input, so without a ceiling one request could
+ * read the whole table, and `LIMIT 0`/`-1` reaches SQLite as no limit at all.
  */
 export const MAX_PAGE_SIZE = 500;
 

package/constant/via.ts

@@ -57,12 +57,11 @@ type ResolvedSchema<ResolveField extends (resolve: FieldResolver) => FieldInfoOb
 type ResolvedFieldObject<ResolveField extends (resolve: FieldResolver) => FieldInfoObject> =
   FieldInfoObjectToFieldObject<ReturnType<ResolveField>>;
 
-const objectModelOf = <T>(
-  inputRef: ConstantCls<T>,
-  fieldMap: FieldInfoObject,
-): ConstantCls<WithBase<T>, FieldObject, WithBase<T>, FieldObject, "object"> => {
-  const fieldObject = Object.fromEntries(Object.entries(fieldMap).map(([key, field]) => [key, field.toField()]));
-  const applyFieldObject = { ...inputRef[FIELD_META], ...fieldObject };
+const toFieldObject = (fieldMap: FieldInfoObject): FieldObject =>
+  Object.fromEntries(Object.entries(fieldMap).map(([key, field]) => [key, field.toField()]));
+
+const objectModelOf = <T>(inputRef: ConstantCls<T>, fieldMap: FieldInfoObject) => {
+  const applyFieldObject = { ...inputRef[FIELD_META], ...toFieldObject(fieldMap) };
   const field = Object.assign(ConstantField.getBaseModelField(), applyFieldObject);
   const baseObjectModelRef = getBaseConstantClass(field);
   applyConstantStatics(baseObjectModelRef, applyFieldObject);
@@ -75,16 +74,10 @@ const lightModelOf = <T, F extends keyof OmitBase<T>>(
   fields: readonly F[],
   fieldMap: FieldInfoObject,
   ...libLightModelRefs: ConstantCls[]
-): ConstantCls<
-  Pick<OmitBase<T>, F> & BaseObject,
-  FieldObject,
-  Pick<OmitBase<T>, F> & BaseObject,
-  FieldObject,
-  "light"
-> => {
+) => {
   const libLightModelRef = libLightModelRefs.at(0);
   const applyFieldObject = {
-    ...Object.fromEntries(Object.entries(fieldMap).map(([key, field]) => [key, field.toField()])),
+    ...toFieldObject(fieldMap),
     ...Object.fromEntries(fields.map((field) => [field, objectRef[FIELD_META][field as string] as ConstantField])),
   };
   const field = Object.assign(libLightModelRef?.[FIELD_META] ?? ConstantField.getBaseModelField(), applyFieldObject);
@@ -106,30 +99,20 @@ const fullModelOf = <A, B = undefined>(
   lightRef: ConstantCls<B>,
   fieldMap: FieldInfoObject,
   ...libFullModelRefs: ConstantCls[]
-): ConstantCls<Merge<A, B>, FieldObject, Merge<A, B>, FieldObject, "full"> => {
+) => {
   const fullRef = libFullModelRefs.at(0) ?? getBaseConstantClass(ConstantField.getBaseModelField());
-  const applyFieldObject = {
-    ...objectRef[FIELD_META],
-    ...lightRef[FIELD_META],
-    ...Object.fromEntries(Object.entries(fieldMap).map(([key, field]) => [key, field.toField()])),
-  };
+  const applyFieldObject = { ...objectRef[FIELD_META], ...lightRef[FIELD_META], ...toFieldObject(fieldMap) };
   Object.assign(fullRef[FIELD_META], applyFieldObject);
   applyMixins(fullRef, [objectRef, lightRef, ...libFullModelRefs]);
-  libFullModelRefs.forEach((libFullModelRef) => {
-    applyMixins(libFullModelRef, [objectRef, lightRef]);
-  });
-
+  for (const libFullModelRef of libFullModelRefs) applyMixins(libFullModelRef, [objectRef, lightRef]);
   applyConstantStatics(fullRef, applyFieldObject);
   fullRef.modelType = "full";
   return fullRef as unknown as ConstantCls<Merge<A, B>, FieldObject, Merge<A, B>, FieldObject, "full">;
 };
 
-const extendModelInputs = <T extends ConstantCls[]>(
-  fieldMap: FieldInfoObject,
-  ...libInputModelRefs: T
-): ConstantCls<MergeOwnSchemas<T>, FieldObject, MergeOwnSchemas<T>, FieldObject, "input"> => {
+const extendModelInputs = <T extends ConstantCls[]>(fieldMap: FieldInfoObject, ...libInputModelRefs: T) => {
   const baseInputModelRef = libInputModelRefs.at(0);
-  const applyFieldObject = Object.fromEntries(Object.entries(fieldMap).map(([key, field]) => [key, field.toField()]));
+  const applyFieldObject = toFieldObject(fieldMap);
   const fieldObject = Object.assign(baseInputModelRef?.[FIELD_META] ?? {}, applyFieldObject);
   const baseInputRef = getBaseConstantClass(fieldObject);
   applyConstantStatics(baseInputRef, applyFieldObject);
@@ -146,18 +129,9 @@ const extendModelObjects = <Input, ObjectModels extends ConstantCls[]>(
   inputRef: ConstantCls<Input>,
   fieldMap: FieldInfoObject,
   ...libObjectModelRefs: ObjectModels
-): ConstantCls<
-  MergeWithOwnSchemas<ObjectModels, Input & object>,
-  FieldObject,
-  MergeWithOwnSchemas<ObjectModels, Input & object>,
-  FieldObject,
-  "object"
-> => {
+) => {
   const baseObjectModelRef = libObjectModelRefs.at(0);
-  const applyFieldObject = {
-    ...inputRef[FIELD_META],
-    ...Object.fromEntries(Object.entries(fieldMap).map(([key, field]) => [key, field.toField()])),
-  };
+  const applyFieldObject = { ...inputRef[FIELD_META], ...toFieldObject(fieldMap) };
   const field = Object.assign(baseObjectModelRef?.[FIELD_META] ?? {}, applyFieldObject);
   const baseInputRef = getBaseConstantClass(field, "object");
   applyConstantStatics(baseInputRef, applyFieldObject);
@@ -173,15 +147,14 @@ const extendModelObjects = <Input, ObjectModels extends ConstantCls[]>(
 const extendModelInsights = <InsightModels extends ConstantCls[]>(
   fieldMap: FieldInfoObject,
   ...insightModelRefs: InsightModels
-): ConstantCls<MergeOwnSchemas<InsightModels>, FieldObject, MergeOwnSchemas<InsightModels>, FieldObject, "insight"> => {
+) => {
   const baseInsightModelRef = insightModelRefs.at(0);
-  const applyFieldObject = Object.fromEntries(Object.entries(fieldMap).map(([key, field]) => [key, field.toField()]));
+  const applyFieldObject = toFieldObject(fieldMap);
   const field = Object.assign(
     baseInsightModelRef?.[FIELD_META] ?? ConstantField.getBaseInsightField(),
     applyFieldObject,
   );
   const baseInsightRef = getBaseConstantClass(field, "insight");
-
   applyConstantStatics(baseInsightRef, applyFieldObject);
   return baseInsightRef as unknown as ConstantCls<
     MergeOwnSchemas<InsightModels>,
@@ -217,16 +190,8 @@ const getBaseConstantClass = (field: FieldObject, modelType: ConstantType = "sca
   return BaseConstant as unknown as ConstantCls;
 };
 
-const makeBaseScalar = <FieldMap extends FieldInfoObject>(
-  fieldMap: FieldMap,
-): ConstantCls<
-  ExtractFieldInfoObject<FieldMap>,
-  FieldObject,
-  ExtractFieldInfoObject<FieldMap>,
-  FieldObject,
-  "scalar"
-> => {
-  const fieldObject = Object.fromEntries(Object.entries(fieldMap).map(([key, field]) => [key, field.toField()]));
+const makeBaseScalar = <FieldMap extends FieldInfoObject>(fieldMap: FieldMap) => {
+  const fieldObject = toFieldObject(fieldMap);
   const baseScalarRef = getBaseConstantClass(fieldObject, "scalar");
   applyConstantStatics(baseScalarRef, fieldObject);
   return baseScalarRef as unknown as ConstantCls<
@@ -427,7 +392,7 @@ declare global {
 }
 
 const applyConstantStatics = <Model>(model: ConstantCls<Model>, fieldMap: FieldObject): ConstantCls<Model> => {
-
+  
   let defaultValue: DefaultOf<Model> | undefined;
   Object.assign(model, {
     purify: makePurify(model),
@@ -449,14 +414,13 @@ const applyConstantStatics = <Model>(model: ConstantCls<Model>, fieldMap: FieldO
   });
   model.text.collect(fieldMap);
   model.cascade.collect(fieldMap);
-
+  
   for (const [key, field] of Object.entries(model[FIELD_META]))
     if (isDateSlotField(field.getProps())) Object.defineProperty(model.prototype, key, dateAccessorOf(key));
   HydrationPlan.reset(model);
   return model as unknown as ConstantCls<Model>;
 };
 
-/** Builds Akan constant models such as scalar, input, object, light, full, and insight classes. */
 export function via<
   Obj extends BaseObject,
   ObjFieldObj extends FieldObject,
@@ -552,7 +516,6 @@ export function via(
   thirdRefOrResolveField?: Cls | ((resolve: FieldResolver) => FieldInfoObject),
   ...extendRefs: Cls[]
 ): any {
-  
   if (
     !firstRefOrBuildField.prototype ||
     !(firstRefOrBuildField as Cls<unknown, { modelType?: ConstantType }>).modelType
@@ -567,7 +530,6 @@ export function via(
     if (!secondRefOrFieldsOrBuildField) return makeBaseScalar(fieldMap);
     else return extendModelInputs(fieldMap, ...extendInputRefs);
   }
-  
   if (Array.isArray(secondRefOrFieldsOrBuildField)) {
     const resolveField = thirdRefOrResolveField as (resolve: FieldResolver) => FieldInfoObject;
     const fieldMap = resolveField(resolve);
@@ -585,7 +547,6 @@ export function via(
   ) {
     const buildField = secondRefOrFieldsOrBuildField as (builder: FieldBuilder) => FieldInfoObject;
     const fieldMap = buildField(field);
-    
     if (ConstantRegistry.isScalar(firstRefOrBuildField as Cls<unknown, { modelType: ConstantType }>)) {
       if (!thirdRefOrResolveField) return objectModelOf(firstRefOrBuildField as ConstantCls, fieldMap);
       else
@@ -596,7 +557,6 @@ export function via(
           ...(extendRefs as ConstantCls[]),
         );
     }
-    
     if (ConstantRegistry.isFull(firstRefOrBuildField as Cls<unknown, { modelType: ConstantType }>)) {
       const extendInsightRefs = [
         ...(thirdRefOrResolveField ? [thirdRefOrResolveField as Cls] : []),

package/dictionary/DictionaryLookup.ts

@@ -2,13 +2,7 @@ import { pathGetLoose } from "akanjs/common";
 import { DictionaryRegistry } from "./dictionaryRegistry";
 import type { DictionaryNode } from "./trans";
 
-/**
- * Reads translated text out of the merged dictionary tree by dotted key (`user.signal.createUser.arg.data.desc`).
- *
- * Unlike `translate`, a missing key resolves to `undefined` rather than echoing the key back: callers here are
- * document generators (OpenAPI, MCP) that must omit an absent description instead of emitting `"user.signal.…"`
- * as if it were prose. The merged root is snapshotted once per instance, so build a fresh one per document.
- */
+/** A missing key reads `undefined` (unlike `translate`, which echoes it); the root is snapshotted per instance. */
 export class DictionaryLookup {
   readonly language: string;
   readonly #models: Record<string, DictionaryNode>;

package/dictionary/agent.dictionary.ts

@@ -1,6 +1,6 @@
-import type { AgentEndpoint } from "akanjs/signal";
+import type { AgentEndpoint, AgentStop, AgentTurn } from "akanjs/signal";
 
-import { serviceDictionary } from "./dictInfo";
+import { scalarDictionary, serviceDictionary } from "./dictInfo";
 
 export const agentDictionary = serviceDictionary(["en", "ko"])
   .endpoint<AgentEndpoint>((fn) => ({
@@ -24,16 +24,48 @@ export const agentDictionary = serviceDictionary(["en", "ko"])
       "The agent is unavailable — this app has no language model configured",
       "에이전트를 사용할 수 없습니다. 이 앱에 언어 모델이 설정되어 있지 않습니다",
     ],
-    deepseekRequestFailed: [
-      "DeepSeek refused this turn with status {status}. Reason: {reason}",
-      "DeepSeek가 이번 턴을 거절했습니다 (status {status}). 사유: {reason}",
+    
+    llmRequestFailed: [
+      "{provider} refused this turn with status {status}. Reason: {reason}",
+      "{provider}가 이번 턴을 거절했습니다 (status {status}). 사유: {reason}",
     ],
-    openaiRequestFailed: [
-      "OpenAI refused this turn with status {status}. Reason: {reason}",
-      "OpenAI가 이번 턴을 거절했습니다 (status {status}). 사유: {reason}",
+    
+    contextOverflow: [
+      "This conversation no longer fits the model's context window at {provider}. Use /compact to summarize it, or /new to start over",
+      "대화가 {provider} 모델의 컨텍스트 창을 넘었습니다. /compact로 요약하거나 /new로 새로 시작할 수 있습니다.",
     ],
-    anthropicRequestFailed: [
-      "Anthropic refused this turn with status {status}. Reason: {reason}",
-      "Anthropic이 이번 턴을 거절했습니다 (status {status}). 사유: {reason}",
+    quotaExceeded: [
+      "The agent's usage limit for this account has been reached",
+      "이 계정의 에이전트 사용 한도에 도달했습니다.",
     ],
   });
+
+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, toolUse when tool results are awaited, or length when the provider cut it off",
+      "턴이 끝난 이유 — end, 툴 결과를 기다리는 toolUse, 프로바이더가 잘라낸 length",
+    ]),
+  }))
+  .enum<AgentStop>("agentStop", (t) => ({
+    end: t(["End", "종료"]).desc(["The final answer", "최종 응답"]),
+    toolUse: t(["Tool Use", "툴 사용"]).desc(["The model awaits tool results", "모델이 툴 결과를 기다린다"]),
+    length: t(["Length", "길이 초과"]).desc([
+      "The provider's answer ceiling cut the turn off, so it is incomplete",
+      "프로바이더의 응답 상한에 걸려 턴이 잘렸다. 미완성이다",
+    ]),
+  }));

package/dictionary/base.dictionary.ts

@@ -75,12 +75,18 @@ export const baseDictionary = serviceDictionary(["en", "ko"])
     agentPlaceholder: ["Message the agent...", "에이전트에게 메시지..."],
     agentClear: ["Clear conversation", "대화 비우기"],
     agentQuestion: ["The agent needs your decision", "에이전트가 결정을 요청합니다"],
+    agentToolCard: ["The agent needs you to fill this in", "에이전트가 입력을 요청합니다"],
     agentAnswer: ["Type your answer...", "답변을 입력하세요..."],
     agentListen: ["Speak to the agent", "에이전트에게 말하기"],
     agentVoiceFailed: ["The microphone could not be used.", "마이크를 사용할 수 없습니다."],
     agentAttach: ["Attach a file", "파일 첨부"],
     agentAttachRemove: ["Remove attachment", "첨부 제거"],
     agentAttachReading: ["Reading…", "읽는 중…"],
+    agentReferenceRemove: ["Remove reference", "참조 제거"],
+    agentReferenceFailed: [
+      "{label} could not be read, so the agent has only its name.",
+      "{label}을(를) 읽지 못해 이름만 전달됩니다.",
+    ],
     agentAttachTooLarge: ["{name} is too large to attach.", "{name}은(는) 용량이 너무 커서 첨부할 수 없습니다."],
     agentAttachUnsupported: ["{name} cannot be attached here.", "{name}은(는) 여기에 첨부할 수 없습니다."],
     agentAttachDuplicate: ["{name} is already attached.", "{name}은(는) 이미 첨부되어 있습니다."],
@@ -103,6 +109,11 @@ export const baseDictionary = serviceDictionary(["en", "ko"])
     agentToolRunning: ["Running", "실행 중"],
     agentToolResult: ["Show what this tool returned", "이 툴이 반환한 값 보기"],
     agentTokens: ["~{count} tokens", "약 {count} 토큰"],
+    agentTokensOf: ["~{count} / {limit} tokens", "약 {count} / {limit} 토큰"],
+    agentCompactsAt: [
+      "The conversation summarizes itself past {limit} tokens",
+      "{limit} 토큰을 넘으면 대화를 스스로 요약합니다",
+    ],
     agentSummarizing: ["Summarizing the conversation…", "대화를 요약하는 중…"],
     agentContinue: ["This is taking a while. Keep going?", "시간이 걸리고 있습니다. 계속할까요?"],
     agentKeepGoing: ["Keep going", "계속하기"],