@alumbwe/anvil 1.0.20 → 1.0.22

package/vendor/@anvil/common/src/tools/constants.ts

@@ -0,0 +1,117 @@
+import { COMPOSIO_META_TOOL_NAMES } from '../constants/composio'
+
+import type { ToolResultOutput } from '../types/messages/content-part'
+import type { Tool } from 'ai'
+
+export const toolNameParam = 'cb_tool_name'
+export const endsAgentStepParam = 'cb_easp'
+export const toolXmlName = 'anvil_tool_call'
+export const startToolTag = `<${toolXmlName}>\n`
+export const endToolTag = `\n</${toolXmlName}>`
+
+export const TOOLS_WHICH_WONT_FORCE_NEXT_STEP = [
+  'think_deeply',
+  'set_output',
+  'set_messages',
+  'add_message',
+  'update_subgoal',
+  'create_plan',
+  'render_ui',
+  'suggest_followups',
+  'suggest_prompts',
+  'task_completed',
+]
+
+// List of all available tools
+export const toolNames = [
+  'apply_patch',
+  'add_subgoal',
+  'add_message',
+  'ask_user',
+  'browser_logs',
+  'code_search',
+  'cloud_plan_ready',
+  'create_plan',
+  'end_turn',
+  'find_files',
+  'glob',
+  'gravity_index',
+  'list_directory',
+  'lookup_agent_info',
+  'propose_str_replace',
+  'propose_write_file',
+  'read_docs',
+  'read_files',
+  'read_subtree',
+  'read_url',
+  'render_ui',
+  'run_file_change_hooks',
+  'run_terminal_command',
+  'set_messages',
+  'set_output',
+  'skill',
+  'spawn_agents',
+  'spawn_agent_inline',
+  'str_replace',
+  'suggest_followups',
+  'task_completed',
+  'think_deeply',
+  'update_subgoal',
+  'screenshot',
+  'vision_analyze',
+  'web_search',
+  'write_file',
+  'write_todos',
+  ...COMPOSIO_META_TOOL_NAMES,
+] as const
+
+export const publishedTools = [
+  'apply_patch',
+  'add_message',
+  'ask_user',
+  'code_search',
+  'cloud_plan_ready',
+  'end_turn',
+  'find_files',
+  'glob',
+  'gravity_index',
+  'list_directory',
+  'lookup_agent_info',
+  'propose_str_replace',
+  'propose_write_file',
+  'read_docs',
+  'read_files',
+  'read_subtree',
+  'read_url',
+  'render_ui',
+  'run_file_change_hooks',
+  'run_terminal_command',
+  'screenshot',
+  'vision_analyze',
+  'set_messages',
+  'set_output',
+  'skill',
+  'spawn_agents',
+  'str_replace',
+  'suggest_followups',
+  'task_completed',
+  'think_deeply',
+  'web_search',
+  'write_file',
+  'write_todos',
+  // 'spawn_agent_inline',
+] as const
+
+export type ToolName = (typeof toolNames)[number]
+export type PublishedToolName = (typeof publishedTools)[number]
+
+/** Only used for validating tool definitions */
+export type $ToolParams<T extends ToolName = ToolName> = Required<
+  Pick<
+    Tool<any, ToolResultOutput[]>,
+    'description' | 'inputSchema' | 'outputSchema'
+  >
+> & {
+  toolName: T
+  endsAgentStep: boolean
+}

package/vendor/@anvil/common/src/tools/list.ts

