@alumbwe/anvil 1.0.20 → 1.0.21

package/vendor/@anvil/common/src/__tests__/gravity-capi.test.ts

@@ -0,0 +1,154 @@
+import { describe, expect, test } from 'bun:test'
+
+import {
+  buildGravityFirstMessagePayload,
+  gravityFirstMessageEventId,
+  isAnvilGravitySurface,
+  sanitizeGravityCapiData,
+  sendGravityFirstMessageConversion,
+} from '../gravity-capi'
+
+describe('Gravity first-message CAPI', () => {
+  test('sanitizes browser attribution in one shared boundary', () => {
+    expect(
+      sanitizeGravityCapiData(
+        {
+          user_data: {
+            click_id: 'click-1',
+            visitor_id: 123,
+            session_id: 'session-1',
+          },
+          event_source_url: 'https://stale.example',
+          client_context: { timezone: 'America/Los_Angeles' },
+        },
+        'https://anvil.com/chat',
+      ),
+    ).toEqual({
+      user_data: {
+        click_id: 'click-1',
+        visitor_id: undefined,
+        session_id: 'session-1',
+        client_user_agent: undefined,
+      },
+      event_source_url: 'https://anvil.com/chat',
+      client_context: { timezone: 'America/Los_Angeles' },
+    })
+    expect(isAnvilGravitySurface('desktop')).toBe(true)
+    expect(isAnvilGravitySurface('preexisting')).toBe(false)
+  })
+
+  test('drops oversized client context before forwarding it to Gravity', () => {
+    expect(
+      sanitizeGravityCapiData({
+        user_data: { click_id: 'click-123' },
+        client_context: { padding: 'x'.repeat(32_768) },
+      }),
+    ).toEqual({
+      user_data: {
+        click_id: 'click-123',
+        visitor_id: undefined,
+        session_id: undefined,
+        client_user_agent: undefined,
+      },
+      event_source_url: undefined,
+      client_context: undefined,
+    })
+  })
+
+  test('builds a stable, attributed payload with authoritative identity', () => {
+    expect(
+      buildGravityFirstMessagePayload({
+        userId: 'user-123',
+        email: 'person@example.com',
+        surface: 'cloud',
+        eventTime: 123,
+        gravity: {
+          event_source_url: 'https://anvil.com/cloud/project/example',
+          user_data: {
+            click_id: 'click-1',
+            visitor_id: 'visitor-1',
+            session_id: 'session-1',
+            client_user_agent: 'pixel-agent',
+          },
+          client_context: { timezone: 'America/Los_Angeles' },
+        },
+      }),
+    ).toEqual({
+      data: [
+        {
+          event_name: 'FirstMessage',
+          event_time: 123,
+          event_id: 'anvil-first-message-user-123',
+          action_source: 'website',
+          event_source_url: 'https://anvil.com/cloud/project/example',
+          user_data: {
+            click_id: 'click-1',
+            visitor_id: 'visitor-1',
+            session_id: 'session-1',
+            client_user_agent: 'pixel-agent',
+            em: ['person@example.com'],
+            external_id: ['user-123'],
+          },
+          client_context: { timezone: 'America/Los_Angeles' },
+          custom_data: {
+            content_name: 'Anvil first message',
+            content_category: 'cloud',
+          },
+        },
+      ],
+    })
+  })
+
+  test('uses the same event id across surfaces for Gravity deduplication', () => {
+    expect(gravityFirstMessageEventId('user-123')).toBe(
+      'anvil-first-message-user-123',
+    )
+  })
+
+  test('accepts a duplicate response as delivered', async () => {
+    let requestBody: unknown
+    const result = await sendGravityFirstMessageConversion({
+      apiKey: 'secret',
+      userId: 'user-123',
+      surface: 'desktop',
+      fetchImpl: (async (_input, init) => {
+        requestBody = JSON.parse(String(init?.body))
+        return new Response(
+          JSON.stringify({
+            results: [
+              {
+                event_id: 'anvil-first-message-user-123',
+                status: 'duplicate',
+              },
+            ],
+          }),
+          { status: 200 },
+        )
+      }) as typeof fetch,
+    })
+
+    expect(result.status).toBe('duplicate')
+    expect(requestBody).toMatchObject({
+      data: [
+        {
+          event_name: 'FirstMessage',
+          custom_data: { content_category: 'desktop' },
+        },
+      ],
+    })
+  })
+
+  test('throws on an event-level error so the claim remains retryable', async () => {
+    await expect(
+      sendGravityFirstMessageConversion({
+        apiKey: 'secret',
+        userId: 'user-123',
+        surface: 'cli',
+        fetchImpl: (async () =>
+          new Response(JSON.stringify({ results: [{ status: 'error' }] }), {
+            status: 200,
+          })) as unknown as typeof fetch,
+      }),
+    ).rejects.toThrow('status error')
+  })
+})

