@alumbwe/anvil 1.0.42 → 1.0.49

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

@@ -1,132 +0,0 @@
-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

@@ -1,422 +0,0 @@
-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)
-    })
-  })
-})