@alumbwe/anvil 1.0.20 → 1.0.21

package/vendor/@anvil/common/src/tools/params/tool/add-message.ts

@@ -0,0 +1,39 @@
+import z from 'zod/v4'
+
+import {
+  $getNativeToolCallExampleString,
+  textToolResultSchema,
+} from '../utils'
+
+import type { $ToolParams } from '../../constants'
+
+const toolName = 'add_message'
+const endsAgentStep = true
+const inputSchema = z
+  .object({
+    role: z.enum(['user', 'assistant']),
+    content: z.string(),
+  })
+  .describe(
+    `Add a new message to the conversation history. To be used for complex requests that can't be solved in a single step, as you may forget what happened!`,
+  )
+const description = `
+Example:
+${$getNativeToolCallExampleString({
+  toolName,
+  inputSchema,
+  input: {
+    role: 'user',
+    content: 'Hello, how are you?',
+  },
+  endsAgentStep,
+})}
+`.trim()
+
+export const addMessageParams = {
+  toolName,
+  endsAgentStep,
+  description,
+  inputSchema,
+  outputSchema: textToolResultSchema(),
+} satisfies $ToolParams

package/vendor/@anvil/common/src/tools/params/tool/add-subgoal.ts

@@ -0,0 +1,57 @@
+import z from 'zod/v4'
+
+import { $getNativeToolCallExampleString, jsonToolResultSchema } from '../utils'
+
+import type { $ToolParams } from '../../constants'
+
+const toolName = 'add_subgoal'
+const endsAgentStep = false
+const inputSchema = z
+  .object({
+    id: z
+      .string()
+      .min(1, 'Id cannot be empty')
+      .describe(
+        `A unique identifier for the subgoal. Try to choose the next sequential integer that is not already in use.`,
+      ),
+    objective: z
+      .string()
+      .min(1, 'Objective cannot be empty')
+      .describe(`The objective of the subgoal, concisely and clearly stated.`),
+    status: z
+      .enum(['NOT_STARTED', 'IN_PROGRESS', 'COMPLETE', 'ABORTED'])
+      .describe(`The status of the subgoal.`),
+    plan: z.string().optional().describe('A plan for the subgoal.'),
+    log: z
+      .string()
+      .optional()
+      .describe('A log message for the subgoal progress.'),
+  })
+  .describe(
+    `Add a new subgoal for tracking progress. To be used for complex requests that can't be solved in a single step, as you may forget what happened!`,
+  )
+const description = `
+Example:
+${$getNativeToolCallExampleString({
+  toolName,
+  inputSchema,
+  input: {
+    id: '1',
+    objective: 'Add a new "deploy api" subgoal',
+    status: 'IN_PROGRESS',
+  },
+  endsAgentStep,
+})}
+`.trim()
+
+export const addSubgoalParams = {
+  toolName,
+  endsAgentStep,
+  description,
+  inputSchema,
+  outputSchema: jsonToolResultSchema(
+    z.object({
+      message: z.string(),
+    }),
+  ),
+} satisfies $ToolParams

package/vendor/@anvil/common/src/tools/params/tool/apply-patch.ts