@@ -0,0 +1,190 @@
+import z from 'zod/v4'
+
+import { FileChangeSchema } from '../actions'
+import { addMessageParams } from './params/tool/add-message'
+import { addSubgoalParams } from './params/tool/add-subgoal'
+import { applyPatchParams } from './params/tool/apply-patch'
+import { askUserParams } from './params/tool/ask-user'
+import { browserLogsParams } from './params/tool/browser-logs'
+import { codeSearchParams } from './params/tool/code-search'
+import { cloudPlanReadyParams } from './params/tool/cloud-plan-ready'
+import { composioMetaToolParams } from './params/tool/composio'
+import { createPlanParams } from './params/tool/create-plan'
+import { endTurnParams } from './params/tool/end-turn'
+import { findFilesParams } from './params/tool/find-files'
+import { globParams } from './params/tool/glob'
+import { gravityIndexParams } from './params/tool/gravity-index'
+import { listDirectoryParams } from './params/tool/list-directory'
+import { lookupAgentInfoParams } from './params/tool/lookup-agent-info'
+import { proposeStrReplaceParams } from './params/tool/propose-str-replace'
+import { proposeWriteFileParams } from './params/tool/propose-write-file'
+import { readDocsParams } from './params/tool/read-docs'
+import { readFilesParams } from './params/tool/read-files'
+import { readSubtreeParams } from './params/tool/read-subtree'
+import { readUrlParams } from './params/tool/read-url'
+import { renderUIParams } from './params/tool/render-ui'
+import { runFileChangeHooksParams } from './params/tool/run-file-change-hooks'
+import { screenshotParams } from './params/tool/screenshot'
+import { visionAnalyzeParams } from './params/tool/vision-analyze'
+import { runTerminalCommandParams } from './params/tool/run-terminal-command'
+import { setMessagesParams } from './params/tool/set-messages'
+import { setOutputParams } from './params/tool/set-output'
+import { skillParams } from './params/tool/skill'
+import { spawnAgentInlineParams } from './params/tool/spawn-agent-inline'
+import { spawnAgentsParams } from './params/tool/spawn-agents'
+import { strReplaceParams } from './params/tool/str-replace'
+import { suggestFollowupsParams } from './params/tool/suggest-followups'
+import { taskCompletedParams } from './params/tool/task-completed'
+import { thinkDeeplyParams } from './params/tool/think-deeply'
+import { updateSubgoalParams } from './params/tool/update-subgoal'
+import { webSearchParams } from './params/tool/web-search'
+import { writeFileParams } from './params/tool/write-file'
+import { writeTodosParams } from './params/tool/write-todos'
+
+import type { $ToolParams, PublishedToolName, ToolName } from './constants'
+import type { ToolMessage } from '../types/messages/anvil-message'
+import type { ToolCallPart } from '../types/messages/content-part'
+
+export const toolParams = {
+  add_message: addMessageParams,
+  add_subgoal: addSubgoalParams,
+  apply_patch: applyPatchParams,
+  ask_user: askUserParams,
+  browser_logs: browserLogsParams,
+  code_search: codeSearchParams,
+  cloud_plan_ready: cloudPlanReadyParams,
+  create_plan: createPlanParams,
+  end_turn: endTurnParams,
+  find_files: findFilesParams,
+  glob: globParams,
+  gravity_index: gravityIndexParams,
+  list_directory: listDirectoryParams,
+  lookup_agent_info: lookupAgentInfoParams,
+  propose_str_replace: proposeStrReplaceParams,
+  propose_write_file: proposeWriteFileParams,
+  read_docs: readDocsParams,
+  read_files: readFilesParams,
+  read_subtree: readSubtreeParams,
+  read_url: readUrlParams,
+  render_ui: renderUIParams,
+  run_file_change_hooks: runFileChangeHooksParams,
+  run_terminal_command: runTerminalCommandParams,
+  set_messages: setMessagesParams,
+  set_output: setOutputParams,
+  skill: skillParams,
+  spawn_agents: spawnAgentsParams,
+  spawn_agent_inline: spawnAgentInlineParams,
+  str_replace: strReplaceParams,
+  suggest_followups: suggestFollowupsParams,
+  task_completed: taskCompletedParams,
+  think_deeply: thinkDeeplyParams,
+  update_subgoal: updateSubgoalParams,
+  screenshot: screenshotParams,
+  vision_analyze: visionAnalyzeParams,
+  web_search: webSearchParams,
+  write_file: writeFileParams,
+  write_todos: writeTodosParams,
+  ...composioMetaToolParams,
+} satisfies {
+  [K in ToolName]: $ToolParams<K>
+}
+
+// Tool call from LLM after parsing
+export type AnvilToolCall<T extends ToolName = ToolName> = {
+  [K in ToolName]: {
+    toolName: K
+    input: z.infer<(typeof toolParams)[K]['inputSchema']>
+  } & Omit<ToolCallPart, 'type'>
+}[T]
+
+export type AnvilToolOutput<T extends ToolName = ToolName> = {
+  [K in ToolName]: K extends ToolName
+    ? z.infer<(typeof toolParams)[K]['outputSchema']>
+    : never
+}[T]
+
+export type AnvilToolMessage<T extends ToolName = ToolName> = ToolMessage & {
+  content: AnvilToolOutput<T>
+}
+
+// Tool call to send to client
+export const clientToolCallSchema = z.discriminatedUnion('toolName', [
+  z.object({
+    toolName: z.literal('apply_patch'),
+    input: toolParams.apply_patch.inputSchema,
+  }),
+  z.object({
+    toolName: z.literal('ask_user'),
+    input: toolParams.ask_user.inputSchema,
+  }),
+  z.object({
+    toolName: z.literal('browser_logs'),
+    input: toolParams.browser_logs.inputSchema,
+  }),
+  z.object({
+    toolName: z.literal('code_search'),
+    input: toolParams.code_search.inputSchema,
+  }),
+  z.object({
+    toolName: z.literal('create_plan'),
+    input: FileChangeSchema,
+  }),
+  z.object({
+    toolName: z.literal('glob'),
+    input: toolParams.glob.inputSchema,
+  }),
+  z.object({
+    toolName: z.literal('list_directory'),
+    input: toolParams.list_directory.inputSchema,
+  }),
+  z.object({
+    toolName: z.literal('run_file_change_hooks'),
+    input: toolParams.run_file_change_hooks.inputSchema,
+  }),
+  z.object({
+    toolName: z.literal('read_url'),
+    input: toolParams.read_url.inputSchema,
+  }),
+  z.object({
+    toolName: z.literal('run_terminal_command'),
+    input: toolParams.run_terminal_command.inputSchema.and(
+      z.object({ mode: z.enum(['assistant', 'user']) }),
+    ),
+  }),
+  z.object({
+    toolName: z.literal('str_replace'),
+    input: FileChangeSchema,
+  }),
+  z.object({
+    toolName: z.literal('write_file'),
+    input: FileChangeSchema,
+  }),
+  z.object({
+    toolName: z.literal('composio_manage_connections'),
+    input: toolParams.composio_manage_connections.inputSchema,
+  }),
+  z.object({
+    toolName: z.literal('composio_multi_execute_tool'),
+    input: toolParams.composio_multi_execute_tool.inputSchema,
+  }),
+  z.object({
+    toolName: z.literal('composio_search_tools'),
+    input: toolParams.composio_search_tools.inputSchema,
+  }),
+  z.object({
+    toolName: z.literal('composio_get_tool_schemas'),
+    input: toolParams.composio_get_tool_schemas.inputSchema,
+  }),
+])
+export const clientToolNames = clientToolCallSchema.def.options.map(
+  (opt) => opt.shape.toolName.value,
+) satisfies ToolName[]
+export type ClientToolName = (typeof clientToolNames)[number]
+
+export type ClientToolCall<T extends ClientToolName = ClientToolName> = Extract<
+  z.infer<typeof clientToolCallSchema>,
+  { toolName: T }
+> &
+  Pick<ToolCallPart, 'toolCallId' | 'toolName' | 'input' | 'providerOptions'>
+
+export type PublishedClientToolName = Extract<ClientToolName, PublishedToolName>

