@alumbwe/anvil 1.0.20 → 1.0.22

package/vendor/@anvil/common/src/__tests__/disposable-email.test.ts

@@ -0,0 +1,132 @@
+import { describe, expect, it } from 'bun:test'
+
+import {
+  classifyEmailDomain,
+  isSpendCeilingFlaggedEmailDomain,
+} from '../util/disposable-email'
+
+describe('classifyEmailDomain', () => {
+  it('flags one-time inbox providers as disposable', () => {
+    expect(classifyEmailDomain('bot123@mailinator.com')).toBe('disposable')
+    expect(classifyEmailDomain('x@yopmail.com')).toBe('disposable')
+    // Domains observed in the 2026-07 referral farm rings.
+    expect(classifyEmailDomain('mrz640mq54kr@animatimg.com')).toBe('disposable')
+    expect(classifyEmailDomain('a@biscoito.email')).toBe('disposable')
+  })
+
+  it('classifies mainstream privacy mailboxes without ceiling-pricing them', () => {
+    // Operator decision 2026-08-14: Proton/Tutanota/Apple/DuckDuckGo/Firefox
+    // are consumer providers, not bot-farm suppliers. Visible to scoring,
+    // invisible to the spend ceiling.
+    expect(classifyEmailDomain('4q9cq4d7cj@proton.me')).toBe(
+      'mainstream_privacy',
+    )
+    expect(classifyEmailDomain('someone@protonmail.com')).toBe(
+      'mainstream_privacy',
+    )
+    expect(classifyEmailDomain('g862jxscfv@privaterelay.appleid.com')).toBe(
+      'mainstream_privacy',
+    )
+    expect(classifyEmailDomain('dev@pm.me')).toBe('mainstream_privacy')
+    expect(isSpendCeilingFlaggedEmailDomain('dev@pm.me')).toBe(false)
+    expect(isSpendCeilingFlaggedEmailDomain('user@tutanota.com')).toBe(false)
+    // Alias products stay priced: one-address-per-signup IS the abuse shape.
+    expect(classifyEmailDomain('a@simplelogin.io')).toBe('privacy_relay')
+    expect(isSpendCeilingFlaggedEmailDomain('a@simplelogin.io')).toBe(true)
+    expect(isSpendCeilingFlaggedEmailDomain('a@passmail.net')).toBe(true)
+    // Disposables too, unchanged.
+    expect(isSpendCeilingFlaggedEmailDomain('x@mailinator.com')).toBe(true)
+  })
+
+  it('matches subdomains of listed domains', () => {
+    expect(classifyEmailDomain('x@inbox.mailinator.com')).toBe('disposable')
+  })
+
+  it('flags the 2026-08-01 free-mode compute ring domains and their subdomains', () => {
+    // Real addresses from the ring; the deceptive subdomains are the point.
+    expect(classifyEmailDomain('tbcy8kvy77z2@l0veyou.com')).toBe('disposable')
+    expect(classifyEmailDomain('xtikhozbrw3z@gmail.l0veyou.com')).toBe(
+      'disposable',
+    )
+    expect(classifyEmailDomain('kznc3jb31lsz@edu.l0veyou.com')).toBe(
+      'disposable',
+    )
+    expect(classifyEmailDomain('ht07lgr96jsg@my.l0veyou.com')).toBe(
+      'disposable',
+    )
+    expect(classifyEmailDomain('8cuoyn573zae@test123.l0veyou.com')).toBe(
+      'disposable',
+    )
+    expect(classifyEmailDomain('4j4fyacbke76@pumpkinai.space')).toBe(
+      'disposable',
+    )
+    expect(classifyEmailDomain('uhm9e3za1qft@gmail.pumpkinai.space')).toBe(
+      'disposable',
+    )
+    expect(classifyEmailDomain('7yahsqv1o8lc@pumpkinai.it.com')).toBe(
+      'disposable',
+    )
+  })
+
+  it('flags the proxy-service and single-day-mint domains', () => {
+    expect(classifyEmailDomain('github-1@proxyvpn.cn')).toBe('disposable')
+    expect(classifyEmailDomain('yazen@impact.qd.je')).toBe('disposable')
+    expect(classifyEmailDomain('x@fincy.qd.je')).toBe('disposable')
+  })
+
+  it('does not flag real providers a "proxy" substring rule would catch', () => {
+    // Proximus is Belgium's largest telecom; its one user has 791 legitimate
+    // messages. dns-proxy.com has a single account and no activity, so there
+    // is no evidence to act on.
+    expect(classifyEmailDomain('leopold.delage@proximus.lu')).toBeNull()
+    expect(classifyEmailDomain('alizy@dns-proxy.com')).toBeNull()
+    expect(classifyEmailDomain('someone@proxyclick.com')).toBeNull()
+  })
+
+  it('does not flag lookalikes of the ring domains', () => {
+    expect(classifyEmailDomain('x@loveyou.com')).toBeNull()
+    expect(classifyEmailDomain('x@notl0veyou.com')).toBeNull()
+    expect(classifyEmailDomain('x@pumpkinai.com')).toBeNull()
+  })
+
+  it('treats ordinary providers as unflagged', () => {
+    expect(classifyEmailDomain('person@gmail.com')).toBeNull()
+    expect(classifyEmailDomain('dev@company.io')).toBeNull()
+    // Substring lookalikes must not match the suffix rule.
+    expect(classifyEmailDomain('x@notproton.me.example.com')).toBeNull()
+    expect(classifyEmailDomain('x@fakeproton.me')).toBeNull()
+  })
+
+  it('is case-insensitive and null-safe', () => {
+    expect(classifyEmailDomain('X@Proton.ME')).toBe('mainstream_privacy')
+    expect(classifyEmailDomain(null)).toBeNull()
+    expect(classifyEmailDomain(undefined)).toBeNull()
+    expect(classifyEmailDomain('not-an-email')).toBeNull()
+    expect(classifyEmailDomain('trailing@')).toBeNull()
+  })
+  it('flags the 2026-08-15 Singapore ring, and prices it', () => {
+    // These are why the SG geography cap could come off: the abuse there was a
+    // domain farm, not a country. Each cleared the file's evidence bar on ban
+    // rate (see the dated block in disposable-email.ts).
+    for (const domain of [
+      'dhisy.com',
+      'dewaa.id',
+      'sendang.space',
+      'yotube.id',
+      'gusil.my.id',
+    ]) {
+      expect(classifyEmailDomain(`user@${domain}`)).toBe('disposable')
+      expect(isSpendCeilingFlaggedEmailDomain(`user@${domain}`)).toBe(true)
+    }
+  })
+
+  it('does NOT flag the two lookalikes that failed the evidence bar', () => {
+    // gmisel.com sits one letter from the listed gmisol.my.id and shows a 2%
+    // abuse rate — indistinguishable from gmail. cemararaya.id has six
+    // accounts. Name similarity is not evidence; this is the regression guard
+    // for adding a domain because it "looks like" one of the others.
+    expect(classifyEmailDomain('user@gmisel.com')).toBeNull()
+    expect(classifyEmailDomain('user@cemararaya.id')).toBeNull()
+    expect(isSpendCeilingFlaggedEmailDomain('user@gmisel.com')).toBe(false)
+  })
+})

