@symerian/symi 3.0.18 → 3.0.19

package/extensions/llm-task/README.md

@@ -1,97 +0,0 @@
-# LLM Task (plugin)
-
-Adds an **optional** agent tool `llm-task` for running **JSON-only** LLM tasks
-(drafting, summarizing, classifying) with optional JSON Schema validation.
-
-Designed to be called from workflow engines (for example, Pipeline via
-`symi.invoke --each`) without adding new Symi code per workflow.
-
-## Enable
-
-1. Enable the plugin:
-
-```json
-{
-  "plugins": {
-    "entries": {
-      "llm-task": { "enabled": true }
-    }
-  }
-}
-```
-
-2. Allowlist the tool (it is registered with `optional: true`):
-
-```json
-{
-  "agents": {
-    "list": [
-      {
-        "id": "main",
-        "tools": { "allow": ["llm-task"] }
-      }
-    ]
-  }
-}
-```
-
-## Config (optional)
-
-```json
-{
-  "plugins": {
-    "entries": {
-      "llm-task": {
-        "enabled": true,
-        "config": {
-          "defaultProvider": "openai-codex",
-          "defaultModel": "gpt-5.2",
-          "defaultAuthProfileId": "main",
-          "allowedModels": ["openai-codex/gpt-5.2"],
-          "maxTokens": 800,
-          "timeoutMs": 30000
-        }
-      }
-    }
-  }
-}
-```
-
-`allowedModels` is an allowlist of `provider/model` strings. If set, any request
-outside the list is rejected.
-
-## Tool API
-
-### Parameters
-
-- `prompt` (string, required)
-- `input` (any, optional)
-- `schema` (object, optional JSON Schema)
-- `provider` (string, optional)
-- `model` (string, optional)
-- `authProfileId` (string, optional)
-- `temperature` (number, optional)
-- `maxTokens` (number, optional)
-- `timeoutMs` (number, optional)
-
-### Output
-
-Returns `details.json` containing the parsed JSON (and validates against
-`schema` when provided).
-
-## Notes
-
-- The tool is **JSON-only** and instructs the model to output only JSON
-  (no code fences, no commentary).
-- No tools are exposed to the model for this run.
-- Side effects should be handled outside this tool (for example, approvals in
-  Pipeline) before calling tools that send messages/emails.
-
-## Bundled extension note
-
-This extension depends on Symi internal modules (the embedded agent runner).
-It is intended to ship as a **bundled** Symi extension (like `pipeline`) and
-be enabled via `plugins.entries` + tool allowlists.
-
-It is **not** currently designed to be copied into
-`~/.symi/extensions` as a standalone plugin directory.

package/extensions/llm-task/index.ts

@@ -1,6 +0,0 @@
-import type { AnyAgentTool, SymiPluginApi } from "../../src/plugins/types.js";
-import { createLlmTaskTool } from "./src/llm-task-tool.js";
-
-export default function register(api: SymiPluginApi) {
-  api.registerTool(createLlmTaskTool(api) as unknown as AnyAgentTool, { optional: true });
-}

package/extensions/llm-task/package.json

@@ -1,12 +0,0 @@
-{
-  "name": "@symi/llm-task",
-  "version": "3.0.9",
-  "private": true,
-  "description": "Symi JSON-only LLM task plugin",
-  "type": "module",
-  "symi": {
-    "extensions": [
-      "./index.ts"
-    ]
-  }
-}

package/extensions/llm-task/src/llm-task-tool.test.ts

