akanjs 3.0.0-beta.9 → 3.0.0

package/constant/purify.ts

@@ -66,14 +66,12 @@ export type PurifyFuncV2<
 
 const getPurifyFn = (modelRef: Cls): ((value: unknown) => unknown) => {
   const [valueRef] = getNonArrayModel(modelRef);
-  const purifyFn = PrimitiveRegistry.has(valueRef)
+  return PrimitiveRegistry.has(valueRef)
     ? (value: unknown) => (valueRef as unknown as typeof PrimitiveScalar)._serialize(value as never)
     : (value: unknown) => value as object;
-  return purifyFn;
 };
 
 const purify = (field: FieldProps, key: string, value: unknown, self: Record<string, unknown>): unknown => {
-  
   if (
     field.nullable &&
     (value === null ||
@@ -111,13 +109,11 @@ const purify = (field: FieldProps, key: string, value: unknown, self: Record<str
     throw new Error(`Invalid Value (Failed to pass validation) / ${value} in ${key}`);
   if (!field.nullable && !value && value !== 0 && value !== false && (field.modelRef as Cls) !== Any)
     throw new Error(`Invalid Value (Nullable) in ${key} for value ${value}`);
-
-  const purifyFn = getPurifyFn(field.modelRef);
-  return purifyFn(value);
+  return getPurifyFn(field.modelRef)(value);
 };
 
-export const makePurify = <I>(modelRef: ConstantModelRef<I>): PurifyFunc<I> => {
-  const fn = ((self: Record<string, unknown>, isChild?: boolean): unknown => {
+export const makePurify = <I>(modelRef: ConstantModelRef<I>): PurifyFunc<I> =>
+  ((self: Record<string, unknown>, isChild?: boolean): unknown => {
     try {
       if (isChild && !ConstantRegistry.isScalar(modelRef)) {
         const id = self.id as string;
@@ -125,10 +121,8 @@ export const makePurify = <I>(modelRef: ConstantModelRef<I>): PurifyFunc<I> => {
         return id;
       }
       const result: Record<string, unknown> = {};
-      Object.entries(modelRef[FIELD_META]).forEach(([key, field]) => {
-        const value = self[key] as object;
-        result[key] = purify(field.getProps(), key, value, self) as object;
-      });
+      for (const [key, field] of Object.entries(modelRef[FIELD_META]))
+        result[key] = purify(field.getProps(), key, self[key], self);
       return result;
     } catch (err) {
       if (isChild) throw new Error(err as string);
@@ -136,5 +130,3 @@ export const makePurify = <I>(modelRef: ConstantModelRef<I>): PurifyFunc<I> => {
       return null;
     }
   }) as PurifyFunc<I>;
-  return fn;
-};

package/constant/serialize.ts

@@ -3,6 +3,7 @@ import {
   applyFnToArrayObjects,
   type Cls,
   type Dayjs,
+  type EnumInstance,
   FIELD_META,
   getNonArrayModel,
   ID,
@@ -10,7 +11,7 @@ import {
   type PrimitiveScalar,
 } from "akanjs/base";
 
-import type { ConstantCls, ConstantModelRef } from ".";
+import { type ConstantCls, type ConstantModelRef, ConstantRegistry, type FieldProps, withSharedInstances } from ".";
 
 export type Serialized<O> = O extends (infer V)[]
   ? Serialized<V>[]
@@ -22,12 +23,10 @@ export type Serialized<O> = O extends (infer V)[]
         ? { [K in keyof O]: Serialized<O[K]> }
         : O;
 
-const getSerializeFn = (inputRef: Cls, { optional = false }: { optional?: boolean } = {}) => {
-  const serializeFn = PrimitiveRegistry.has(inputRef)
+const getSerializeFn = (inputRef: Cls, { optional = false }: { optional?: boolean } = {}) =>
+  PrimitiveRegistry.has(inputRef)
     ? (value: unknown) => (inputRef as typeof PrimitiveScalar)._serialize(value as never, { optional })
     : (value: unknown) => value as object;
-  return serializeFn;
-};
 const serializeInput = <Input = unknown>(
   value: Input | Input[],
   inputRef: ConstantModelRef<Input> | PrimitiveScalar,
@@ -86,3 +85,81 @@ export const serialize = (
     throw new Error(`Invalid Value (Nullable) in ${argRef} for value ${value}${key ? ` in ${key}` : ""}`);
   return serializeInput(value, argRef, arrDepth, serializeType, { optional: nullable }) as object[];
 };
+
+const getDeserializeFn = (inputRef: ConstantModelRef | PrimitiveScalar) =>
+  PrimitiveRegistry.has(inputRef as Cls)
+    ? (value: unknown) => (inputRef as unknown as typeof PrimitiveScalar)._parse(value as never)
+    : (value: unknown) => value as object;
+const deserializeMap = (value: unknown, field: Pick<FieldProps, "of">) => {
+  if (!field.of) return value;
+  return Object.fromEntries(
+    Object.entries(value as Record<string, unknown>).map(([key, val]) => [
+      key,
+      applyFnToArrayObjects(val, (v: never) => deserializeInput(v, field.of as ConstantModelRef, 0)),
+    ]),
+  );
+};
+
+const deserializeInput = <Input = unknown>(
+  value: Input | Input[],
+  inputRef: ConstantModelRef<Input> | PrimitiveScalar,
+  arrDepth: number,
+  convertFn: (value: unknown) => unknown = (value: unknown) => value,
+): Input | Input[] => {
+  if (arrDepth && Array.isArray(value))
+    return value.map((v) => deserializeInput(v, inputRef, arrDepth - 1, convertFn) as Input) as unknown as Input[];
+  if ((inputRef as ConstantCls).prototype === Map.prototype) {
+    const deserializeFn = getDeserializeFn(inputRef);
+    const entries = value instanceof Map ? [...value.entries()] : Object.entries(value as Record<string, unknown>);
+    return convertFn(
+      Object.fromEntries(entries.map(([key, val]) => [key, applyFnToArrayObjects(val, deserializeFn)])),
+    ) as Input;
+  }
+  if (PrimitiveRegistry.has(inputRef as Cls)) return convertFn(getDeserializeFn(inputRef)(value)) as Input;
+  if (!ConstantRegistry.isScalar(inputRef as Cls)) return convertFn(value) as Input;
+  return convertFn(
+    Object.fromEntries(
+      Object.entries((inputRef as ConstantCls)[FIELD_META]).map(([key, field]) => [
+        key,
+        field.isMap
+          ? deserializeMap((value as Record<string, unknown>)[key], field.getProps())
+          : deserialize(field.modelRef, field.arrDepth, (value as Record<string, unknown>)[key], {
+              key,
+              nullable: field.nullable,
+              enum: field.enum,
+            }),
+      ]),
+    ),
+  ) as Input;
+};
+
+interface DeserializeOption {
+  key?: string;
+  nullable?: boolean;
+  convertFn?: (value: unknown) => unknown;
+  enum?: EnumInstance;
+}
+
+const assertEnumValue = (enumRef: EnumInstance, value: unknown, key?: string): void => {
+  if (Array.isArray(value)) {
+    for (const item of value) assertEnumValue(enumRef, item, key);
+    return;
+  }
+  if (value === null || value === undefined || enumRef.has(value as never)) return;
+  throw new Error(`Invalid Enum Value in ${key}: ${String(value)} is not one of ${enumRef.values.join(", ")}`);
+};
+
+export const deserialize = (
+  argRef: ConstantModelRef | PrimitiveScalar,
+  arrDepth: number,
+  value: unknown,
+  { key, nullable = false, convertFn, enum: enumRef }: DeserializeOption,
+) => {
+  if (nullable && (value === null || value === undefined)) return null;
+  else if (!nullable && (value === null || value === undefined) && argRef !== Any)
+    throw new Error(`Invalid Value (Nullable) in ${key} ${argRef} for value ${value}`);
+
+  const result = withSharedInstances(() => deserializeInput(value, argRef, arrDepth, convertFn)) as object[];
+  if (enumRef) assertEnumValue(enumRef, result, key);
+  return result;
+};

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,6 +75,7 @@ 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.", "마이크를 사용할 수 없습니다."],
@@ -108,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", "계속하기"],