@molecule/api-ai-tools 1.0.9 → 1.2.0

package/README.md

@@ -3,7 +3,7 @@ AUTO-GENERATED — DO NOT EDIT THIS FILE.
 Generated by `mlcl sync-docs` from the package's src/index.ts JSDoc + mlcl/registry.json.
 Edits here are overwritten on the next commit (molecule's pre-commit hook regenerates).
 To change this document, edit the module-level JSDoc in src/index.ts.
-Generated: 2026-09-18T06:57:26.872Z
+Generated: 2026-09-22T21:57:22.227Z
 -->
 
 # @molecule/api-ai-tools
@@ -133,6 +133,50 @@ interface FileDiffEvent {
 }
 ```
 
+#### `GuardOptions`
+
+Options shared by {@link guardToolExecute} and {@link guardAITool}.
+
+```typescript
+interface GuardOptions {
+  /**
+   * Redactor applied to a THROWN error's message before it is returned to the
+   * model. Defaults to this package's `redactSecrets`.
+   */
+  redactError?: (message: string) => string
+}
+```
+
+#### `NormalizableSchema`
+
+The JSON-Schema-ish shape every tool in this package declares.
+
+```typescript
+interface NormalizableSchema {
+  name: string
+  parameters?: {
+    type?: string
+    properties?: Record<string, { type?: string; description?: string }>
+    required?: string[]
+  }
+}
+```
+
+#### `NormalizedInput`
+
+The result of normalizing one tool call's input.
+
+```typescript
+interface NormalizedInput {
+  /** The input to hand the handler, with aliases moved onto the declared names. */
+  input: Record<string, unknown>
+  /** Declared-required parameters still absent after aliasing. */
+  missing: string[]
+  /** `alias→declared` pairs that were moved, for logging. */
+  aliased: string[]
+}
+```
+
 #### `PromptContext`
 
 Context for building a composable system prompt.
@@ -355,6 +399,21 @@ function createSandboxBackend(sandbox: SandboxLike, projectRoot?: string): Execu
 
 **Returns:** A backend that proxies all filesystem calls into the sandbox.
 
+#### `declaredBudgetSeconds(command, timeoutParam)`
+
+The time budget a COMMAND declares for itself — a `timeout <seconds>` prefix
+anywhere in it, or the tool call's own `timeout` (ms) parameter, whichever is
+larger. Zero when it declares none.
+
+```typescript
+function declaredBudgetSeconds(command: string, timeoutParam: unknown): number
+```
+
+- `command` — The shell command.
+- `timeoutParam` — The tool call's `timeout` input, in milliseconds.
+
+**Returns:** The declared budget in seconds, or 0.
+
 #### `directoryReadHint(message, path)`
 
 Detect a "read/edit targeted a directory, not a file" failure from a backend
@@ -386,6 +445,50 @@ function discoverSkills(backend: ExecutionBackend): Promise<SkillEntry[]>
 
 **Returns:** Array of discovered skills with name, description, and path
 
+#### `guardAITool(tool)`
+
+Apply {@link guardToolExecute} to a ready-made tool object (the
+`@molecule/api-ai` `AITool` shape: `{ name, description, parameters,
+execute }`), returning a copy whose `execute` is guarded.
+
+Use it at the point a consumer hands its full tool list to the model, so
+tools built outside this package get the same treatment as the ones built
+inside it.
+
+```typescript
+function guardAITool(tool: T, options?: GuardOptions): T
+```
+
+- `tool` — The tool to guard.
+
+**Returns:** A copy with a guarded `execute`.
+
+#### `guardToolExecute(schema, impl)`
+
+Wrap a tool handler so every call is normalized first and a handler that
+THROWS returns something the model can act on.
+
+The guard deliberately does NOT pre-empt the handler when a required
+parameter looks absent: several handlers accept a documented older shape
+(`edit_file`'s top-level `old_string`/`new_string`) or answer a missing
+parameter with far better guidance than a generic message could (`edit_file`
+telling the model to re-read the file). It steps in only where the handler
+would otherwise crash — and when it does, a still-missing required parameter
+is the accurate diagnosis for that crash, so it is reported as one.
+
+```typescript
+function guardToolExecute(
+  schema: NormalizableSchema,
+  impl: (input: Record<string, unknown>, ...rest: never[]) => Promise<unknown>,
+  options?: GuardOptions,
+): (input: unknown, ...rest: never[]) => Promise<unknown>
+```
+
+- `schema` — The tool's declared schema.
+- `impl` — The raw handler.
+
+**Returns:** A handler with the same signature, guarded.
+
 #### `isEnvFilePath(path)`
 
 Whether a path is an env file, for which {@link redactSecrets}' full env-dump
@@ -422,6 +525,93 @@ function isValidGlob(pattern: string): boolean
 
 **Returns:** `true` when the pattern contains only allowed characters.
 
+#### `missingParamError(schema, input, missing)`
+
+The error a tool returns when a required parameter is still absent after
+aliasing. Model-facing, so it names the right parameter, what was actually
+sent, and the shape of a correct call — everything needed to fix it in one
+turn instead of concluding the tool is broken.
+
+```typescript
+function missingParamError(
+  schema: NormalizableSchema,
+  input: Record<string, unknown>,
+  missing: string[],
+): string
+```
+
+- `schema` — The tool's declared schema.
+- `input` — The normalized input (used to list the keys that were sent).
+- `missing` — The required parameters still absent.
+
+**Returns:** A single-sentence-per-clause error string.
+
+#### `normalizeToolInput(schema, raw)`
+
+Move known aliases onto the declared parameter names and report what is still
+missing. Unknown keys are left in place — handlers ignore them, and dropping
+them would hide a model's intent from anything reading the call log.
+
+```typescript
+function normalizeToolInput(schema: NormalizableSchema, raw: unknown): NormalizedInput
+```
+
+- `schema` — The tool's declared schema.
+- `raw` — Whatever the model sent as the tool input.
+
+**Returns:** The normalized input plus the missing-required and aliased lists.
+
+#### `outputIsWithheldUntilExit(command)`
+
+Whether a command's output reaches the tool only when the whole pipeline
+ends — a pipe into `tail`, `grep`, `sort`, `wc` and friends, which
+block-buffer when stdout is not a terminal.
+
+It matters only in combination with an overrun: a command stopped at the
+tool's ceiling normally hands back everything it printed, but behind one of
+these it printed nothing, so the whole budget is spent for no information.
+Measured across six real agent runs: ten such commands, every one of them
+piped, 49 minutes returning a few hundred bytes each.
+
+```typescript
+function outputIsWithheldUntilExit(command: string): boolean
+```
+
+- `command` — The shell command.
+
+**Returns:** True when a kill would return no useful output.
+
+#### `parseCheckCommand(path)`
+
+The shell command that parses one file and exits non-zero with the error
+when it does not parse: `node --check` for JavaScript, `JSON.parse` for
+JSON, esbuild's transform (present wherever Vite is) for TypeScript.
+
+```typescript
+function parseCheckCommand(path: string): string | null
+```
+
+- `path` — The file's absolute path.
+
+**Returns:** The command, or null when the file type has no cheap parser.
+
+#### `parseCheckProblem(result)`
+
+What a failed parse check says to the executor, or null when the check
+passed or could not run (no parser available is not a syntax error).
+
+```typescript
+function parseCheckProblem(result: {
+  stdout: string
+  stderr: string
+  exitCode: number
+}): string | null
+```
+
+- `result` — The check command's result.
+
+**Returns:** The message for the tool result, or null.
+
 #### `pathArgError(path, tool)`
 
 Validate a file tool's `path` argument is a non-empty string. A weak model
@@ -512,6 +702,28 @@ function shellQuote(s: string): string
 
 **Returns:** A single-quoted shell literal representing `s`.
 
+#### `sliceLines(content, window)`
+
+Return a line window of `content`, or null when no window was asked for.
+
+`read_file` returned whole files only, so an executor that wanted part of one
+shelled out: across six real agent runs, 260 of 377 shell-inspection commands
+(69%) were `head`/`tail`/`sed -n` windowing a file the tool could have
+windowed itself. `offset` is 1-based, matching the line numbers every other
+tool reports and what `grep -n` prints.
+
+```typescript
+function sliceLines(
+  content: string,
+  window?: { offset?: unknown; limit?: unknown },
+): { text: string; offset: number; lines: number; totalLines: number; truncated: boolean } | null
+```
+
+- `content` — The file's full text.
+- `window` — The requested `offset` (1-based) and `limit` (line count).
+
+**Returns:** The window plus its position, or null when neither was given.
+
 #### `stripControlChars(s)`
 
 Strip C0 control chars (except tab, newline, CR) that break PostgreSQL JSONB
@@ -614,6 +826,25 @@ const DEFAULT_SEARCH_EXCLUDED_DIRS: readonly [
 ]
 ```
 
+#### `MAX_BATCH_READ_BYTES`
+
+Total content bytes one batched `read_file` call returns, across all files.
+The per-file {@link MAX_READ_SIZE} still applies to each one.
+
+```typescript
+const MAX_BATCH_READ_BYTES: number
+```
+
+#### `MAX_BATCH_READ_FILES`
+
+Most files one batched `read_file` call returns. The cap exists so a survey
+of a large tree cannot swallow the turn's context in one result; the tool
+reports where it stopped so the model continues from there.
+
+```typescript
+const MAX_BATCH_READ_FILES: 25
+```
+
 #### `MAX_FIND_RESULTS`
 
 Max find results.
@@ -630,6 +861,23 @@ Max command output size (100KB per stream).
 const MAX_OUTPUT_SIZE: number
 ```
 
+#### `MAX_READ_RETURN_CHARS`
+
+The most one read_file call returns for ONE file when no window was asked
+for, in chars. Larger files come back as their first window with a note
+saying how to read the rest.
+
+MAX_READ_SIZE (5 MB) is a bound on what the tool will open, not on what it
+should hand a model: a single batched read that returned a 1.2 MB README
+put the next three provider calls at 366k tokens (~330k of them fresh)
+against a 120k-token context cap (X0 run x5, call 26). ~80 KB is ~20–25k
+tokens — a fifth of that cap, and more than any one file read usually
+needs.
+
+```typescript
+const MAX_READ_RETURN_CHARS: number
+```
+
 #### `MAX_READ_SIZE`
 
 Max file size for read_file (5MB).
@@ -638,6 +886,16 @@ Max file size for read_file (5MB).
 const MAX_READ_SIZE: number
 ```
 
+#### `MAX_SEARCH_CONTEXT_LINES`
+
+Most lines of surrounding context `search_files` will return per match.
+Bounded so a broad pattern with a generous context cannot pull a whole tree
+into one reply.
+
+```typescript
+const MAX_SEARCH_CONTEXT_LINES: 40
+```
+
 #### `MAX_SEARCH_RESULTS`
 
 Max search results.
@@ -654,6 +912,14 @@ Max content size for write_file (10MB).
 const MAX_WRITE_SIZE: number
 ```
 
+#### `PARSE_CHECKABLE`
+
+Files a parse check can vouch for cheaply right after a write.
+
+```typescript
+const PARSE_CHECKABLE: RegExp
+```
+
 #### `TOOL_SCHEMAS`
 
 Canonical tool schemas shared by the agent runtime and documentation.
@@ -685,6 +951,19 @@ Peer dependencies:
   rules via `blockCommand` (return an actionable error string to refuse — it is
   shown to the model verbatim) and enable `blockDangerousCommands` (default
   FALSE) where appropriate.
+- **`read_file` takes `paths` as well as `path`.** An agent that issues one
+  tool call per model round-trip pays a full round-trip per file, so a project
+  survey costs minutes; batched, the same reads cost one call each 25 files
+  (`MAX_BATCH_READ_FILES` / `MAX_BATCH_READ_BYTES`, which report where they
+  stopped). Each entry carries its own content or its own error, so one bad
+  path never fails the batch.
+- **A parameter under another name is not a broken tool.** Every tool's input
+  is normalized first (`cmd` → `command`, `file` → `path`, camelCase ⇄
+  snake_case), and a handler that throws returns an error naming the missing
+  parameter rather than a bare internal message — which a weak executor reads
+  as a broken tool and routes around, taking its verification with it. Use
+  `guardAITool` to give tools built elsewhere the same treatment, passing
+  `redactError` so a thrown message is masked by your own redactor.
 - **Scope the tool set per agent** with `include`/`exclude` — a read-only agent
   should not receive `write_file`/`exec_command`.
 - Outputs are size-capped (`MAX_READ_SIZE`, `MAX_OUTPUT_SIZE`, …) and searches

package/dist/index.d.ts

@@ -23,6 +23,19 @@
  *   rules via `blockCommand` (return an actionable error string to refuse — it is
  *   shown to the model verbatim) and enable `blockDangerousCommands` (default
  *   FALSE) where appropriate.
+ * - **`read_file` takes `paths` as well as `path`.** An agent that issues one
+ *   tool call per model round-trip pays a full round-trip per file, so a project
+ *   survey costs minutes; batched, the same reads cost one call each 25 files
+ *   (`MAX_BATCH_READ_FILES` / `MAX_BATCH_READ_BYTES`, which report where they
+ *   stopped). Each entry carries its own content or its own error, so one bad
+ *   path never fails the batch.
+ * - **A parameter under another name is not a broken tool.** Every tool's input
+ *   is normalized first (`cmd` → `command`, `file` → `path`, camelCase ⇄
+ *   snake_case), and a handler that throws returns an error naming the missing
+ *   parameter rather than a bare internal message — which a weak executor reads
+ *   as a broken tool and routes around, taking its verification with it. Use
+ *   `guardAITool` to give tools built elsewhere the same treatment, passing
+ *   `redactError` so a thrown message is masked by your own redactor.
  * - **Scope the tool set per agent** with `include`/`exclude` — a read-only agent
  *   should not receive `write_file`/`exec_command`.
  * - Outputs are size-capped (`MAX_READ_SIZE`, `MAX_OUTPUT_SIZE`, …) and searches
@@ -85,6 +98,7 @@
 export * from './backends/local.js';
 export * from './backends/sandbox.js';
 export * from './browser-guard.js';
+export * from './input-normalizer.js';
 export * from './schemas.js';
 export * from './system-prompt.js';
 export * from './tools.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmFG;AAEH,cAAc,qBAAqB,CAAA;AACnC,cAAc,uBAAuB,CAAA;AACrC,cAAc,oBAAoB,CAAA;AAClC,cAAc,cAAc,CAAA;AAC5B,cAAc,oBAAoB,CAAA;AAClC,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA;AAC1B,cAAc,gBAAgB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgGG;AAEH,cAAc,qBAAqB,CAAA;AACnC,cAAc,uBAAuB,CAAA;AACrC,cAAc,oBAAoB,CAAA;AAClC,cAAc,uBAAuB,CAAA;AACrC,cAAc,cAAc,CAAA;AAC5B,cAAc,oBAAoB,CAAA;AAClC,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA;AAC1B,cAAc,gBAAgB,CAAA"}

package/dist/index.js

@@ -23,6 +23,19 @@
  *   rules via `blockCommand` (return an actionable error string to refuse — it is
  *   shown to the model verbatim) and enable `blockDangerousCommands` (default
  *   FALSE) where appropriate.
+ * - **`read_file` takes `paths` as well as `path`.** An agent that issues one
+ *   tool call per model round-trip pays a full round-trip per file, so a project
+ *   survey costs minutes; batched, the same reads cost one call each 25 files
+ *   (`MAX_BATCH_READ_FILES` / `MAX_BATCH_READ_BYTES`, which report where they
+ *   stopped). Each entry carries its own content or its own error, so one bad
+ *   path never fails the batch.
+ * - **A parameter under another name is not a broken tool.** Every tool's input
+ *   is normalized first (`cmd` → `command`, `file` → `path`, camelCase ⇄
+ *   snake_case), and a handler that throws returns an error naming the missing
+ *   parameter rather than a bare internal message — which a weak executor reads
+ *   as a broken tool and routes around, taking its verification with it. Use
+ *   `guardAITool` to give tools built elsewhere the same treatment, passing
+ *   `redactError` so a thrown message is masked by your own redactor.
  * - **Scope the tool set per agent** with `include`/`exclude` — a read-only agent
  *   should not receive `write_file`/`exec_command`.
  * - Outputs are size-capped (`MAX_READ_SIZE`, `MAX_OUTPUT_SIZE`, …) and searches
@@ -85,6 +98,7 @@
 export * from './backends/local.js';
 export * from './backends/sandbox.js';
 export * from './browser-guard.js';
+export * from './input-normalizer.js';
 export * from './schemas.js';
 export * from './system-prompt.js';
 export * from './tools.js';

package/dist/input-normalizer.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Tool-input normalization: accept the parameter names a weak executor
+ * actually sends, and never let a missing one reach a handler as `undefined`.
+ *
+ * @module
+ */
+/** The JSON-Schema-ish shape every tool in this package declares. */
+export interface NormalizableSchema {
+    name: string;
+    parameters?: {
+        type?: string;
+        properties?: Record<string, {
+            type?: string;
+            description?: string;
+        }>;
+        required?: string[];
+    };
+}
+/** The result of normalizing one tool call's input. */
+export interface NormalizedInput {
+    /** The input to hand the handler, with aliases moved onto the declared names. */
+    input: Record<string, unknown>;
+    /** Declared-required parameters still absent after aliasing. */
+    missing: string[];
+    /** `alias→declared` pairs that were moved, for logging. */
+    aliased: string[];
+}
+/** Options shared by {@link guardToolExecute} and {@link guardAITool}. */
+export interface GuardOptions {
+    /**
+     * Redactor applied to a THROWN error's message before it is returned to the
+     * model. Defaults to this package's `redactSecrets`.
+     */
+    redactError?: (message: string) => string;
+}
+/**
+ * Move known aliases onto the declared parameter names and report what is still
+ * missing. Unknown keys are left in place — handlers ignore them, and dropping
+ * them would hide a model's intent from anything reading the call log.
+ *
+ * @param schema - The tool's declared schema.
+ * @param raw - Whatever the model sent as the tool input.
+ * @returns The normalized input plus the missing-required and aliased lists.
+ */
+export declare function normalizeToolInput(schema: NormalizableSchema, raw: unknown): NormalizedInput;
+/**
+ * The error a tool returns when a required parameter is still absent after
+ * aliasing. Model-facing, so it names the right parameter, what was actually
+ * sent, and the shape of a correct call — everything needed to fix it in one
+ * turn instead of concluding the tool is broken.
+ *
+ * @param schema - The tool's declared schema.
+ * @param input - The normalized input (used to list the keys that were sent).
+ * @param missing - The required parameters still absent.
+ * @returns A single-sentence-per-clause error string.
+ */
+export declare function missingParamError(schema: NormalizableSchema, input: Record<string, unknown>, missing: string[]): string;
+/**
+ * Wrap a tool handler so every call is normalized first and a handler that
+ * THROWS returns something the model can act on.
+ *
+ * The guard deliberately does NOT pre-empt the handler when a required
+ * parameter looks absent: several handlers accept a documented older shape
+ * (`edit_file`'s top-level `old_string`/`new_string`) or answer a missing
+ * parameter with far better guidance than a generic message could (`edit_file`
+ * telling the model to re-read the file). It steps in only where the handler
+ * would otherwise crash — and when it does, a still-missing required parameter
+ * is the accurate diagnosis for that crash, so it is reported as one.
+ *
+ * @param schema - The tool's declared schema.
+ * @param impl - The raw handler.
+ * @returns A handler with the same signature, guarded.
+ */
+export declare function guardToolExecute(schema: NormalizableSchema, impl: (input: Record<string, unknown>, ...rest: never[]) => Promise<unknown>, options?: GuardOptions): (input: unknown, ...rest: never[]) => Promise<unknown>;
+/**
+ * Apply {@link guardToolExecute} to a ready-made tool object (the
+ * `@molecule/api-ai` `AITool` shape: `{ name, description, parameters,
+ * execute }`), returning a copy whose `execute` is guarded.
+ *
+ * Use it at the point a consumer hands its full tool list to the model, so
+ * tools built outside this package get the same treatment as the ones built
+ * inside it.
+ *
+ * @param tool - The tool to guard.
+ * @returns A copy with a guarded `execute`.
+ */
+export declare function guardAITool<T extends {
+    name: string;
+    parameters?: unknown;
+    execute: (input: unknown, ...rest: never[]) => Promise<unknown>;
+}>(tool: T, options?: GuardOptions): T;
+//# sourceMappingURL=input-normalizer.d.ts.map

package/dist/input-normalizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-normalizer.d.ts","sourceRoot":"","sources":["../src/input-normalizer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,qEAAqE;AACrE,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,CAAC,EAAE;QACX,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;YAAE,IAAI,CAAC,EAAE,MAAM,CAAC;YAAC,WAAW,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC,CAAA;QACpE,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KACpB,CAAA;CACF;AAED,uDAAuD;AACvD,MAAM,WAAW,eAAe;IAC9B,iFAAiF;IACjF,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,gEAAgE;IAChE,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,2DAA2D;IAC3D,OAAO,EAAE,MAAM,EAAE,CAAA;CAClB;AAiDD,0EAA0E;AAC1E,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,CAAA;CAC1C;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,kBAAkB,EAAE,GAAG,EAAE,OAAO,GAAG,eAAe,CAiD5F;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,kBAAkB,EAC1B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,EAAE,MAAM,EAAE,GAChB,MAAM,CAaR;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,kBAAkB,EAC1B,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,EAC5E,OAAO,GAAE,YAAiB,GACzB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAsBxD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CACzB,CAAC,SAAS;IACR,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;CAChE,EACD,IAAI,EAAE,CAAC,EAAE,OAAO,GAAE,YAAiB,GAAG,CAAC,CAaxC"}