@@ -1,138 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-vi.mock("../../../src/agents/pi-embedded-runner.js", () => {
-  return {
-    runEmbeddedPiAgent: vi.fn(async () => ({
-      meta: { startedAt: Date.now() },
-      payloads: [{ text: "{}" }],
-    })),
-  };
-});
-
-import { runEmbeddedPiAgent } from "../../../src/agents/pi-embedded-runner.js";
-import { createLlmTaskTool } from "./llm-task-tool.js";
-
-// oxlint-disable-next-line typescript/no-explicit-any
-function fakeApi(overrides: any = {}) {
-  return {
-    id: "llm-task",
-    name: "llm-task",
-    source: "test",
-    config: {
-      agents: { defaults: { workspace: "/tmp", model: { primary: "openai-codex/gpt-5.2" } } },
-    },
-    pluginConfig: {},
-    runtime: { version: "test" },
-    logger: { debug() {}, info() {}, warn() {}, error() {} },
-    registerTool() {},
-    ...overrides,
-  };
-}
-
-describe("llm-task tool (json-only)", () => {
-  beforeEach(() => vi.clearAllMocks());
-
-  it("returns parsed json", async () => {
-    // oxlint-disable-next-line typescript/no-explicit-any
-    (runEmbeddedPiAgent as any).mockResolvedValueOnce({
-      meta: {},
-      payloads: [{ text: JSON.stringify({ foo: "bar" }) }],
-    });
-    const tool = createLlmTaskTool(fakeApi());
-    const res = await tool.execute("id", { prompt: "return foo" });
-    // oxlint-disable-next-line typescript/no-explicit-any
-    expect((res as any).details.json).toEqual({ foo: "bar" });
-  });
-
-  it("strips fenced json", async () => {
-    // oxlint-disable-next-line typescript/no-explicit-any
-    (runEmbeddedPiAgent as any).mockResolvedValueOnce({
-      meta: {},
-      payloads: [{ text: '```json\n{"ok":true}\n```' }],
-    });
-    const tool = createLlmTaskTool(fakeApi());
-    const res = await tool.execute("id", { prompt: "return ok" });
-    // oxlint-disable-next-line typescript/no-explicit-any
-    expect((res as any).details.json).toEqual({ ok: true });
-  });
-
-  it("validates schema", async () => {
-    // oxlint-disable-next-line typescript/no-explicit-any
-    (runEmbeddedPiAgent as any).mockResolvedValueOnce({
-      meta: {},
-      payloads: [{ text: JSON.stringify({ foo: "bar" }) }],
-    });
-    const tool = createLlmTaskTool(fakeApi());
-    const schema = {
-      type: "object",
-      properties: { foo: { type: "string" } },
-      required: ["foo"],
-      additionalProperties: false,
-    };
-    const res = await tool.execute("id", { prompt: "return foo", schema });
-    // oxlint-disable-next-line typescript/no-explicit-any
-    expect((res as any).details.json).toEqual({ foo: "bar" });
-  });
-
-  it("throws on invalid json", async () => {
-    // oxlint-disable-next-line typescript/no-explicit-any
-    (runEmbeddedPiAgent as any).mockResolvedValueOnce({
-      meta: {},
-      payloads: [{ text: "not-json" }],
-    });
-    const tool = createLlmTaskTool(fakeApi());
-    await expect(tool.execute("id", { prompt: "x" })).rejects.toThrow(/invalid json/i);
-  });
-
-  it("throws on schema mismatch", async () => {
-    // oxlint-disable-next-line typescript/no-explicit-any
-    (runEmbeddedPiAgent as any).mockResolvedValueOnce({
-      meta: {},
-      payloads: [{ text: JSON.stringify({ foo: 1 }) }],
-    });
-    const tool = createLlmTaskTool(fakeApi());
-    const schema = { type: "object", properties: { foo: { type: "string" } }, required: ["foo"] };
-    await expect(tool.execute("id", { prompt: "x", schema })).rejects.toThrow(/match schema/i);
-  });
-
-  it("passes provider/model overrides to embedded runner", async () => {
-    // oxlint-disable-next-line typescript/no-explicit-any
-    (runEmbeddedPiAgent as any).mockResolvedValueOnce({
-      meta: {},
-      payloads: [{ text: JSON.stringify({ ok: true }) }],
-    });
-    const tool = createLlmTaskTool(fakeApi());
-    await tool.execute("id", { prompt: "x", provider: "anthropic", model: "claude-4-sonnet" });
-    // oxlint-disable-next-line typescript/no-explicit-any
-    const call = (runEmbeddedPiAgent as any).mock.calls[0]?.[0];
-    expect(call.provider).toBe("anthropic");
-    expect(call.model).toBe("claude-4-sonnet");
-  });
-
-  it("enforces allowedModels", async () => {
-    // oxlint-disable-next-line typescript/no-explicit-any
-    (runEmbeddedPiAgent as any).mockResolvedValueOnce({
-      meta: {},
-      payloads: [{ text: JSON.stringify({ ok: true }) }],
-    });
-    const tool = createLlmTaskTool(
-      fakeApi({ pluginConfig: { allowedModels: ["openai-codex/gpt-5.2"] } }),
-    );
-    await expect(
-      tool.execute("id", { prompt: "x", provider: "anthropic", model: "claude-4-sonnet" }),
-    ).rejects.toThrow(/not allowed/i);
-  });
-
-  it("disables tools for embedded run", async () => {
-    // oxlint-disable-next-line typescript/no-explicit-any
-    (runEmbeddedPiAgent as any).mockResolvedValueOnce({
-      meta: {},
-      payloads: [{ text: JSON.stringify({ ok: true }) }],
-    });
-    const tool = createLlmTaskTool(fakeApi());
-    await tool.execute("id", { prompt: "x" });
-    // oxlint-disable-next-line typescript/no-explicit-any
-    const call = (runEmbeddedPiAgent as any).mock.calls[0]?.[0];
-    expect(call.disableTools).toBe(true);
-  });
-});