@@ -0,0 +1,110 @@
+import z from 'zod/v4'
+
+import { $getNativeToolCallExampleString, jsonToolResultSchema } from '../utils'
+
+import type { $ToolParams } from '../../constants'
+
+export const applyPatchResultSchema = z.union([
+  z.object({
+    message: z.string(),
+    applied: z.array(
+      z.object({
+        file: z.string(),
+        action: z.enum(['add', 'update', 'delete']),
+      }),
+    ),
+  }),
+  z.object({
+    errorMessage: z.string(),
+  }),
+])
+
+const toolName = 'apply_patch'
+const endsAgentStep = false
+
+const operationSchema = z.discriminatedUnion('type', [
+  z.object({
+    type: z.literal('create_file'),
+    path: z.string().min(1, 'Path cannot be empty'),
+    diff: z.string().min(1, 'Diff cannot be empty'),
+  }),
+  z.object({
+    type: z.literal('update_file'),
+    path: z.string().min(1, 'Path cannot be empty'),
+    diff: z.string().min(1, 'Diff cannot be empty'),
+  }),
+  z.object({
+    type: z.literal('delete_file'),
+    path: z.string().min(1, 'Path cannot be empty'),
+  }),
+])
+
+export type ApplyPatchOperation = z.infer<typeof operationSchema>
+
+const inputSchema = z
+  .object({
+    operation: operationSchema.describe(
+      'The file operation to perform. type is one of create_file, update_file, or delete_file.',
+    ),
+  })
+  .describe('Apply a file operation (create, update, or delete).')
+
+const description = `
+Use this tool to apply file operations using Codex-style apply_patch format.
+
+Each call performs a single operation on one file.
+
+Operation types:
+- create_file: Create a new file. Requires path and diff (lines prefixed with +).
+- update_file: Update an existing file. Requires path and diff (unified diff with @@ hunks).
+- delete_file: Delete a file. Requires only path.
+
+Example (create):
+${$getNativeToolCallExampleString({
+  toolName,
+  inputSchema,
+  input: {
+    operation: {
+      type: 'create_file',
+      path: 'hello.txt',
+      diff: '@@\n+Hello world\n',
+    },
+  },
+  endsAgentStep,
+})}
+
+Example (update):
+${$getNativeToolCallExampleString({
+  toolName,
+  inputSchema,
+  input: {
+    operation: {
+      type: 'update_file',
+      path: 'lib/fib.py',
+      diff: '@@\n-def fib(n):\n+def fibonacci(n):\n     if n <= 1:\n         return n\n-    return fib(n-1) + fib(n-2)\n+    return fibonacci(n-1) + fibonacci(n-2)\n',
+    },
+  },
+  endsAgentStep,
+})}
+
+Example (delete):
+${$getNativeToolCallExampleString({
+  toolName,
+  inputSchema,
+  input: {
+    operation: {
+      type: 'delete_file',
+      path: 'old-file.txt',
+    },
+  },
+  endsAgentStep,
+})}
+`.trim()
+
+export const applyPatchParams = {
+  toolName,
+  endsAgentStep,
+  description,
+  inputSchema,
+  outputSchema: jsonToolResultSchema(applyPatchResultSchema),
+} satisfies $ToolParams

package/vendor/@anvil/common/src/tools/params/tool/ask-user.ts