package/vendor/@anvil/common/src/__tests__/dynamic-agent-template-schema.test.ts

@@ -0,0 +1,422 @@
+import { describe, expect, it } from 'bun:test'
+
+import {
+  DynamicAgentDefinitionSchema,
+  DynamicAgentTemplateSchema,
+} from '../types/dynamic-agent-template'
+import { AgentTemplateTypes } from '../types/session-state'
+
+describe('DynamicAgentDefinitionSchema', () => {
+  const validBaseTemplate = {
+    id: 'test-agent',
+    version: '1.0.0',
+    displayName: 'Test Agent',
+    spawnerPrompt: 'A test agent',
+    model: 'anthropic/claude-4-sonnet-20250522',
+    systemPrompt: 'Test system prompt',
+    instructionsPrompt: 'Test user prompt',
+    stepPrompt: 'Test step prompt',
+  }
+
+  describe('Valid Templates', () => {
+    it('should validate minimal valid template', () => {
+      const result = DynamicAgentDefinitionSchema.safeParse(validBaseTemplate)
+      expect(result.success).toBe(true)
+    })
+
+    it('should validate template with inputSchema', () => {
+      const template = {
+        ...validBaseTemplate,
+        inputSchema: {
+          prompt: {
+            type: 'string',
+            description: 'A test prompt',
+          },
+        },
+      }
+
+      const result = DynamicAgentDefinitionSchema.safeParse(template)
+      expect(result.success).toBe(true)
+    })
+
+    it('should validate template with paramsSchema', () => {
+      const template = {
+        ...validBaseTemplate,
+        inputSchema: {
+          params: {
+            type: 'object',
+            properties: {
+              temperature: {
+                type: 'number',
+                minimum: 0,
+                maximum: 1,
+              },
+            },
+          },
+        },
+      }
+
+      const result = DynamicAgentDefinitionSchema.safeParse(template)
+      expect(result.success).toBe(true)
+    })
+
+    it('should validate template with both schemas', () => {
+      const template = {
+        ...validBaseTemplate,
+        inputSchema: {
+          prompt: {
+            type: 'string',
+            description: 'A test prompt',
+          },
+          params: {
+            type: 'object',
+            properties: {
+              mode: { type: 'string', enum: ['fast', 'thorough'] },
+            },
+          },
+        },
+      }
+
+      const result = DynamicAgentDefinitionSchema.safeParse(template)
+      expect(result.success).toBe(true)
+    })
+
+    it('should validate template with complex nested schemas', () => {
+      const template = {
+        ...validBaseTemplate,
+        inputSchema: {
+          params: {
+            type: 'object',
+            properties: {
+              config: {
+                type: 'object',
+                properties: {
+                  settings: {
+                    type: 'array',
+                    items: {
+                      type: 'object',
+                      properties: {
+                        key: { type: 'string' },
+                        value: { type: 'string' },
+                      },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      }
+
+      const result = DynamicAgentDefinitionSchema.safeParse(template)
+      expect(result.success).toBe(true)
+    })
+
+    it('should apply default values', () => {
+      const result = DynamicAgentDefinitionSchema.safeParse(validBaseTemplate)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.data.outputMode).toBe('last_message')
+        expect(result.data.includeMessageHistory).toBe(false)
+        expect(result.data.toolNames).toEqual([])
+        expect(result.data.spawnableAgents).toEqual([])
+      }
+    })
+
+    it('should validate template with parentInstructions', () => {
+      const template = {
+        ...validBaseTemplate,
+        parentInstructions: {
+          researcher: 'Spawn when you need research',
+          [AgentTemplateTypes.file_picker]: 'Spawn when you need files',
+          base: 'Spawn for general tasks',
+        },
+      }
+
+      const result = DynamicAgentDefinitionSchema.safeParse(template)
+      expect(result.success).toBe(true)
+    })
+  })
+
+  describe('Invalid Templates', () => {
+    it('should reject template with missing required fields', () => {
+      const template = {
+        id: 'test-agent',
+        // Missing other required fields
+      }
+
+      const result = DynamicAgentDefinitionSchema.safeParse(template)
+      expect(result.success).toBe(false)
+    })
+
+    it('should reject template with invalid outputMode', () => {
+      const template = {
+        ...validBaseTemplate,
+        outputMode: 'invalid_mode',
+      }
+
+      const result = DynamicAgentDefinitionSchema.safeParse(template)
+      expect(result.success).toBe(false)
+    })
+
+    it('should reject template with invalid inputSchema type', () => {
+      const template = {
+        ...validBaseTemplate,
+        inputSchema: 'not an object',
+      }
+
+      const result = DynamicAgentDefinitionSchema.safeParse(template)
+      expect(result.success).toBe(false)
+    })
+
+    it('should reject template with invalid paramsSchema type', () => {
+      const template = {
+        ...validBaseTemplate,
+        inputSchema: { params: 'not an object' },
+      }
+
+      const result = DynamicAgentDefinitionSchema.safeParse(template)
+      expect(result.success).toBe(false)
+    })
+
+    it('should reject template with null schemas', () => {
+      const template = {
+        ...validBaseTemplate,
+        inputSchema: null,
+      }
+
+      const result = DynamicAgentDefinitionSchema.safeParse(template)
+      expect(result.success).toBe(false)
+    })
+
+    it('should reject template with invalid prompt field structure', () => {
+      const template = {
+        ...validBaseTemplate,
+        systemPrompt: { invalidField: 'value' }, // Should be string only
+      }
+
+      const result = DynamicAgentDefinitionSchema.safeParse(template)
+      expect(result.success).toBe(false)
+    })
+
+    it('should reject template with invalid agent ID format', () => {
+      const invalidIds = [
+        'Test_Agent', // uppercase and underscore
+        'test agent', // space
+        'test.agent', // dot
+        'test@agent', // special character
+        'Test-Agent', // uppercase
+        '123_test', // underscore
+        'test/agent', // slash
+      ]
+
+      invalidIds.forEach((id) => {
+        const template = {
+          ...validBaseTemplate,
+          id,
+        }
+
+        const result = DynamicAgentDefinitionSchema.safeParse(template)
+        expect(result.success).toBe(false)
+        if (!result.success) {
+          expect(result.error.issues[0].message).toContain(
+            'lowercase letters, numbers, and hyphens',
+          )
+        }
+      })
+    })
+
+    it('should accept template with valid agent ID format', () => {
+      const validIds = [
+        'test-agent',
+        'test123',
+        'agent-v2',
+        'my-custom-agent-123',
+        'a',
+        '123',
+        'test-agent-with-many-hyphens',
+      ]
+
+      validIds.forEach((id) => {
+        const template = {
+          ...validBaseTemplate,
+          id,
+        }
+
+        const result = DynamicAgentDefinitionSchema.safeParse(template)
+        expect(result.success).toBe(true)
+      })
+    })
+
+    // 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.
+    it('should allow template with outputMode structured_output without set_output tool', () => {
+      const template = {
+        ...validBaseTemplate,
+        outputMode: 'structured_output' as const,
+        toolNames: ['end_turn', 'read_files'], // Missing set_output - now allowed
+      }
+
+      const result = DynamicAgentTemplateSchema.safeParse(template)
+      expect(result.success).toBe(true)
+    })
+
+    it('should accept template with outputMode structured_output and set_output tool', () => {
+      const template = {
+        ...validBaseTemplate,
+        outputMode: 'structured_output' as const,
+        toolNames: ['end_turn', 'set_output'],
+      }
+
+      const result = DynamicAgentTemplateSchema.safeParse(template)
+      expect(result.success).toBe(true)
+    })
+
+    // Note: The validation that rejected set_output without structured_output mode was
+    // intentionally disabled to allow parent agents to have set_output tool with 'last_message'
+    // outputMode while their subagents use 'structured_output' (preserves prompt caching).
+    it('should allow template with set_output tool and non-structured_output outputMode', () => {
+      const template = {
+        ...validBaseTemplate,
+        outputMode: 'last_message' as const,
+        toolNames: ['end_turn', 'set_output'], // set_output is now allowed with any outputMode
+      }
+
+      const result = DynamicAgentTemplateSchema.safeParse(template)
+      expect(result.success).toBe(true)
+    })
+
+    it('should allow template with set_output tool and all_messages outputMode', () => {
+      const template = {
+        ...validBaseTemplate,
+        outputMode: 'all_messages' as const,
+        toolNames: ['end_turn', 'set_output'], // set_output is now allowed with any outputMode
+      }
+
+      const result = DynamicAgentTemplateSchema.safeParse(template)
+      expect(result.success).toBe(true)
+    })
+
+    it('should reject template with non-empty spawnableAgents but missing spawn_agents tool', () => {
+      const template = {
+        ...validBaseTemplate,
+        spawnableAgents: ['researcher', 'file-picker'], // Non-empty spawnableAgents
+        toolNames: ['end_turn', 'read_files'], // Missing spawn_agents
+      }
+
+      const result = DynamicAgentTemplateSchema.safeParse(template)
+      expect(result.success).toBe(false)
+      if (!result.success) {
+        const spawnAgentsError = result.error.issues.find((issue) =>
+          issue.message.includes(
+            "Non-empty spawnableAgents array requires the 'spawn_agents' tool",
+          ),
+        )
+        expect(spawnAgentsError).toBeDefined()
+        expect(spawnAgentsError?.message).toContain(
+          "Non-empty spawnableAgents array requires the 'spawn_agents' tool",
+        )
+      }
+    })
+
+    it('should accept template with non-empty spawnableAgents and spawn_agent_inline tool', () => {
+      const template = {
+        ...validBaseTemplate,
+        spawnableAgents: ['context-pruner'],
+        toolNames: ['end_turn', 'spawn_agent_inline'],
+      }
+
+      const result = DynamicAgentTemplateSchema.safeParse(template)
+      expect(result.success).toBe(true)
+    })
+
+    it('should accept template with non-empty spawnableAgents and a handleSteps generator', () => {
+      const template = {
+        ...validBaseTemplate,
+        spawnableAgents: ['context-pruner'],
+        toolNames: ['end_turn', 'read_files'],
+        handleSteps: `function* () { yield { toolName: 'spawn_agent_inline', input: { agent_type: 'context-pruner' } } }`,
+      }
+
+      const result = DynamicAgentTemplateSchema.safeParse(template)
+      expect(result.success).toBe(true)
+    })
+
+    it('should accept template with non-empty spawnableAgents and spawn_agents tool', () => {
+      const template = {
+        ...validBaseTemplate,
+        spawnableAgents: ['researcher', 'file-picker'],
+        toolNames: ['end_turn', 'spawn_agents'],
+      }
+
+      const result = DynamicAgentTemplateSchema.safeParse(template)
+      expect(result.success).toBe(true)
+    })
+
+    it('should accept template with empty spawnableAgents and no spawn_agents tool', () => {
+      const template = {
+        ...validBaseTemplate,
+        spawnableAgents: [], // Empty spawnableAgents
+        toolNames: ['end_turn', 'read_files'], // No spawn_agents needed
+      }
+
+      const result = DynamicAgentTemplateSchema.safeParse(template)
+      expect(result.success).toBe(true)
+    })
+  })
+
+  describe('Edge Cases', () => {
+    it('should handle empty schemas', () => {
+      const template = {
+        ...validBaseTemplate,
+        inputSchema: {},
+      }
+
+      const result = DynamicAgentDefinitionSchema.safeParse(template)
+      expect(result.success).toBe(true)
+    })
+
+    it('should handle schemas with additional properties', () => {
+      const template = {
+        ...validBaseTemplate,
+        inputSchema: {
+          prompt: {
+            type: 'string',
+            description: 'A test prompt',
+            customProperty: 'custom value',
+            anotherProperty: { nested: 'object' },
+          },
+        },
+      }
+
+      const result = DynamicAgentDefinitionSchema.safeParse(template)
+      expect(result.success).toBe(true)
+    })
+
+    it('should handle very long schema definitions', () => {
+      const largeSchema: any = {
+        type: 'object',
+        properties: {},
+      }
+
+      // Create a large schema with many properties
+      for (let i = 0; i < 100; i++) {
+        largeSchema.properties[`property${i}`] = {
+          type: 'string',
+          description: `Property ${i} description`,
+        }
+      }
+
+      const template = {
+        ...validBaseTemplate,
+        inputSchema: {
+          params: largeSchema,
+        },
+      }
+
+      const result = DynamicAgentDefinitionSchema.safeParse(template)
+      expect(result.success).toBe(true)
+    })
+  })
+})