package/extensions/llm-task/src/llm-task-tool.ts

@@ -1,249 +0,0 @@
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { Type } from "@sinclair/typebox";
-import Ajv from "ajv";
-// NOTE: This extension is intended to be bundled with Symi.
-// When running from source (tests/dev), Symi internals live under src/.
-// When running from a built install, internals live under dist/ (no src/ tree).
-// So we resolve internal imports dynamically with src-first, dist-fallback.
-import type { SymiPluginApi } from "../../../src/plugins/types.js";
-
-type RunEmbeddedPiAgentFn = (params: Record<string, unknown>) => Promise<unknown>;
-
-async function loadRunEmbeddedPiAgent(): Promise<RunEmbeddedPiAgentFn> {
-  // Source checkout (tests/dev)
-  try {
-    const mod = await import("../../../src/agents/pi-embedded-runner.js");
-    // oxlint-disable-next-line typescript/no-explicit-any
-    if (typeof (mod as any).runEmbeddedPiAgent === "function") {
-      // oxlint-disable-next-line typescript/no-explicit-any
-      return (mod as any).runEmbeddedPiAgent;
-    }
-  } catch {
-    // ignore
-  }
-
-  // Bundled install (built)
-  const mod = await import("../../../src/agents/pi-embedded-runner.js");
-  if (typeof mod.runEmbeddedPiAgent !== "function") {
-    throw new Error("Internal error: runEmbeddedPiAgent not available");
-  }
-  return mod.runEmbeddedPiAgent as RunEmbeddedPiAgentFn;
-}
-
-function stripCodeFences(s: string): string {
-  const trimmed = s.trim();
-  const m = trimmed.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
-  if (m) {
-    return (m[1] ?? "").trim();
-  }
-  return trimmed;
-}
-
-function collectText(payloads: Array<{ text?: string; isError?: boolean }> | undefined): string {
-  const texts = (payloads ?? [])
-    .filter((p) => !p.isError && typeof p.text === "string")
-    .map((p) => p.text ?? "");
-  return texts.join("\n").trim();
-}
-
-function toModelKey(provider?: string, model?: string): string | undefined {
-  const p = provider?.trim();
-  const m = model?.trim();
-  if (!p || !m) {
-    return undefined;
-  }
-  return `${p}/${m}`;
-}
-
-type PluginCfg = {
-  defaultProvider?: string;
-  defaultModel?: string;
-  defaultAuthProfileId?: string;
-  allowedModels?: string[];
-  maxTokens?: number;
-  timeoutMs?: number;
-};
-
-export function createLlmTaskTool(api: SymiPluginApi) {
-  return {
-    name: "llm-task",
-    label: "LLM Task",
-    description:
-      "Run a generic JSON-only LLM task and return schema-validated JSON. Designed for orchestration from Pipeline workflows via symi.invoke.",
-    parameters: Type.Object({
-      prompt: Type.String({ description: "Task instruction for the LLM." }),
-      input: Type.Optional(Type.Unknown({ description: "Optional input payload for the task." })),
-      schema: Type.Optional(
-        Type.Unknown({ description: "Optional JSON Schema to validate the returned JSON." }),
-      ),
-      provider: Type.Optional(
-        Type.String({ description: "Provider override (e.g. openai-codex, anthropic)." }),
-      ),
-      model: Type.Optional(Type.String({ description: "Model id override." })),
-      authProfileId: Type.Optional(Type.String({ description: "Auth profile override." })),
-      temperature: Type.Optional(Type.Number({ description: "Best-effort temperature override." })),
-      maxTokens: Type.Optional(Type.Number({ description: "Best-effort maxTokens override." })),
-      timeoutMs: Type.Optional(Type.Number({ description: "Timeout for the LLM run." })),
-    }),
-
-    async execute(_id: string, params: Record<string, unknown>) {
-      const prompt = typeof params.prompt === "string" ? params.prompt : "";
-      if (!prompt.trim()) {
-        throw new Error("prompt required");
-      }
-
-      const pluginCfg = (api.pluginConfig ?? {}) as PluginCfg;
-
-      const primary = api.config?.agents?.defaults?.model?.primary;
-      const primaryProvider = typeof primary === "string" ? primary.split("/")[0] : undefined;
-      const primaryModel =
-        typeof primary === "string" ? primary.split("/").slice(1).join("/") : undefined;
-
-      const provider =
-        (typeof params.provider === "string" && params.provider.trim()) ||
-        (typeof pluginCfg.defaultProvider === "string" && pluginCfg.defaultProvider.trim()) ||
-        primaryProvider ||
-        undefined;
-
-      const model =
-        (typeof params.model === "string" && params.model.trim()) ||
-        (typeof pluginCfg.defaultModel === "string" && pluginCfg.defaultModel.trim()) ||
-        primaryModel ||
-        undefined;
-
-      const authProfileId =
-        // oxlint-disable-next-line typescript/no-explicit-any
-        (typeof (params as any).authProfileId === "string" &&
-          // oxlint-disable-next-line typescript/no-explicit-any
-          (params as any).authProfileId.trim()) ||
-        (typeof pluginCfg.defaultAuthProfileId === "string" &&
-          pluginCfg.defaultAuthProfileId.trim()) ||
-        undefined;
-
-      const modelKey = toModelKey(provider, model);
-      if (!provider || !model || !modelKey) {
-        throw new Error(
-          `provider/model could not be resolved (provider=${String(provider ?? "")}, model=${String(model ?? "")})`,
-        );
-      }
-
-      const allowed = Array.isArray(pluginCfg.allowedModels) ? pluginCfg.allowedModels : undefined;
-      if (allowed && allowed.length > 0 && !allowed.includes(modelKey)) {
-        throw new Error(
-          `Model not allowed by llm-task plugin config: ${modelKey}. Allowed models: ${allowed.join(", ")}`,
-        );
-      }
-
-      const timeoutMs =
-        (typeof params.timeoutMs === "number" && params.timeoutMs > 0
-          ? params.timeoutMs
-          : undefined) ||
-        (typeof pluginCfg.timeoutMs === "number" && pluginCfg.timeoutMs > 0
-          ? pluginCfg.timeoutMs
-          : undefined) ||
-        30_000;
-
-      const streamParams = {
-        temperature: typeof params.temperature === "number" ? params.temperature : undefined,
-        maxTokens:
-          typeof params.maxTokens === "number"
-            ? params.maxTokens
-            : typeof pluginCfg.maxTokens === "number"
-              ? pluginCfg.maxTokens
-              : undefined,
-      };
-
-      // oxlint-disable-next-line typescript/no-explicit-any
-      const input = (params as any).input as unknown;
-      let inputJson: string;
-      try {
-        inputJson = JSON.stringify(input ?? null, null, 2);
-      } catch {
-        throw new Error("input must be JSON-serializable");
-      }
-
-      const system = [
-        "You are a JSON-only function.",
-        "Return ONLY a valid JSON value.",
-        "Do not wrap in markdown fences.",
-        "Do not include commentary.",
-        "Do not call tools.",
-      ].join(" ");
-
-      const fullPrompt = `${system}\n\nTASK:\n${prompt}\n\nINPUT_JSON:\n${inputJson}\n`;
-
-      let tmpDir: string | null = null;
-      try {
-        tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "symi-llm-task-"));
-        const sessionId = `llm-task-${Date.now()}`;
-        const sessionFile = path.join(tmpDir, "session.json");
-
-        const runEmbeddedPiAgent = await loadRunEmbeddedPiAgent();
-
-        const result = await runEmbeddedPiAgent({
-          sessionId,
-          sessionFile,
-          workspaceDir: api.config?.agents?.defaults?.workspace ?? process.cwd(),
-          config: api.config,
-          prompt: fullPrompt,
-          timeoutMs,
-          runId: `llm-task-${Date.now()}`,
-          provider,
-          model,
-          authProfileId,
-          authProfileIdSource: authProfileId ? "user" : "auto",
-          streamParams,
-          disableTools: true,
-        });
-
-        // oxlint-disable-next-line typescript/no-explicit-any
-        const text = collectText((result as any).payloads);
-        if (!text) {
-          throw new Error("LLM returned empty output");
-        }
-
-        const raw = stripCodeFences(text);
-        let parsed: unknown;
-        try {
-          parsed = JSON.parse(raw);
-        } catch {
-          throw new Error("LLM returned invalid JSON");
-        }
-
-        // oxlint-disable-next-line typescript/no-explicit-any
-        const schema = (params as any).schema as unknown;
-        if (schema && typeof schema === "object" && !Array.isArray(schema)) {
-          const ajv = new Ajv.default({ allErrors: true, strict: false });
-          // oxlint-disable-next-line typescript/no-explicit-any
-          const validate = ajv.compile(schema as any);
-          const ok = validate(parsed);
-          if (!ok) {
-            const msg =
-              validate.errors
-                ?.map(
-                  (e: { instancePath?: string; message?: string }) =>
-                    `${e.instancePath || "<root>"} ${e.message || "invalid"}`,
-                )
-                .join("; ") ?? "invalid";
-            throw new Error(`LLM JSON did not match schema: ${msg}`);
-          }
-        }
-
-        return {
-          content: [{ type: "text", text: JSON.stringify(parsed, null, 2) }],
-          details: { json: parsed, provider, model },
-        };
-      } finally {
-        if (tmpDir) {
-          try {
-            await fs.rm(tmpDir, { recursive: true, force: true });
-          } catch {
-            // ignore
-          }
-        }
-      }
-    },
-  };
-}