package/vendor/@anvil/common/src/tools/params/__tests__/coerce-to-array.test.ts

@@ -0,0 +1,213 @@
+import { describe, expect, it } from 'bun:test'
+import z from 'zod/v4'
+
+import {
+  coerceToArray,
+  coerceToObject,
+  normalizeReplacementAliases,
+} from '../utils'
+
+describe('coerceToArray', () => {
+  it('passes through arrays unchanged', () => {
+    expect(coerceToArray(['a', 'b'])).toEqual(['a', 'b'])
+    expect(coerceToArray([{ old: 'x', new: 'y' }])).toEqual([
+      { old: 'x', new: 'y' },
+    ])
+    expect(coerceToArray([])).toEqual([])
+  })
+
+  it('wraps a single string in an array', () => {
+    expect(coerceToArray('file.ts')).toEqual(['file.ts'])
+  })
+
+  it('wraps a single object in an array', () => {
+    expect(coerceToArray({ old: 'x', new: 'y' })).toEqual([
+      { old: 'x', new: 'y' },
+    ])
+  })
+
+  it('wraps a single number in an array', () => {
+    expect(coerceToArray(42)).toEqual([42])
+  })
+
+  it('parses a stringified JSON array', () => {
+    expect(coerceToArray('["file1.ts", "file2.ts"]')).toEqual([
+      'file1.ts',
+      'file2.ts',
+    ])
+  })
+
+  it('wraps a non-JSON string (does not parse as array)', () => {
+    expect(coerceToArray('not-json')).toEqual(['not-json'])
+  })
+
+  it('wraps a stringified JSON object (not an array) in an array', () => {
+    expect(coerceToArray('{"key": "value"}')).toEqual(['{"key": "value"}'])
+  })
+
+  it('passes through null', () => {
+    expect(coerceToArray(null)).toBeNull()
+  })
+
+  it('passes through undefined', () => {
+    expect(coerceToArray(undefined)).toBeUndefined()
+  })
+})
+
+describe('coerceToObject', () => {
+  it('passes through objects unchanged', () => {
+    expect(coerceToObject({ key: 'value' })).toEqual({ key: 'value' })
+  })
+
+  it('parses a stringified JSON object', () => {
+    expect(coerceToObject('{"key": "value"}')).toEqual({ key: 'value' })
+  })
+
+  it('leaves non-JSON strings untouched', () => {
+    expect(coerceToObject('not-json')).toBe('not-json')
+  })
+
+  it('passes through arrays and primitives so validation can reject them', () => {
+    expect(coerceToObject(['a'])).toEqual(['a'])
+    expect(coerceToObject(1)).toBe(1)
+  })
+})
+
+describe('coerceToArray with Zod schemas', () => {
+  it('coerces a single string into an array for z.array(z.string())', () => {
+    const schema = z.object({
+      paths: z.preprocess(coerceToArray, z.array(z.string())),
+    })
+    const result = schema.safeParse({ paths: 'file.ts' })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.paths).toEqual(['file.ts'])
+    }
+  })
+
+  it('coerces a single object into an array for z.array(z.object(...))', () => {
+    const schema = z.object({
+      replacements: z.preprocess(
+        coerceToArray,
+        z.array(z.object({ old: z.string(), new: z.string() })),
+      ),
+    })
+    const result = schema.safeParse({ replacements: { old: 'x', new: 'y' } })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.replacements).toEqual([{ old: 'x', new: 'y' }])
+    }
+  })
+
+  it('still validates correctly when already an array', () => {
+    const schema = z.object({
+      paths: z.preprocess(coerceToArray, z.array(z.string())),
+    })
+    const result = schema.safeParse({ paths: ['a.ts', 'b.ts'] })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.paths).toEqual(['a.ts', 'b.ts'])
+    }
+  })
+
+  it('still rejects invalid inner types after coercion', () => {
+    const schema = z.object({
+      paths: z.preprocess(coerceToArray, z.array(z.string())),
+    })
+    const result = schema.safeParse({ paths: 123 })
+    expect(result.success).toBe(false)
+  })
+
+  it('works with optional arrays', () => {
+    const schema = z.object({
+      paths: z.preprocess(coerceToArray, z.array(z.string())).optional(),
+    })
+    const withValue = schema.safeParse({ paths: 'file.ts' })
+    expect(withValue.success).toBe(true)
+    if (withValue.success) {
+      expect(withValue.data.paths).toEqual(['file.ts'])
+    }
+
+    const withoutValue = schema.safeParse({})
+    expect(withoutValue.success).toBe(true)
+    if (withoutValue.success) {
+      expect(withoutValue.data.paths).toBeUndefined()
+    }
+  })
+
+  it('produces identical JSON schema with or without preprocess', () => {
+    const plain = z.object({ paths: z.array(z.string()) })
+    const coerced = z.object({
+      paths: z.preprocess(coerceToArray, z.array(z.string())),
+    })
+
+    const plainSchema = z.toJSONSchema(plain, { io: 'input' })
+    const coercedSchema = z.toJSONSchema(coerced, { io: 'input' })
+    expect(coercedSchema).toEqual(plainSchema)
+  })
+})
+
+describe('coerceToObject with Zod schemas', () => {
+  it('produces identical JSON schema with or without preprocess', () => {
+    const plain = z.object({
+      params: z.record(z.string(), z.any()).optional(),
+    })
+    const coerced = z.object({
+      params: z
+        .preprocess(coerceToObject, z.record(z.string(), z.any()))
+        .optional(),
+    })
+
+    const plainSchema = z.toJSONSchema(plain, { io: 'input' })
+    const coercedSchema = z.toJSONSchema(coerced, { io: 'input' })
+    expect(coercedSchema).toEqual(plainSchema)
+  })
+})
+
+describe('normalizeReplacementAliases', () => {
+  it('maps old_str and new_str onto the documented replacement keys', () => {
+    expect(
+      normalizeReplacementAliases({
+        old_str: 'before',
+        new_str: 'after',
+        allowMultiple: true,
+      }),
+    ).toEqual({
+      old_str: 'before',
+      new_str: 'after',
+      oldString: 'before',
+      newString: 'after',
+      allowMultiple: true,
+    })
+  })
+
+  it('maps old_string and new_string onto the documented replacement keys', () => {
+    expect(
+      normalizeReplacementAliases({
+        old_string: 'before',
+        new_string: 'after',
+      }),
+    ).toEqual({
+      old_string: 'before',
+      new_string: 'after',
+      oldString: 'before',
+      newString: 'after',
+    })
+  })
+
+  it('does not overwrite documented replacement keys', () => {
+    expect(
+      normalizeReplacementAliases({
+        oldString: 'before',
+        newString: 'after',
+        old_str: 'ignored',
+        new_str: 'ignored',
+      }),
+    ).toEqual({
+      oldString: 'before',
+      newString: 'after',
+      old_str: 'ignored',
+      new_str: 'ignored',
+    })
+  })
+})