package/vendor/@anvil/common/src/__tests__/handlesteps-parsing.test.ts

@@ -0,0 +1,246 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+
+import { validateAgents } from '../templates/agent-validation'
+import { DynamicAgentDefinitionSchema } from '../types/dynamic-agent-template'
+
+import type { DynamicAgentTemplate } from '../types/dynamic-agent-template'
+import type { AgentState } from '../types/session-state'
+import type { ProjectFileContext } from '../util/file'
+import type { Logger } from '@anvil/common/types/contracts/logger'
+
+describe('handleSteps Parsing Tests', () => {
+  let mockFileContext: ProjectFileContext
+  let mockAgentTemplate: DynamicAgentTemplate
+  const logger: Logger = {
+    debug: () => {},
+    error: () => {},
+    info: () => {},
+    warn: () => {},
+  }
+
+  beforeEach(() => {
+    // Setup common mock data
+    mockFileContext = {
+      projectRoot: '/test',
+      cwd: '/test',
+      fileTree: [],
+      fileTokenScores: {},
+      knowledgeFiles: {},
+      agentTemplates: {},
+      customToolDefinitions: {},
+      gitChanges: {
+        status: '',
+        diff: '',
+        diffCached: '',
+        lastCommitMessages: '',
+      },
+      changesSinceLastChat: {},
+      shellConfigFiles: {},
+      systemInfo: {
+        platform: 'test',
+        shell: 'test',
+        nodeVersion: 'test',
+        arch: 'test',
+        homedir: '/test',
+        cpus: 1,
+        chromeAvailable: false,
+      },
+      tokenCallers: {},
+    }
+
+    mockAgentTemplate = {
+      id: 'test-agent',
+      version: '1.0.0',
+      displayName: 'Test Agent',
+      spawnerPrompt: 'Testing',
+      model: 'claude-3-5-sonnet-20241022',
+      outputMode: 'structured_output' as const,
+      mcpServers: {},
+      toolNames: ['set_output'],
+      spawnableAgents: [],
+      includeMessageHistory: true,
+      inheritParentSystemPrompt: false,
+      systemPrompt: 'Test system prompt',
+      instructionsPrompt: 'Test user prompt',
+      stepPrompt: 'Test agent step prompt',
+    }
+  })
+
+  afterEach(() => {
+    // No cleanup needed for stateless functions
+  })
+
+  test('should validate agent config with handleSteps function', () => {
+    const agentConfig = {
+      id: 'test-agent',
+      version: '1.0.0',
+      displayName: 'Test Agent',
+      spawnerPrompt: 'Testing handleSteps',
+      model: 'claude-3-5-sonnet-20241022',
+      outputMode: 'structured_output' as const,
+      toolNames: ['set_output'],
+      systemPrompt: 'You are a test agent',
+      instructionsPrompt: 'Process: {prompt}',
+      stepPrompt: 'Continue processing',
+      handleSteps: function* ({
+        agentState,
+        prompt,
+        params,
+      }: {
+        agentState: AgentState
+        prompt?: string
+        params?: any
+      }) {
+        yield {
+          toolName: 'set_output',
+          args: { message: 'Test completed' },
+        }
+      },
+    }
+
+    const result = DynamicAgentDefinitionSchema.safeParse(agentConfig)
+    expect(result.success).toBe(true)
+
+    if (result.success) {
+      expect(typeof result.data.handleSteps).toBe('function')
+    }
+  })
+
+  test('should convert handleSteps function to string', async () => {
+    const handleStepsFunction = function* ({
+      agentState,
+      prompt,
+      params,
+    }: {
+      agentState: AgentState
+      prompt?: string
+      params?: any
+    }) {
+      yield {
+        toolName: 'set_output',
+        args: { message: 'Hello from generator' },
+      }
+    }
+
+    const agentTemplates = {
+      'test-agent.ts': {
+        ...mockAgentTemplate,
+        handleSteps: handleStepsFunction.toString(),
+      },
+    }
+
+    const fileContext: ProjectFileContext = {
+      ...mockFileContext,
+      agentTemplates,
+    }
+
+    const result = validateAgents({
+      agentTemplates: fileContext.agentTemplates || {},
+      logger,
+    })
+
+    expect(result.validationErrors).toHaveLength(0)
+    expect(result.templates['test-agent']).toBeDefined()
+    expect(typeof result.templates['test-agent'].handleSteps).toBe('string')
+  })
+
+  // Note: The validation that required set_output tool for structured_output mode was
+  // intentionally disabled to allow handleSteps to use set_output while the LLM does not
+  // have access to the set_output tool.
+  test('should allow structured_output mode without set_output tool in toolNames', () => {
+    const {
+      DynamicAgentTemplateSchema,
+    } = require('../types/dynamic-agent-template')
+
+    const agentConfig = {
+      id: 'test-agent',
+      version: '1.0.0',
+      displayName: 'Test Agent',
+      spawnerPrompt: 'Testing handleSteps',
+      model: 'claude-3-5-sonnet-20241022',
+      outputMode: 'structured_output' as const,
+      toolNames: ['end_turn'], // Missing set_output - now allowed
+      spawnableAgents: [],
+      systemPrompt: 'Test',
+      instructionsPrompt: 'Test',
+      stepPrompt: 'Test',
+
+      handleSteps:
+        'function* () { yield { toolName: "set_output", args: {} } }',
+    }
+
+    const result = DynamicAgentTemplateSchema.safeParse(agentConfig)
+    expect(result.success).toBe(true)
+  })
+
+  test('should validate that handleSteps is a generator function', async () => {
+    const agentTemplates = {
+      'test-agent.ts': {
+        ...mockAgentTemplate,
+        handleSteps: 'function () { return "not a generator" }', // Missing *
+      },
+    }
+
+    const fileContext: ProjectFileContext = {
+      ...mockFileContext,
+      agentTemplates,
+    }
+
+    const result = validateAgents({
+      agentTemplates: fileContext.agentTemplates || {},
+      logger,
+    })
+
+    expect(result.validationErrors.length).toBeGreaterThan(0)
+    expect(result.validationErrors[0].message).toContain('generator function')
+    expect(result.validationErrors[0].message).toContain('function*')
+  })
+
+  test('should verify loaded template handleSteps matches original function toString', async () => {
+    // Create a generator function
+    const originalFunction = function* ({
+      agentState,
+      prompt,
+      params,
+    }: {
+      agentState: AgentState
+      prompt?: string
+      params?: any
+    }) {
+      yield {
+        toolName: 'set_output',
+        args: { message: 'Test output', data: params },
+      }
+    }
+
+    // Get the string representation
+    const expectedStringified = originalFunction.toString()
+
+    // Create agent templates with the function
+    const agentTemplates = {
+      'test-agent.ts': {
+        ...mockAgentTemplate,
+        handleSteps: expectedStringified,
+      },
+    }
+
+    const fileContext: ProjectFileContext = {
+      ...mockFileContext,
+      agentTemplates,
+    }
+
+    // Load agents through the service
+    const result = validateAgents({
+      agentTemplates: fileContext.agentTemplates || {},
+      logger,
+    })
+
+    // Verify no validation errors
+    expect(result.validationErrors).toHaveLength(0)
+    expect(result.templates['test-agent']).toBeDefined()
+
+    // Verify the loaded template's handleSteps field matches the original toString
+    expect(result.templates['test-agent'].handleSteps).toBe(expectedStringified)
+    expect(typeof result.templates['test-agent'].handleSteps).toBe('string')
+  })
+})