package/extensions/llm-task/symi.plugin.json

@@ -1,21 +0,0 @@
-{
-  "id": "llm-task",
-  "name": "LLM Task",
-  "description": "Generic JSON-only LLM tool for structured tasks callable from workflows.",
-  "configSchema": {
-    "type": "object",
-    "additionalProperties": false,
-    "properties": {
-      "defaultProvider": { "type": "string" },
-      "defaultModel": { "type": "string" },
-      "defaultAuthProfileId": { "type": "string" },
-      "allowedModels": {
-        "type": "array",
-        "items": { "type": "string" },
-        "description": "Allowlist of provider/model keys like openai-codex/gpt-5.2."
-      },
-      "maxTokens": { "type": "number" },
-      "timeoutMs": { "type": "number" }
-    }
-  }
-}

package/extensions/memory-lancedb/config.ts

@@ -1,161 +0,0 @@
-import fs from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-
-export type MemoryConfig = {
-  embedding: {
-    provider: "openai";
-    model?: string;
-    apiKey: string;
-  };
-  dbPath?: string;
-  autoCapture?: boolean;
-  autoRecall?: boolean;
-  captureMaxChars?: number;
-};
-
-export const MEMORY_CATEGORIES = ["preference", "fact", "decision", "entity", "other"] as const;
-export type MemoryCategory = (typeof MEMORY_CATEGORIES)[number];
-
-const DEFAULT_MODEL = "text-embedding-3-small";
-export const DEFAULT_CAPTURE_MAX_CHARS = 500;
-const LEGACY_STATE_DIRS: string[] = [];
-
-function resolveDefaultDbPath(): string {
-  const home = homedir();
-  const preferred = join(home, ".symi", "memory", "lancedb");
-  try {
-    if (fs.existsSync(preferred)) {
-      return preferred;
-    }
-  } catch {
-    // best-effort
-  }
-
-  for (const legacy of LEGACY_STATE_DIRS) {
-    const candidate = join(home, legacy, "memory", "lancedb");
-    try {
-      if (fs.existsSync(candidate)) {
-        return candidate;
-      }
-    } catch {
-      // best-effort
-    }
-  }
-
-  return preferred;
-}
-
-const DEFAULT_DB_PATH = resolveDefaultDbPath();
-
-const EMBEDDING_DIMENSIONS: Record<string, number> = {
-  "text-embedding-3-small": 1536,
-  "text-embedding-3-large": 3072,
-};
-
-function assertAllowedKeys(value: Record<string, unknown>, allowed: string[], label: string) {
-  const unknown = Object.keys(value).filter((key) => !allowed.includes(key));
-  if (unknown.length === 0) {
-    return;
-  }
-  throw new Error(`${label} has unknown keys: ${unknown.join(", ")}`);
-}
-
-export function vectorDimsForModel(model: string): number {
-  const dims = EMBEDDING_DIMENSIONS[model];
-  if (!dims) {
-    throw new Error(`Unsupported embedding model: ${model}`);
-  }
-  return dims;
-}
-
-function resolveEnvVars(value: string): string {
-  return value.replace(/\$\{([^}]+)\}/g, (_, envVar) => {
-    const envValue = process.env[envVar];
-    if (!envValue) {
-      throw new Error(`Environment variable ${envVar} is not set`);
-    }
-    return envValue;
-  });
-}
-
-function resolveEmbeddingModel(embedding: Record<string, unknown>): string {
-  const model = typeof embedding.model === "string" ? embedding.model : DEFAULT_MODEL;
-  vectorDimsForModel(model);
-  return model;
-}
-
-export const memoryConfigSchema = {
-  parse(value: unknown): MemoryConfig {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-      throw new Error("memory config required");
-    }
-    const cfg = value as Record<string, unknown>;
-    assertAllowedKeys(
-      cfg,
-      ["embedding", "dbPath", "autoCapture", "autoRecall", "captureMaxChars"],
-      "memory config",
-    );
-
-    const embedding = cfg.embedding as Record<string, unknown> | undefined;
-    if (!embedding || typeof embedding.apiKey !== "string") {
-      throw new Error("embedding.apiKey is required");
-    }
-    assertAllowedKeys(embedding, ["apiKey", "model"], "embedding config");
-
-    const model = resolveEmbeddingModel(embedding);
-
-    const captureMaxChars =
-      typeof cfg.captureMaxChars === "number" ? Math.floor(cfg.captureMaxChars) : undefined;
-    if (
-      typeof captureMaxChars === "number" &&
-      (captureMaxChars < 100 || captureMaxChars > 10_000)
-    ) {
-      throw new Error("captureMaxChars must be between 100 and 10000");
-    }
-
-    return {
-      embedding: {
-        provider: "openai",
-        model,
-        apiKey: resolveEnvVars(embedding.apiKey),
-      },
-      dbPath: typeof cfg.dbPath === "string" ? cfg.dbPath : DEFAULT_DB_PATH,
-      autoCapture: cfg.autoCapture === true,
-      autoRecall: cfg.autoRecall !== false,
-      captureMaxChars: captureMaxChars ?? DEFAULT_CAPTURE_MAX_CHARS,
-    };
-  },
-  uiHints: {
-    "embedding.apiKey": {
-      label: "OpenAI API Key",
-      sensitive: true,
-      placeholder: "sk-proj-...",
-      help: "API key for OpenAI embeddings (or use ${OPENAI_API_KEY})",
-    },
-    "embedding.model": {
-      label: "Embedding Model",
-      placeholder: DEFAULT_MODEL,
-      help: "OpenAI embedding model to use",
-    },
-    dbPath: {
-      label: "Database Path",
-      placeholder: "~/.symi/memory/lancedb",
-      advanced: true,
-    },
-    autoCapture: {
-      label: "Auto-Capture",
-      help: "Automatically capture important information from conversations",
-    },
-    autoRecall: {
-      label: "Auto-Recall",
-      help: "Automatically inject relevant memories into context",
-    },
-    captureMaxChars: {
-      label: "Capture Max Chars",
-      help: "Maximum message length eligible for auto-capture",
-      advanced: true,
-      placeholder: String(DEFAULT_CAPTURE_MAX_CHARS),
-    },
-  },
-};