@@ -0,0 +1,181 @@
+import z from 'zod/v4'
+
+import { $getNativeToolCallExampleString, coerceToArray, jsonToolResultSchema } from '../utils'
+
+import type { $ToolParams } from '../../constants'
+
+export const questionSchema = z.object({
+  question: z.string().describe('The question to ask the user'),
+  header: z
+    .string()
+    .max(18)
+    .optional()
+    .describe(
+      // Tell the llm 12 chars so that if it goes over slightly, it will still be under the max.
+      'Short label (max 12 chars) displayed as a chip/tag. Example: "Auth method"',
+    ),
+  options: z
+    .preprocess(
+      coerceToArray,
+      z
+        .object({
+          label: z.string().describe('The display text for this option'),
+          description: z
+            .string()
+            .optional()
+            .describe('Explanation shown when option is focused'),
+        })
+        .array()
+        .refine((opts) => opts.length >= 2, {
+          message: 'Each question must have at least 2 options',
+        }),
+    )
+    .describe('Array of answer options with label and optional description.'),
+
+  multiSelect: z
+    .boolean()
+    .default(false)
+    .describe(
+      'If true, allows selecting multiple options (checkbox). If false, single selection only (radio).',
+    ),
+  validation: z
+    .object({
+      maxLength: z
+        .number()
+        .optional()
+        .describe('Maximum length for "Other" text input'),
+      minLength: z
+        .number()
+        .optional()
+        .describe('Minimum length for "Other" text input'),
+      pattern: z
+        .string()
+        .optional()
+        .describe('Regex pattern for "Other" text input'),
+      patternError: z
+        .string()
+        .optional()
+        .describe('Custom error message when pattern fails'),
+    })
+    .optional()
+    .describe('Validation rules for "Other" text input'),
+})
+
+export type AskUserQuestion = z.infer<typeof questionSchema>
+
+const toolName = 'ask_user'
+const endsAgentStep = true
+const inputSchema = z
+  .object({
+    questions: z
+      .preprocess(
+        coerceToArray,
+        z
+          .array(questionSchema)
+          .min(1, 'Must provide at least one question'),
+      )
+      .describe('List of multiple choice questions to ask the user'),
+  })
+  .describe(
+    'Ask the user a list of multiple choice questions. Each question must have at least 2 options. The agent execution will pause until the user submits their answers.',
+  )
+
+const outputSchema = z.object({
+  answers: z
+    .array(
+      z.object({
+        questionIndex: z.number(),
+        selectedOption: z
+          .string()
+          .optional()
+          .describe('The selected option text (single-select mode)'),
+        selectedOptions: z
+          .array(z.string())
+          .optional()
+          .describe('Array of selected option texts (multi-select mode)'),
+        otherText: z
+          .string()
+          .optional()
+          .describe('Custom text input (if user typed their own answer)'),
+      }),
+    )
+    .optional()
+    .describe(
+      'Array of user answers, one per question. Each answer has either selectedOption (single), selectedOptions (multi), or otherText.',
+    ),
+  skipped: z
+    .boolean()
+    .optional()
+    .describe('True if user skipped the questions'),
+})
+
+const description = `
+Ask the user multiple choice questions and pause execution until they respond. Supports both single-select (radio) and multi-select (checkbox) modes.
+
+The user can either:
+- Select one option (single-select mode, default)
+- Select multiple options (multi-select mode, set multiSelect: true)
+- Type a custom answer in the "Other" text field
+- Skip the questions to provide different instructions instead
+
+IMPORTANT: Do NOT include options like "Custom", "Other", "None of the above", or similar catch-all options. The UI automatically provides a "Custom" text input field for users to type their own answer. Including such options would be redundant and confusing.
+
+Single-select example:
+${$getNativeToolCallExampleString({
+  toolName,
+  inputSchema,
+  input: {
+    questions: [
+      {
+        question: 'Which authentication method should we use?',
+        header: 'Auth method',
+        options: [
+          {
+            label: 'JWT tokens',
+            description: 'Stateless tokens stored in localStorage',
+          },
+          {
+            label: 'Session cookies',
+            description: 'Server-side sessions with httpOnly cookies',
+          },
+          {
+            label: 'OAuth2',
+            description: 'Third-party authentication (Google, GitHub, etc.)',
+          },
+        ],
+      },
+    ],
+  },
+  endsAgentStep,
+})}
+
+Multi-select example:
+${$getNativeToolCallExampleString({
+  toolName,
+  inputSchema,
+  input: {
+    questions: [
+      {
+        question: 'Which features should we implement?',
+        header: 'Features',
+        options: [
+          { label: 'Rate limiting' },
+          { label: 'Caching' },
+          { label: 'Logging' },
+          { label: 'Monitoring' },
+        ],
+        multiSelect: true,
+      },
+    ],
+  },
+  endsAgentStep,
+})}
+`.trim()
+
+export const askUserParams = {
+  toolName,
+  endsAgentStep,
+  description,
+  inputSchema,
+  outputSchema: jsonToolResultSchema(outputSchema),
+} satisfies $ToolParams

package/vendor/@anvil/common/src/tools/params/tool/browser-logs.ts

@@ -0,0 +1,85 @@
+import z from 'zod/v4'
+
+import { BrowserResponseSchema } from '../../../browser-actions'
+import { $getNativeToolCallExampleString, jsonToolResultSchema } from '../utils'
+
+import type { $ToolParams } from '../../constants'
+
+const toolName = 'browser_logs'
+const endsAgentStep = true
+const inputSchema = z.object({
+  type: z
+    .string()
+    .min(1, 'Type cannot be empty')
+    .describe('The type of browser action to perform (e.g., "navigate").'),
+  url: z
+    .string()
+    .min(1, 'URL cannot be empty')
+    .describe('The URL to navigate to.'),
+  waitUntil: z
+    .enum(['load', 'domcontentloaded', 'networkidle0'])
+    .optional()
+    .describe("When to consider navigation successful. Defaults to 'load'."),
+})
+const description = `
+Purpose: Use this tool to check the output of console.log or errors in order to debug issues, test functionality, or verify expected behavior.
+
+IMPORTANT: Assume the user's development server is ALREADY running and active, unless you see logs indicating otherwise. Never start the user's development server for them, unless they ask you to do so.
+Never offer to interact with the website aside from reading them (see available actions below). The user will manipulate the website themselves and bring you to the UI they want you to interact with.
+
+### Response Analysis
+
+After each action, you'll receive:
+1. Success/failure status
+2. New console logs since last action
+3. Network requests and responses
+4. JavaScript errors with stack traces
+
+Use this data to:
+- Verify expected behavior
+- Debug issues
+- Guide next actions
+- Make informed decisions about fixes
+
+### Best Practices
+
+**Workflow**
+- Navigate to the user's website, probably on localhost, but you can compare with the production site if you want.
+- Scroll to the relevant section
+- Take screenshots and analyze confirm changes
+- Check network requests for anomalies
+
+**Debugging Flow**
+- Start with minimal reproduction steps
+- Collect data at each step
+- Analyze results before next action
+- Take screenshots to track your changes after each UI change you make
+
+There is currently only one type of browser action available:
+Navigate:
+   - Load a new URL in the current browser window and get the logs after page load.
+   Params:
+   - \`type\`: (required) Must be equal to 'navigate'
+   - \`url\`: (required) The URL to navigate to.
+   - \`waitUntil\`: (required) One of 'load', 'domcontentloaded', 'networkidle0'
+
+Example:
+${$getNativeToolCallExampleString({
+  toolName,
+  inputSchema,
+  input: {
+    type: 'navigate',
+    url: 'localhost:3000',
+    waitUntil: 'domcontentloaded',
+  },
+  endsAgentStep,
+})}
+    `.trim()
+
+export const browserLogsParams = {
+  toolName,
+  endsAgentStep,
+  description,
+  inputSchema,
+  outputSchema: jsonToolResultSchema(BrowserResponseSchema),
+} satisfies $ToolParams