package/vendor/@anvil/common/src/tools/params/__tests__/read-docs.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, test } from 'bun:test'
+
+import { readDocsParams } from '../tool/read-docs'
+
+describe('read_docs parameters', () => {
+  test('trims text inputs and defaults max_tokens', () => {
+    const result = readDocsParams.inputSchema.parse({
+      libraryTitle: '  React  ',
+      topic: '  hooks  ',
+    })
+
+    expect(result).toEqual({
+      libraryTitle: 'React',
+      topic: 'hooks',
+      max_tokens: 10_000,
+    })
+  })
+
+  test('rejects empty text and invalid token counts', () => {
+    expect(
+      readDocsParams.inputSchema.safeParse({
+        libraryTitle: '   ',
+        topic: 'hooks',
+      }).success,
+    ).toBe(false)
+    expect(
+      readDocsParams.inputSchema.safeParse({
+        libraryTitle: 'React',
+        topic: '   ',
+      }).success,
+    ).toBe(false)
+    expect(
+      readDocsParams.inputSchema.safeParse({
+        libraryTitle: 'React',
+        topic: 'hooks',
+        max_tokens: -1,
+      }).success,
+    ).toBe(false)
+    expect(
+      readDocsParams.inputSchema.safeParse({
+        libraryTitle: 'React',
+        topic: 'hooks',
+        max_tokens: 1.5,
+      }).success,
+    ).toBe(false)
+  })
+})

