@vellumai/assistant 0.4.16 → 0.4.18

package/src/__tests__/dynamic-page-surface.test.ts

@@ -1,37 +1,35 @@
-import { describe, expect,test } from 'bun:test';
+import { describe, expect, test } from "bun:test";
 
 import type {
   DynamicPageSurfaceData,
   UiSurfaceShowDynamicPage,
-} from '../daemon/ipc-protocol.js';
-import {
-  INTERACTIVE_SURFACE_TYPES,
-} from '../daemon/ipc-protocol.js';
-import { uiShowTool } from '../tools/ui-surface/definitions.js';
+} from "../daemon/ipc-protocol.js";
+import { INTERACTIVE_SURFACE_TYPES } from "../daemon/ipc-protocol.js";
+import { uiShowTool } from "../tools/ui-surface/definitions.js";
 
 // ---------------------------------------------------------------------------
 // DynamicPageSurfaceData shape
 // ---------------------------------------------------------------------------
 
-describe('DynamicPageSurfaceData shape', () => {
-  test('accepts an object with html, width, and height', () => {
+describe("DynamicPageSurfaceData shape", () => {
+  test("accepts an object with html, width, and height", () => {
     const data: DynamicPageSurfaceData = {
-      html: '<h1>Hi</h1>',
+      html: "<h1>Hi</h1>",
       width: 400,
       height: 300,
     };
 
-    expect(data.html).toBe('<h1>Hi</h1>');
+    expect(data.html).toBe("<h1>Hi</h1>");
     expect(data.width).toBe(400);
     expect(data.height).toBe(300);
   });
 
-  test('width and height are optional', () => {
+  test("width and height are optional", () => {
     const data: DynamicPageSurfaceData = {
-      html: '<p>Hello</p>',
+      html: "<p>Hello</p>",
     };
 
-    expect(data.html).toBe('<p>Hello</p>');
+    expect(data.html).toBe("<p>Hello</p>");
     expect(data.width).toBeUndefined();
     expect(data.height).toBeUndefined();
   });
@@ -41,8 +39,8 @@ describe('DynamicPageSurfaceData shape', () => {
 // Tool definition includes dynamic_page
 // ---------------------------------------------------------------------------
 
-describe('Tool definition includes dynamic_page', () => {
-  test('input_schema surface_type enum includes dynamic_page', () => {
+describe("Tool definition includes dynamic_page", () => {
+  test("input_schema surface_type enum includes dynamic_page", () => {
     const definition = uiShowTool.getDefinition();
     const surfaceTypeEnum = (
       definition.input_schema as {
@@ -50,12 +48,12 @@ describe('Tool definition includes dynamic_page', () => {
       }
     ).properties.surface_type.enum;
 
-    expect(surfaceTypeEnum).toContain('dynamic_page');
+    expect(surfaceTypeEnum).toContain("dynamic_page");
   });
 
-  test('description mentions dynamic_page', () => {
+  test("description mentions dynamic_page", () => {
     const definition = uiShowTool.getDefinition();
-    expect(definition.description).toContain('dynamic_page');
+    expect(definition.description).toContain("dynamic_page");
   });
 });
 
@@ -63,21 +61,21 @@ describe('Tool definition includes dynamic_page', () => {
 // UiSurfaceShowDynamicPage structure
 // ---------------------------------------------------------------------------
 
-describe('UiSurfaceShowDynamicPage structure', () => {
-  test('can construct a well-typed UiSurfaceShowDynamicPage object', () => {
+describe("UiSurfaceShowDynamicPage structure", () => {
+  test("can construct a well-typed UiSurfaceShowDynamicPage object", () => {
     const msg: UiSurfaceShowDynamicPage = {
-      type: 'ui_surface_show',
-      sessionId: 'session-abc',
-      surfaceId: 'surface-123',
-      surfaceType: 'dynamic_page',
-      data: { html: '<div>Content</div>' },
+      type: "ui_surface_show",
+      sessionId: "session-abc",
+      surfaceId: "surface-123",
+      surfaceType: "dynamic_page",
+      data: { html: "<div>Content</div>" },
     };
 
-    expect(msg.type).toBe('ui_surface_show');
-    expect(msg.surfaceType).toBe('dynamic_page');
-    expect(typeof msg.data.html).toBe('string');
-    expect(msg.sessionId).toBe('session-abc');
-    expect(msg.surfaceId).toBe('surface-123');
+    expect(msg.type).toBe("ui_surface_show");
+    expect(msg.surfaceType).toBe("dynamic_page");
+    expect(typeof msg.data.html).toBe("string");
+    expect(msg.sessionId).toBe("session-abc");
+    expect(msg.surfaceId).toBe("surface-123");
   });
 });
 
@@ -85,8 +83,8 @@ describe('UiSurfaceShowDynamicPage structure', () => {
 // Interactivity
 // ---------------------------------------------------------------------------
 
-describe('dynamic_page interactivity', () => {
-  test('dynamic_page is in the interactive surface types list', () => {
-    expect(INTERACTIVE_SURFACE_TYPES).toContain('dynamic_page');
+describe("dynamic_page interactivity", () => {
+  test("dynamic_page is in the interactive surface types list", () => {
+    expect(INTERACTIVE_SURFACE_TYPES).toContain("dynamic_page");
   });
 });

package/src/__tests__/dynamic-skill-workflow-prompt.test.ts

@@ -1,35 +1,34 @@
-import { existsSync,mkdirSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { afterEach,beforeEach, describe, expect, test } from 'bun:test';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
 const TEST_DIR = join(tmpdir(), `vellum-dyn-skill-test-${crypto.randomUUID()}`);
 
-import { mock } from 'bun:test';
+import { mock } from "bun:test";
 
-mock.module('../util/platform.js', () => ({
+mock.module("../util/platform.js", () => ({
   getRootDir: () => TEST_DIR,
   getDataDir: () => TEST_DIR,
   getWorkspaceDir: () => TEST_DIR,
-  getWorkspaceConfigPath: () => join(TEST_DIR, 'config.json'),
-  getWorkspaceSkillsDir: () => join(TEST_DIR, 'skills'),
-  getWorkspaceHooksDir: () => join(TEST_DIR, 'hooks'),
+  getWorkspaceConfigPath: () => join(TEST_DIR, "config.json"),
+  getWorkspaceSkillsDir: () => join(TEST_DIR, "skills"),
+  getWorkspaceHooksDir: () => join(TEST_DIR, "hooks"),
   getWorkspacePromptPath: (file: string) => join(TEST_DIR, file),
   ensureDataDir: () => {},
-  getSocketPath: () => join(TEST_DIR, 'vellum.sock'),
-  getPidPath: () => join(TEST_DIR, 'vellum.pid'),
-  getDbPath: () => join(TEST_DIR, 'data', 'assistant.db'),
-  getLogPath: () => join(TEST_DIR, 'logs', 'vellum.log'),
-  getHistoryPath: () => join(TEST_DIR, 'history'),
-  getHooksDir: () => join(TEST_DIR, 'hooks'),
-  getIpcBlobDir: () => join(TEST_DIR, 'ipc-blobs'),
-  getSandboxRootDir: () => join(TEST_DIR, 'sandbox'),
+  getSocketPath: () => join(TEST_DIR, "vellum.sock"),
+  getPidPath: () => join(TEST_DIR, "vellum.pid"),
+  getDbPath: () => join(TEST_DIR, "data", "assistant.db"),
+  getLogPath: () => join(TEST_DIR, "logs", "vellum.log"),
+  getHistoryPath: () => join(TEST_DIR, "history"),
+  getHooksDir: () => join(TEST_DIR, "hooks"),
+  getIpcBlobDir: () => join(TEST_DIR, "ipc-blobs"),
+  getSandboxRootDir: () => join(TEST_DIR, "sandbox"),
   getSandboxWorkingDir: () => TEST_DIR,
-  getInterfacesDir: () => join(TEST_DIR, 'interfaces'),
-  isMacOS: () => process.platform === 'darwin',
-  isLinux: () => process.platform === 'linux',
-  isWindows: () => process.platform === 'win32',
+  getInterfacesDir: () => join(TEST_DIR, "interfaces"),
+  isMacOS: () => process.platform === "darwin",
+  isLinux: () => process.platform === "linux",
+  isWindows: () => process.platform === "win32",
   getPlatformName: () => process.platform,
   getClipboardCommand: () => null,
   removeSocketFile: () => {},
@@ -38,17 +37,18 @@ mock.module('../util/platform.js', () => ({
   migrateToDataLayout: () => {},
 }));
 
-mock.module('../util/logger.js', () => ({
-  getLogger: () => new Proxy({} as Record<string, unknown>, {
-    get: () => () => {},
-  }),
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
   isDebug: () => false,
   truncateForLog: (v: string) => v,
 }));
 
-const { buildSystemPrompt } = await import('../config/system-prompt.js');
+const { buildSystemPrompt } = await import("../config/system-prompt.js");
 
-describe('Dynamic Skill Authoring Workflow prompt section', () => {
+describe("Dynamic Skill Authoring Workflow prompt section", () => {
   beforeEach(() => {
     mkdirSync(TEST_DIR, { recursive: true });
   });
@@ -59,77 +59,77 @@ describe('Dynamic Skill Authoring Workflow prompt section', () => {
     }
   });
 
-  test('buildSystemPrompt includes dynamic skill workflow section', () => {
-    writeFileSync(join(TEST_DIR, 'IDENTITY.md'), 'I am Vellum.');
+  test("buildSystemPrompt includes dynamic skill workflow section", () => {
+    writeFileSync(join(TEST_DIR, "IDENTITY.md"), "I am Vellum.");
     const result = buildSystemPrompt();
-    expect(result).toContain('## Dynamic Skill Authoring Workflow');
+    expect(result).toContain("## Dynamic Skill Authoring Workflow");
   });
 
-  test('workflow section mentions scaffold and delete tools and bun run workflow', () => {
-    writeFileSync(join(TEST_DIR, 'IDENTITY.md'), 'I am Vellum.');
+  test("workflow section mentions scaffold and delete tools and bun run workflow", () => {
+    writeFileSync(join(TEST_DIR, "IDENTITY.md"), "I am Vellum.");
     const result = buildSystemPrompt();
-    expect(result).toContain('bun run /tmp/vellum-eval/snippet.ts');
-    expect(result).toContain('scaffold_managed_skill');
-    expect(result).toContain('delete_managed_skill');
+    expect(result).toContain("bun run /tmp/vellum-eval/snippet.ts");
+    expect(result).toContain("scaffold_managed_skill");
+    expect(result).toContain("delete_managed_skill");
   });
 
-  test('workflow section includes user confirmation warning', () => {
-    writeFileSync(join(TEST_DIR, 'IDENTITY.md'), 'I am Vellum.');
+  test("workflow section includes user confirmation warning", () => {
+    writeFileSync(join(TEST_DIR, "IDENTITY.md"), "I am Vellum.");
     const result = buildSystemPrompt();
-    expect(result).toContain('explicit user confirmation');
+    expect(result).toContain("explicit user confirmation");
   });
 
-  test('workflow section includes retry limit guidance', () => {
-    writeFileSync(join(TEST_DIR, 'IDENTITY.md'), 'I am Vellum.');
+  test("workflow section includes retry limit guidance", () => {
+    writeFileSync(join(TEST_DIR, "IDENTITY.md"), "I am Vellum.");
     const result = buildSystemPrompt();
-    expect(result).toContain('3 attempts');
+    expect(result).toContain("3 attempts");
   });
 
-  test('workflow section includes session eviction note', () => {
-    writeFileSync(join(TEST_DIR, 'IDENTITY.md'), 'I am Vellum.');
+  test("workflow section includes session eviction note", () => {
+    writeFileSync(join(TEST_DIR, "IDENTITY.md"), "I am Vellum.");
     const result = buildSystemPrompt();
-    expect(result).toContain('recreated session');
+    expect(result).toContain("recreated session");
   });
 
-  test('prompt still includes available skills catalog when skills exist', () => {
-    const skillsDir = join(TEST_DIR, 'skills');
-    mkdirSync(join(skillsDir, 'test-skill'), { recursive: true });
+  test("prompt still includes available skills catalog when skills exist", () => {
+    const skillsDir = join(TEST_DIR, "skills");
+    mkdirSync(join(skillsDir, "test-skill"), { recursive: true });
     writeFileSync(
-      join(skillsDir, 'test-skill', 'SKILL.md'),
+      join(skillsDir, "test-skill", "SKILL.md"),
       '---\nname: "Test Skill"\ndescription: "For testing."\n---\n\nDo testing.\n',
     );
-    writeFileSync(join(skillsDir, 'SKILLS.md'), '- test-skill\n');
-    writeFileSync(join(TEST_DIR, 'IDENTITY.md'), 'I am Vellum.');
+    writeFileSync(join(skillsDir, "SKILLS.md"), "- test-skill\n");
+    writeFileSync(join(TEST_DIR, "IDENTITY.md"), "I am Vellum.");
 
     const result = buildSystemPrompt();
-    expect(result).toContain('## Available Skills');
+    expect(result).toContain("## Available Skills");
     expect(result).toContain('id="test-skill"');
-    expect(result).toContain('## Dynamic Skill Authoring Workflow');
+    expect(result).toContain("## Dynamic Skill Authoring Workflow");
   });
 
-  test('prompt is additive with IDENTITY/SOUL/USER files', () => {
-    writeFileSync(join(TEST_DIR, 'IDENTITY.md'), 'Identity here');
-    writeFileSync(join(TEST_DIR, 'SOUL.md'), 'Soul here');
-    writeFileSync(join(TEST_DIR, 'USER.md'), 'User here');
+  test("prompt is additive with IDENTITY/SOUL/USER files", () => {
+    writeFileSync(join(TEST_DIR, "IDENTITY.md"), "Identity here");
+    writeFileSync(join(TEST_DIR, "SOUL.md"), "Soul here");
+    writeFileSync(join(TEST_DIR, "USER.md"), "User here");
 
     const result = buildSystemPrompt();
-    expect(result).toContain('Identity here');
-    expect(result).toContain('Soul here');
-    expect(result).toContain('User here');
-    expect(result).toContain('## Dynamic Skill Authoring Workflow');
+    expect(result).toContain("Identity here");
+    expect(result).toContain("Soul here");
+    expect(result).toContain("User here");
+    expect(result).toContain("## Dynamic Skill Authoring Workflow");
   });
 
-  test('workflow section includes skill_load instruction', () => {
-    writeFileSync(join(TEST_DIR, 'IDENTITY.md'), 'I am Vellum.');
+  test("workflow section includes skill_load instruction", () => {
+    writeFileSync(join(TEST_DIR, "IDENTITY.md"), "I am Vellum.");
     const result = buildSystemPrompt();
-    expect(result).toContain('skill_load');
+    expect(result).toContain("skill_load");
   });
 
-  test('system prompt includes browser skill prerequisite guidance', () => {
-    writeFileSync(join(TEST_DIR, 'IDENTITY.md'), 'I am Vellum.');
+  test("system prompt includes browser skill prerequisite guidance", () => {
+    writeFileSync(join(TEST_DIR, "IDENTITY.md"), "I am Vellum.");
     const result = buildSystemPrompt();
-    expect(result).toContain('Browser Skill Prerequisite');
-    expect(result).toContain('browser_*');
-    expect(result).toContain('skill_load');
+    expect(result).toContain("Browser Skill Prerequisite");
+    expect(result).toContain("browser_*");
+    expect(result).toContain("skill_load");
   });
 });

package/src/__tests__/edit-engine.test.ts

@@ -1,64 +1,64 @@
-import { describe, expect, test } from 'bun:test';
+import { describe, expect, test } from "bun:test";
 
-import { applyEdit } from '../tools/shared/filesystem/edit-engine.js';
+import { applyEdit } from "../tools/shared/filesystem/edit-engine.js";
 
-describe('edit engine', () => {
+describe("edit engine", () => {
   // -----------------------------------------------------------------------
   // Exact unique replacement
   // -----------------------------------------------------------------------
 
-  test('exact unique replacement', () => {
-    const content = 'hello world\n';
-    const result = applyEdit(content, 'hello world', 'updated', false);
+  test("exact unique replacement", () => {
+    const content = "hello world\n";
+    const result = applyEdit(content, "hello world", "updated", false);
 
     expect(result.ok).toBe(true);
     if (!result.ok) return;
-    expect(result.updatedContent).toBe('updated\n');
+    expect(result.updatedContent).toBe("updated\n");
     expect(result.matchCount).toBe(1);
-    expect(result.matchMethod).toBe('exact');
+    expect(result.matchMethod).toBe("exact");
     expect(result.similarity).toBe(1);
   });
 
-  test('exact replacement in multi-line content', () => {
-    const content = 'line one\nline two\nline three\n';
-    const result = applyEdit(content, 'line two', 'replaced', false);
+  test("exact replacement in multi-line content", () => {
+    const content = "line one\nline two\nline three\n";
+    const result = applyEdit(content, "line two", "replaced", false);
 
     expect(result.ok).toBe(true);
     if (!result.ok) return;
-    expect(result.updatedContent).toBe('line one\nreplaced\nline three\n');
-    expect(result.matchMethod).toBe('exact');
+    expect(result.updatedContent).toBe("line one\nreplaced\nline three\n");
+    expect(result.matchMethod).toBe("exact");
   });
 
   // -----------------------------------------------------------------------
   // Whitespace/fuzzy match behavior
   // -----------------------------------------------------------------------
 
-  test('whitespace-normalized match when exact fails', () => {
+  test("whitespace-normalized match when exact fails", () => {
     // Content has extra leading whitespace vs. the search string
-    const content = '  function foo() {\n    return 1;\n  }\n';
-    const oldString = 'function foo() {\n  return 1;\n}';
-    const newString = 'function bar() {\n  return 2;\n}';
+    const content = "  function foo() {\n    return 1;\n  }\n";
+    const oldString = "function foo() {\n  return 1;\n}";
+    const newString = "function bar() {\n  return 2;\n}";
     const result = applyEdit(content, oldString, newString, false);
 
     expect(result.ok).toBe(true);
     if (!result.ok) return;
-    expect(result.matchMethod).toBe('whitespace');
+    expect(result.matchMethod).toBe("whitespace");
     expect(result.matchCount).toBe(1);
     expect(result.similarity).toBe(1);
     // The indentation should be adjusted
-    expect(result.updatedContent).toContain('function bar()');
+    expect(result.updatedContent).toContain("function bar()");
   });
 
-  test('fuzzy match when whitespace match also fails', () => {
+  test("fuzzy match when whitespace match also fails", () => {
     // Content has a slightly different line from oldString (typo-level difference)
-    const content = 'function fooo() {\n  return 1;\n}\n';
-    const oldString = 'function foo() {\n  return 1;\n}';
-    const newString = 'function bar() {\n  return 2;\n}';
+    const content = "function fooo() {\n  return 1;\n}\n";
+    const oldString = "function foo() {\n  return 1;\n}";
+    const newString = "function bar() {\n  return 2;\n}";
     const result = applyEdit(content, oldString, newString, false);
 
     expect(result.ok).toBe(true);
     if (!result.ok) return;
-    expect(result.matchMethod).toBe('fuzzy');
+    expect(result.matchMethod).toBe("fuzzy");
     expect(result.matchCount).toBe(1);
     expect(result.similarity).toBeGreaterThan(0.8);
     expect(result.similarity).toBeLessThan(1);
@@ -68,25 +68,25 @@ describe('edit engine', () => {
   // Ambiguous behavior
   // -----------------------------------------------------------------------
 
-  test('ambiguous: returns error when old_string appears multiple times', () => {
-    const content = 'repeat\nrepeat\n';
-    const result = applyEdit(content, 'repeat', 'new', false);
+  test("ambiguous: returns error when old_string appears multiple times", () => {
+    const content = "repeat\nrepeat\n";
+    const result = applyEdit(content, "repeat", "new", false);
 
     expect(result.ok).toBe(false);
     if (result.ok) return;
-    expect(result.reason).toBe('ambiguous');
-    if (result.reason !== 'ambiguous') return;
+    expect(result.reason).toBe("ambiguous");
+    if (result.reason !== "ambiguous") return;
     expect(result.matchCount).toBe(2);
   });
 
-  test('ambiguous: three occurrences reports correct count', () => {
-    const content = 'x\nx\nx\n';
-    const result = applyEdit(content, 'x', 'y', false);
+  test("ambiguous: three occurrences reports correct count", () => {
+    const content = "x\nx\nx\n";
+    const result = applyEdit(content, "x", "y", false);
 
     expect(result.ok).toBe(false);
     if (result.ok) return;
-    expect(result.reason).toBe('ambiguous');
-    if (result.reason !== 'ambiguous') return;
+    expect(result.reason).toBe("ambiguous");
+    if (result.reason !== "ambiguous") return;
     expect(result.matchCount).toBe(3);
   });
 
@@ -94,55 +94,55 @@ describe('edit engine', () => {
   // Not found
   // -----------------------------------------------------------------------
 
-  test('not found: returns error when old_string is absent', () => {
-    const content = 'hello world\n';
-    const result = applyEdit(content, 'nonexistent', 'replacement', false);
+  test("not found: returns error when old_string is absent", () => {
+    const content = "hello world\n";
+    const result = applyEdit(content, "nonexistent", "replacement", false);
 
     expect(result.ok).toBe(false);
     if (result.ok) return;
-    expect(result.reason).toBe('not_found');
+    expect(result.reason).toBe("not_found");
   });
 
   // -----------------------------------------------------------------------
   // replace_all count correctness
   // -----------------------------------------------------------------------
 
-  test('replace_all: replaces all occurrences and reports correct count', () => {
-    const content = 'x\ny\nx\nz\nx\n';
-    const result = applyEdit(content, 'x', 'replaced', true);
+  test("replace_all: replaces all occurrences and reports correct count", () => {
+    const content = "x\ny\nx\nz\nx\n";
+    const result = applyEdit(content, "x", "replaced", true);
 
     expect(result.ok).toBe(true);
     if (!result.ok) return;
-    expect(result.updatedContent).toBe('replaced\ny\nreplaced\nz\nreplaced\n');
+    expect(result.updatedContent).toBe("replaced\ny\nreplaced\nz\nreplaced\n");
     expect(result.matchCount).toBe(3);
-    expect(result.matchMethod).toBe('exact');
+    expect(result.matchMethod).toBe("exact");
     expect(result.similarity).toBe(1);
   });
 
-  test('replace_all: single occurrence reports count of 1', () => {
-    const content = 'a b c\n';
-    const result = applyEdit(content, 'b', 'B', true);
+  test("replace_all: single occurrence reports count of 1", () => {
+    const content = "a b c\n";
+    const result = applyEdit(content, "b", "B", true);
 
     expect(result.ok).toBe(true);
     if (!result.ok) return;
-    expect(result.updatedContent).toBe('a B c\n');
+    expect(result.updatedContent).toBe("a B c\n");
     expect(result.matchCount).toBe(1);
   });
 
-  test('replace_all: not found returns error', () => {
-    const content = 'hello world\n';
-    const result = applyEdit(content, 'missing', 'nope', true);
+  test("replace_all: not found returns error", () => {
+    const content = "hello world\n";
+    const result = applyEdit(content, "missing", "nope", true);
 
     expect(result.ok).toBe(false);
     if (result.ok) return;
-    expect(result.reason).toBe('not_found');
+    expect(result.reason).toBe("not_found");
   });
 
   // -----------------------------------------------------------------------
   // Executor preview parity: same engine, same output
   // -----------------------------------------------------------------------
 
-  test('executor preview parity: computed preview matches actual edit output', () => {
+  test("executor preview parity: computed preview matches actual edit output", () => {
     // Simulate what both the executor preview and tool execution do:
     // both call applyEdit with the same inputs and should get identical results.
     const content = 'function hello() {\n  console.log("hi");\n}\n';
@@ -163,10 +163,10 @@ describe('edit engine', () => {
     expect(preview.matchMethod).toBe(execution.matchMethod);
   });
 
-  test('executor preview parity: replace_all mode', () => {
-    const content = 'TODO\nsome code\nTODO\n';
-    const oldString = 'TODO';
-    const newString = 'DONE';
+  test("executor preview parity: replace_all mode", () => {
+    const content = "TODO\nsome code\nTODO\n";
+    const oldString = "TODO";
+    const newString = "DONE";
 
     const preview = applyEdit(content, oldString, newString, true);
     const execution = applyEdit(content, oldString, newString, true);