package/vendor/@anvil/common/src/__tests__/kimi-k3-god-only.test.ts

@@ -0,0 +1,77 @@
+/**
+ * Kimi K3 (Eco) is god-only on Anvil Web — a testing row, not a product one.
+ * Cost backs that up: CrofAI lists it at $1.00/$4.00 per M against DeepSeek V4
+ * Flash's $0.12/$0.21 on the same provider, ~8x input and ~19x output.
+ */
+import { describe, expect, it } from 'bun:test'
+
+import {
+  ANVIL_KIMI_K3_ECO_MODEL_ID,
+  ANVIL_MODELS,
+  ANVIL_WEB_ALL_MODELS,
+  ANVIL_WEB_GOD_ONLY_MODELS,
+  ANVIL_WEB_MODELS,
+  ANVIL_WEB_PREMIUM_MODEL_IDS,
+  ANVIL_WEB_STANDARD_MODEL_IDS,
+  isAnvilWebGodOnlyModelId,
+  isAnvilWebModelId,
+  SUPPORTED_ANVIL_MODELS,
+} from '../constants/anvil-models'
+
+const KIMI_ID = ANVIL_KIMI_K3_ECO_MODEL_ID
+
+describe('Kimi K3 is god-only on Anvil Web', () => {
+  it('is offered to god users and nobody else', () => {
+    expect(isAnvilWebGodOnlyModelId(KIMI_ID)).toBe(true)
+    expect(isAnvilWebModelId(KIMI_ID, { includeGodOnly: true })).toBe(true)
+    expect(isAnvilWebModelId(KIMI_ID, { includeGodOnly: false })).toBe(false)
+    expect(ANVIL_WEB_GOD_ONLY_MODELS.map((m) => m.id)).toContain(KIMI_ID)
+    // The god-only list is additive to the visible one, so it must NOT also
+    // appear there or every user would see it.
+    expect(ANVIL_WEB_MODELS.map((m) => m.id)).not.toContain(KIMI_ID)
+  })
+
+  it('stays off every non-web surface', () => {
+    // Web only, as asked. ANVIL_MODELS is the CLI/Desktop catalog and
+    // SUPPORTED_ANVIL_MODELS the waiting-room set.
+    expect(ANVIL_MODELS.map((m) => m.id)).not.toContain(KIMI_ID)
+    expect(SUPPORTED_ANVIL_MODELS.map((m) => m.id)).not.toContain(KIMI_ID)
+    expect(ANVIL_WEB_ALL_MODELS.map((m) => m.id)).toContain(KIMI_ID)
+  })
+
+  it('is metered by the premium pool, never the standard one', () => {
+    // ANVIL_WEB_STANDARD_MODEL_IDS is derived by filtering `!premium`, so a
+    // premium row missing from the premium list would be metered by NO pool.
+    expect(ANVIL_WEB_PREMIUM_MODEL_IDS).toContain(KIMI_ID)
+    expect(ANVIL_WEB_STANDARD_MODEL_IDS).not.toContain(KIMI_ID)
+    const model = ANVIL_WEB_GOD_ONLY_MODELS.find((m) => m.id === KIMI_ID)
+    expect(model?.premium).toBe(true)
+  })
+
+  it('displays as "Kimi K3" while the wire id keeps the -eco build', () => {
+    // DELIBERATE, by explicit request, and the reason this assertion exists: it
+    // breaks the convention DeepSeek V4 Flash 07/31 sets (name the exact build),
+    // so without a test someone would "fix" the label to 'Kimi K3 Eco'.
+    //
+    // The wire id must keep `-eco` regardless. CrofAI serves a full `kimi-k3` at
+    // twice the price ($2.00/$8.00), and routing, billing and CROF_MODEL_MAP all
+    // key off this id — collapsing it to a bare `kimi-k3` would silently point
+    // this row at the dearer model.
+    const model = ANVIL_WEB_GOD_ONLY_MODELS.find((m) => m.id === KIMI_ID)
+    expect(model?.displayName).toBe('Kimi K3')
+    expect(model?.displayName).not.toContain('Eco')
+    expect(KIMI_ID).toBe('crof/kimi-k3-eco')
+  })
+
+  it('is marked experimental, since it exists to be tested', () => {
+    const model = ANVIL_WEB_GOD_ONLY_MODELS.find((m) => m.id === KIMI_ID)
+    expect(model?.experimental).toBe(true)
+  })
+
+  it('keeps its id distinct from every other catalog row', () => {
+    // A second id for an already-offered model is how the retired `crof/glm-5.2`
+    // became a quota-bypass route. This must be the only id that reaches K3 Eco.
+    const all = ANVIL_WEB_ALL_MODELS.map((m) => m.id)
+    expect(new Set(all).size).toBe(all.length)
+  })
+})