package/vendor/@anvil/common/src/tools/params/__tests__/render-ui.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, it } from 'bun:test'
+
+import { parseRenderUIButtonWidget } from '../tool/render-ui'
+
+describe('parseRenderUIButtonWidget', () => {
+  it('preserves the resolved URL exactly', () => {
+    const link =
+      'https://index.trygravity.ai/go/resend?token=a%2Fb&opaque=(keep)'
+
+    expect(
+      parseRenderUIButtonWidget({
+        type: 'button',
+        text: ' Get Resend ',
+        link,
+        variant: 'secondary',
+      }),
+    ).toEqual({
+      type: 'button',
+      text: 'Get Resend',
+      link,
+      variant: 'secondary',
+    })
+  })
+
+  it('defaults the visual variant and rejects unsafe or unresolved links', () => {
+    expect(
+      parseRenderUIButtonWidget({
+        type: 'button',
+        text: 'Open',
+        link: 'https://example.com',
+      }),
+    ).toEqual({
+      type: 'button',
+      text: 'Open',
+      link: 'https://example.com',
+      variant: 'primary',
+    })
+
+    expect(
+      parseRenderUIButtonWidget({
+        type: 'button',
+        text: 'Bad',
+        link: 'javascript:alert(1)',
+      }),
+    ).toBeNull()
+    expect(
+      parseRenderUIButtonWidget({
+        type: 'button',
+        text: 'Padded',
+        link: ' https://example.com ',
+      }),
+    ).toBeNull()
+    expect(
+      parseRenderUIButtonWidget({
+        type: 'button',
+        text: 'Unresolved',
+        link: {
+          source: 'gravity_index',
+          search_id: 's1',
+          service_slug: 'resend',
+        },
+      }),
+    ).toBeNull()
+  })
+})