package/vendor/@anvil/common/src/tools/params/tool/cloud-plan-ready.ts

@@ -0,0 +1,94 @@
+import z from 'zod/v4'
+
+import { $getNativeToolCallExampleString, jsonToolResultSchema } from '../utils'
+
+import type { $ToolParams } from '../../constants'
+
+const toolName = 'cloud_plan_ready'
+const endsAgentStep = true
+
+const inputSchema = z.object({
+  summary: z
+    .string()
+    .min(1)
+    .describe(
+      'One short user-facing sentence describing the agreed product. Put implementation detail in build_prompt.',
+    ),
+  stack: z
+    .array(z.string().min(1))
+    .min(1)
+    .describe('The agreed frameworks, services, and infrastructure choices.'),
+  build_prompt: z
+    .string()
+    .min(1)
+    .describe(
+      'A complete implementation brief for the coding agent that will build the project.',
+    ),
+  required_integrations: z
+    .array(
+      z.object({
+        search_id: z
+          .string()
+          .trim()
+          .min(1)
+          .describe(
+            'The exact search_id from the Gravity search that recommended this service.',
+          ),
+        slug: z
+          .string()
+          .trim()
+          .min(1)
+          .describe('The exact Gravity recommendation slug.'),
+      }),
+    )
+    // Defaulted rather than required: a planner that cannot cite a search_id
+    // must still be able to finalize. An incomplete credential list only costs
+    // the user a manual env var later, while a blocked call costs them the
+    // Start building button entirely.
+    .default([])
+    .describe(
+      'Every selected Gravity service whose recommendation returned required API keys or environment variables. Pass [] when the plan needs no credential-bearing external service, or when you have no exact search_id to cite.',
+    ),
+})
+
+const outputSchema = z.object({ message: z.string() })
+
+const description = `
+Mark a blank Anvil Cloud project plan as ready for the user to approve.
+
+Call this once you know what the product does and which technologies it uses:
+- You understand the product, its users, and its core flows.
+- You chose every technology in the stack with gravity_index.
+- You presented the stack and answered the user's questions about it.
+
+This does not start implementation. It makes a "Start building" button appear
+for the user, and that button is how the user approves the plan — do not ask
+them to confirm the plan before calling this, and never end a turn saying you
+are ready to finalize instead of calling it.
+
+${$getNativeToolCallExampleString({
+  toolName,
+  inputSchema,
+  input: {
+    summary: 'A collaborative booking app for independent music teachers.',
+    stack: ['React', 'Vite', 'Supabase', 'Resend'],
+    build_prompt:
+      'Build the agreed booking app with teacher availability, student booking, authentication, and transactional email.',
+    required_integrations: [
+      {
+        search_id: 'search_id_from_gravity_index',
+        slug: 'resend',
+      },
+    ],
+  },
+  endsAgentStep,
+})}
+`.trim()
+
+export const cloudPlanReadyParams = {
+  toolName,
+  endsAgentStep,
+  description,
+  inputSchema,
+  outputSchema: jsonToolResultSchema(outputSchema),
+} satisfies $ToolParams