package/vendor/@anvil/common/src/__tests__/model-config.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, test } from 'bun:test'
+
+import {
+  contextPrunerBudgetForModel,
+  isExplicitlyDefinedModel,
+  models,
+  supportsAssistantPrefill,
+} from '../constants/model-config'
+
+describe('isExplicitlyDefinedModel', () => {
+  test('distinguishes configured models from unknown model IDs', () => {
+    expect(isExplicitlyDefinedModel(models.openrouter_gpt5)).toBe(true)
+    expect(isExplicitlyDefinedModel('custom/unknown-model')).toBe(false)
+  })
+})
+
+describe('supportsAssistantPrefill', () => {
+  test('rejects prefill for Claude 4.6+', () => {
+    expect(supportsAssistantPrefill('anthropic/claude-opus-4.6')).toBe(false)
+    expect(supportsAssistantPrefill('anthropic/claude-opus-4.7')).toBe(false)
+    expect(supportsAssistantPrefill('anthropic/claude-sonnet-4.6')).toBe(false)
+    expect(supportsAssistantPrefill('anthropic/claude-fable-5')).toBe(false)
+  })
+
+  test('allows prefill for Claude before 4.6', () => {
+    expect(supportsAssistantPrefill('anthropic/claude-sonnet-4.5')).toBe(true)
+    expect(supportsAssistantPrefill('anthropic/claude-opus-4')).toBe(true)
+    expect(supportsAssistantPrefill('anthropic/claude-3-5-sonnet')).toBe(true)
+    expect(
+      supportsAssistantPrefill('anthropic/claude-haiku-4-5-20251001'),
+    ).toBe(true)
+  })
+
+  test('allows prefill for non-Claude models', () => {
+    expect(supportsAssistantPrefill('openai/gpt-5.1')).toBe(true)
+    expect(supportsAssistantPrefill('deepseek/deepseek-v4-pro')).toBe(true)
+    expect(supportsAssistantPrefill('moonshotai/kimi-k2.6')).toBe(true)
+  })
+})
+
+describe('contextPrunerBudgetForModel', () => {
+  test('defaults to 400k, which every ~1M-window model we serve can hold', () => {
+    for (const model of [
+      'anthropic/claude-opus-5',
+      'anthropic/claude-sonnet-5',
+      'openai/gpt-5.4',
+      'openai/gpt-5.6-luna',
+      'deepseek/deepseek-v4-flash',
+      'deepseek/deepseek-v4-pro',
+      'mimo/mimo-v2.5',
+      'z-ai/glm-5.2',
+      // MiniMax M3's real enforced limit is 524_288 (Fireworks rejects with
+      // "model maximum context length: 524287"), not the 1M OpenRouter lists.
+      // 400k is still comfortably under it.
+      'minimax/minimax-m3',
+      'some/model-we-have-never-shipped',
+    ]) {
+      expect(contextPrunerBudgetForModel(model)).toBe(400_000)
+    }
+  })
+
+  test('drops to 250k for the 262,144-token models', () => {
+    // Kimi K2.7 Code is the only remaining exception: the HY3 and Ling 3.0
+    // Flash entries that shared its window went with those models on
+    // 2026-08-07, so they now take the 400k default like anything unlisted.
+    expect(contextPrunerBudgetForModel('moonshotai/kimi-k2.7-code')).toBe(
+      250_000,
+    )
+    for (const removed of [
+      'tencent/hy3',
+      'tencent/hy3:free',
+      'tencent/hy3-preview',
+      'inclusionai/ling-3.0-flash:free',
+    ]) {
+      expect(contextPrunerBudgetForModel(removed)).toBe(400_000)
+    }
+  })
+
+  test('every exception stays under its real window', () => {
+    // The budget is compared against a GPT-4o-based estimate applied to other
+    // tokenizers, so it must sit under the provider's limit with room to spare.
+    expect(
+      contextPrunerBudgetForModel('moonshotai/kimi-k2.7-code'),
+    ).toBeLessThan(262_144)
+    // Kimi K3 Eco is deliberately NOT an exception — CrofAI serves it at a 1M
+    // context, so the 400k default is correct for it.
+    expect(contextPrunerBudgetForModel('crof/kimi-k3-eco')).toBe(400_000)
+  })
+})