package/vendor/@anvil/common/src/tools/params/tool/__tests__/run-terminal-command-timeout.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, it } from 'bun:test'
+
+import {
+  clampTerminalTimeoutSeconds,
+  MAX_TERMINAL_TIMEOUT_SECONDS,
+} from '../run-terminal-command'
+
+describe('clampTerminalTimeoutSeconds', () => {
+  it('clamps the exaggerated budgets models actually pick', () => {
+    // Reported from production: 3-minute, 10-minute and 50-minute waits for
+    // work that finishes in seconds. Nothing in the runtime bounded these —
+    // the model's number reached the client verbatim.
+    expect(clampTerminalTimeoutSeconds(3000)).toBe(MAX_TERMINAL_TIMEOUT_SECONDS)
+    expect(clampTerminalTimeoutSeconds(1800)).toBe(MAX_TERMINAL_TIMEOUT_SECONDS)
+    expect(clampTerminalTimeoutSeconds(601)).toBe(MAX_TERMINAL_TIMEOUT_SECONDS)
+  })
+
+  it('leaves ordinary budgets alone', () => {
+    expect(clampTerminalTimeoutSeconds(30)).toBe(30)
+    expect(clampTerminalTimeoutSeconds(180)).toBe(180)
+    expect(clampTerminalTimeoutSeconds(MAX_TERMINAL_TIMEOUT_SECONDS)).toBe(
+      MAX_TERMINAL_TIMEOUT_SECONDS,
+    )
+  })
+
+  it('preserves the -1 no-timeout sentinel', () => {
+    // The explicit escape hatch for genuinely open-ended commands. Clamping it
+    // to 600 would silently break `cli/src/commands/router.ts`, which passes -1
+    // deliberately.
+    expect(clampTerminalTimeoutSeconds(-1)).toBe(-1)
+  })
+
+  it('leaves an absent value to the schema default', () => {
+    expect(clampTerminalTimeoutSeconds(undefined)).toBeUndefined()
+  })
+
+  it('treats nonsense values as the default rather than an instant timeout', () => {
+    // 0 or a stray negative is a malformed choice, not a request to fail
+    // immediately — which is what passing it through would cause.
+    expect(clampTerminalTimeoutSeconds(0)).toBe(30)
+    expect(clampTerminalTimeoutSeconds(-5)).toBe(30)
+    expect(clampTerminalTimeoutSeconds(Number.NaN)).toBe(
+      MAX_TERMINAL_TIMEOUT_SECONDS,
+    )
+    expect(clampTerminalTimeoutSeconds(Number.POSITIVE_INFINITY)).toBe(
+      MAX_TERMINAL_TIMEOUT_SECONDS,
+    )
+  })
+})