id.org.ai 0.1.0

package/test/agent-identity.test.ts

@@ -0,0 +1,356 @@
+/**
+ * AgentIdentity Tests - RED PHASE
+ *
+ * Tests for the AgentIdentity type which extends Identity for AI agents.
+ * These tests WILL FAIL until the implementation is complete in GREEN phase.
+ */
+
+import { describe, it, expect } from 'vitest'
+import {
+  AgentIdentity,
+  AgentIdentitySchema,
+  isAgentIdentity,
+  createAgentIdentity,
+} from '../src'
+
+describe('AgentIdentity', () => {
+  describe('interface shape', () => {
+    it('should have required $id field', () => {
+      const agent: AgentIdentity = {
+        $id: 'https://example.com/agents/1',
+        $type: 'https://schema.org.ai/AgentIdentity',
+        model: 'claude-3-opus',
+        capabilities: ['text', 'code'],
+        autonomous: false,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      }
+      expect(agent.$id).toBe('https://example.com/agents/1')
+    })
+
+    it('should have required $type field with correct value', () => {
+      const agent: AgentIdentity = {
+        $id: 'https://example.com/agents/1',
+        $type: 'https://schema.org.ai/AgentIdentity',
+        model: 'claude-3-opus',
+        capabilities: ['text'],
+        autonomous: false,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      }
+      expect(agent.$type).toBe('https://schema.org.ai/AgentIdentity')
+    })
+
+    it('should have required model field', () => {
+      const agent: AgentIdentity = {
+        $id: 'https://example.com/agents/1',
+        $type: 'https://schema.org.ai/AgentIdentity',
+        model: 'claude-3-opus',
+        capabilities: ['text'],
+        autonomous: false,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      }
+      expect(agent.model).toBe('claude-3-opus')
+    })
+
+    it('should have required capabilities array', () => {
+      const agent: AgentIdentity = {
+        $id: 'https://example.com/agents/1',
+        $type: 'https://schema.org.ai/AgentIdentity',
+        model: 'claude-3-opus',
+        capabilities: ['text', 'code', 'vision'],
+        autonomous: false,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      }
+      expect(agent.capabilities).toEqual(['text', 'code', 'vision'])
+    })
+
+    it('should have required autonomous boolean', () => {
+      const agent: AgentIdentity = {
+        $id: 'https://example.com/agents/1',
+        $type: 'https://schema.org.ai/AgentIdentity',
+        model: 'claude-3-opus',
+        capabilities: ['text'],
+        autonomous: true,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      }
+      expect(agent.autonomous).toBe(true)
+    })
+
+    it('should inherit createdAt and updatedAt from Identity', () => {
+      const now = new Date().toISOString()
+      const agent: AgentIdentity = {
+        $id: 'https://example.com/agents/1',
+        $type: 'https://schema.org.ai/AgentIdentity',
+        model: 'claude-3-opus',
+        capabilities: ['text'],
+        autonomous: false,
+        createdAt: now,
+        updatedAt: now,
+      }
+      expect(agent.createdAt).toBe(now)
+      expect(agent.updatedAt).toBe(now)
+    })
+  })
+
+  describe('Zod schema validation', () => {
+    it('should validate a valid AgentIdentity object', () => {
+      const result = AgentIdentitySchema.safeParse({
+        $id: 'https://example.com/agents/1',
+        $type: 'https://schema.org.ai/AgentIdentity',
+        model: 'claude-3-opus',
+        capabilities: ['text', 'code'],
+        autonomous: false,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('should validate AgentIdentity with empty capabilities', () => {
+      const result = AgentIdentitySchema.safeParse({
+        $id: 'https://example.com/agents/1',
+        $type: 'https://schema.org.ai/AgentIdentity',
+        model: 'gpt-4',
+        capabilities: [],
+        autonomous: false,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('should reject AgentIdentity without model', () => {
+      const result = AgentIdentitySchema.safeParse({
+        $id: 'https://example.com/agents/1',
+        $type: 'https://schema.org.ai/AgentIdentity',
+        capabilities: ['text'],
+        autonomous: false,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('should reject AgentIdentity without capabilities', () => {
+      const result = AgentIdentitySchema.safeParse({
+        $id: 'https://example.com/agents/1',
+        $type: 'https://schema.org.ai/AgentIdentity',
+        model: 'claude-3-opus',
+        autonomous: false,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('should reject AgentIdentity with non-array capabilities', () => {
+      const result = AgentIdentitySchema.safeParse({
+        $id: 'https://example.com/agents/1',
+        $type: 'https://schema.org.ai/AgentIdentity',
+        model: 'claude-3-opus',
+        capabilities: 'text',
+        autonomous: false,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('should reject AgentIdentity without autonomous', () => {
+      const result = AgentIdentitySchema.safeParse({
+        $id: 'https://example.com/agents/1',
+        $type: 'https://schema.org.ai/AgentIdentity',
+        model: 'claude-3-opus',
+        capabilities: ['text'],
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('should reject AgentIdentity with non-boolean autonomous', () => {
+      const result = AgentIdentitySchema.safeParse({
+        $id: 'https://example.com/agents/1',
+        $type: 'https://schema.org.ai/AgentIdentity',
+        model: 'claude-3-opus',
+        capabilities: ['text'],
+        autonomous: 'yes',
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('should reject AgentIdentity with wrong $type', () => {
+      const result = AgentIdentitySchema.safeParse({
+        $id: 'https://example.com/agents/1',
+        $type: 'https://schema.org.ai/User',
+        model: 'claude-3-opus',
+        capabilities: ['text'],
+        autonomous: false,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('should reject completely invalid data', () => {
+      const result = AgentIdentitySchema.safeParse({ invalid: 'data' })
+      expect(result.success).toBe(false)
+    })
+
+    it('should reject non-object values', () => {
+      expect(AgentIdentitySchema.safeParse(null).success).toBe(false)
+      expect(AgentIdentitySchema.safeParse(undefined).success).toBe(false)
+      expect(AgentIdentitySchema.safeParse('string').success).toBe(false)
+      expect(AgentIdentitySchema.safeParse(123).success).toBe(false)
+    })
+  })
+
+  describe('isAgentIdentity type guard', () => {
+    it('should return true for valid AgentIdentity', () => {
+      const agent = {
+        $id: 'https://example.com/agents/1',
+        $type: 'https://schema.org.ai/AgentIdentity',
+        model: 'claude-3-opus',
+        capabilities: ['text', 'code'],
+        autonomous: false,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      }
+      expect(isAgentIdentity(agent)).toBe(true)
+    })
+
+    it('should return true for autonomous AgentIdentity', () => {
+      const agent = {
+        $id: 'https://example.com/agents/1',
+        $type: 'https://schema.org.ai/AgentIdentity',
+        model: 'claude-3-opus',
+        capabilities: ['text'],
+        autonomous: true,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      }
+      expect(isAgentIdentity(agent)).toBe(true)
+    })
+
+    it('should return false for invalid data', () => {
+      expect(isAgentIdentity({ invalid: 'data' })).toBe(false)
+    })
+
+    it('should return false for null', () => {
+      expect(isAgentIdentity(null)).toBe(false)
+    })
+
+    it('should return false for undefined', () => {
+      expect(isAgentIdentity(undefined)).toBe(false)
+    })
+
+    it('should return false for Identity (base type)', () => {
+      const identity = {
+        $id: 'https://example.com/identities/1',
+        $type: 'https://schema.org.ai/Identity',
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      }
+      expect(isAgentIdentity(identity)).toBe(false)
+    })
+
+    it('should return false for User', () => {
+      const user = {
+        $id: 'https://example.com/users/1',
+        $type: 'https://schema.org.ai/User',
+        email: 'test@example.com',
+        name: 'Test User',
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      }
+      expect(isAgentIdentity(user)).toBe(false)
+    })
+  })
+
+  describe('createAgentIdentity factory', () => {
+    it('should create a valid AgentIdentity with required fields', () => {
+      const agent = createAgentIdentity({
+        model: 'claude-3-opus',
+        capabilities: ['text', 'code'],
+        autonomous: false,
+      })
+      expect(agent.$type).toBe('https://schema.org.ai/AgentIdentity')
+      expect(agent.model).toBe('claude-3-opus')
+      expect(agent.capabilities).toEqual(['text', 'code'])
+      expect(agent.autonomous).toBe(false)
+    })
+
+    it('should auto-generate $id', () => {
+      const agent = createAgentIdentity({
+        model: 'gpt-4',
+        capabilities: ['text'],
+        autonomous: true,
+      })
+      expect(agent.$id).toBeDefined()
+      expect(agent.$id).toMatch(/^https:\/\//)
+    })
+
+    it('should auto-generate timestamps', () => {
+      const before = new Date().toISOString()
+      const agent = createAgentIdentity({
+        model: 'claude-3-opus',
+        capabilities: ['text'],
+        autonomous: false,
+      })
+      const after = new Date().toISOString()
+      expect(agent.createdAt >= before).toBe(true)
+      expect(agent.createdAt <= after).toBe(true)
+      expect(agent.updatedAt >= before).toBe(true)
+      expect(agent.updatedAt <= after).toBe(true)
+    })
+
+    it('should allow custom $id override', () => {
+      const customId = 'https://custom.com/agents/custom-1'
+      const agent = createAgentIdentity({
+        $id: customId,
+        model: 'claude-3-opus',
+        capabilities: ['text'],
+        autonomous: false,
+      })
+      expect(agent.$id).toBe(customId)
+    })
+
+    it('should create autonomous agent when specified', () => {
+      const agent = createAgentIdentity({
+        model: 'claude-3-opus',
+        capabilities: ['text', 'code', 'execute'],
+        autonomous: true,
+      })
+      expect(agent.autonomous).toBe(true)
+    })
+
+    it('should pass validation after creation', () => {
+      const agent = createAgentIdentity({
+        model: 'claude-3-opus',
+        capabilities: ['text'],
+        autonomous: false,
+      })
+      expect(isAgentIdentity(agent)).toBe(true)
+      expect(AgentIdentitySchema.safeParse(agent).success).toBe(true)
+    })
+
+    it('should support various model names', () => {
+      const models = ['claude-3-opus', 'claude-3-sonnet', 'gpt-4', 'gpt-4-turbo', 'gemini-pro']
+      for (const model of models) {
+        const agent = createAgentIdentity({
+          model,
+          capabilities: ['text'],
+          autonomous: false,
+        })
+        expect(agent.model).toBe(model)
+        expect(isAgentIdentity(agent)).toBe(true)
+      }
+    })
+  })
+})

package/test/credential.test.ts

@@ -0,0 +1,337 @@
+/**
+ * Credential Tests - RED PHASE
+ *
+ * Tests for the Credential type used for authentication credentials.
+ * These tests WILL FAIL until the implementation is complete in GREEN phase.
+ */
+
+import { describe, it, expect } from 'vitest'
+import {
+  Credential,
+  CredentialSchema,
+  isCredential,
+  createCredential,
+  CredentialType,
+} from '../src'
+
+describe('Credential', () => {
+  describe('interface shape', () => {
+    it('should have required $id field', () => {
+      const credential: Credential = {
+        $id: 'https://example.com/credentials/1',
+        $type: 'https://schema.org.ai/Credential',
+        identityId: 'https://example.com/users/1',
+        credentialType: 'password',
+      }
+      expect(credential.$id).toBe('https://example.com/credentials/1')
+    })
+
+    it('should have required $type field with correct value', () => {
+      const credential: Credential = {
+        $id: 'https://example.com/credentials/1',
+        $type: 'https://schema.org.ai/Credential',
+        identityId: 'https://example.com/users/1',
+        credentialType: 'password',
+      }
+      expect(credential.$type).toBe('https://schema.org.ai/Credential')
+    })
+
+    it('should have required identityId field', () => {
+      const credential: Credential = {
+        $id: 'https://example.com/credentials/1',
+        $type: 'https://schema.org.ai/Credential',
+        identityId: 'https://example.com/users/1',
+        credentialType: 'password',
+      }
+      expect(credential.identityId).toBe('https://example.com/users/1')
+    })
+
+    it('should have required credentialType field', () => {
+      const credential: Credential = {
+        $id: 'https://example.com/credentials/1',
+        $type: 'https://schema.org.ai/Credential',
+        identityId: 'https://example.com/users/1',
+        credentialType: 'oauth',
+      }
+      expect(credential.credentialType).toBe('oauth')
+    })
+
+    it('should support optional provider field', () => {
+      const credential: Credential = {
+        $id: 'https://example.com/credentials/1',
+        $type: 'https://schema.org.ai/Credential',
+        identityId: 'https://example.com/users/1',
+        credentialType: 'oauth',
+        provider: 'google',
+      }
+      expect(credential.provider).toBe('google')
+    })
+
+    it('should support optional expiresAt field', () => {
+      const expiresAt = new Date(Date.now() + 3600000).toISOString()
+      const credential: Credential = {
+        $id: 'https://example.com/credentials/1',
+        $type: 'https://schema.org.ai/Credential',
+        identityId: 'https://example.com/users/1',
+        credentialType: 'api_key',
+        expiresAt,
+      }
+      expect(credential.expiresAt).toBe(expiresAt)
+    })
+  })
+
+  describe('CredentialType enum', () => {
+    it('should include password type', () => {
+      const credential: Credential = {
+        $id: 'https://example.com/credentials/1',
+        $type: 'https://schema.org.ai/Credential',
+        identityId: 'https://example.com/users/1',
+        credentialType: 'password',
+      }
+      expect(credential.credentialType).toBe('password')
+    })
+
+    it('should include oauth type', () => {
+      const credential: Credential = {
+        $id: 'https://example.com/credentials/1',
+        $type: 'https://schema.org.ai/Credential',
+        identityId: 'https://example.com/users/1',
+        credentialType: 'oauth',
+        provider: 'github',
+      }
+      expect(credential.credentialType).toBe('oauth')
+    })
+
+    it('should include api_key type', () => {
+      const credential: Credential = {
+        $id: 'https://example.com/credentials/1',
+        $type: 'https://schema.org.ai/Credential',
+        identityId: 'https://example.com/agents/1',
+        credentialType: 'api_key',
+      }
+      expect(credential.credentialType).toBe('api_key')
+    })
+
+    it('should include sso type', () => {
+      const credential: Credential = {
+        $id: 'https://example.com/credentials/1',
+        $type: 'https://schema.org.ai/Credential',
+        identityId: 'https://example.com/users/1',
+        credentialType: 'sso',
+        provider: 'okta',
+      }
+      expect(credential.credentialType).toBe('sso')
+    })
+  })
+
+  describe('Zod schema validation', () => {
+    it('should validate a valid Credential object', () => {
+      const result = CredentialSchema.safeParse({
+        $id: 'https://example.com/credentials/1',
+        $type: 'https://schema.org.ai/Credential',
+        identityId: 'https://example.com/users/1',
+        credentialType: 'password',
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('should validate Credential with all optional fields', () => {
+      const result = CredentialSchema.safeParse({
+        $id: 'https://example.com/credentials/1',
+        $type: 'https://schema.org.ai/Credential',
+        identityId: 'https://example.com/users/1',
+        credentialType: 'oauth',
+        provider: 'google',
+        expiresAt: new Date(Date.now() + 3600000).toISOString(),
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('should reject Credential without $id', () => {
+      const result = CredentialSchema.safeParse({
+        $type: 'https://schema.org.ai/Credential',
+        identityId: 'https://example.com/users/1',
+        credentialType: 'password',
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('should reject Credential without identityId', () => {
+      const result = CredentialSchema.safeParse({
+        $id: 'https://example.com/credentials/1',
+        $type: 'https://schema.org.ai/Credential',
+        credentialType: 'password',
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('should reject Credential without credentialType', () => {
+      const result = CredentialSchema.safeParse({
+        $id: 'https://example.com/credentials/1',
+        $type: 'https://schema.org.ai/Credential',
+        identityId: 'https://example.com/users/1',
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('should reject Credential with invalid credentialType', () => {
+      const result = CredentialSchema.safeParse({
+        $id: 'https://example.com/credentials/1',
+        $type: 'https://schema.org.ai/Credential',
+        identityId: 'https://example.com/users/1',
+        credentialType: 'invalid_type',
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('should reject Credential with wrong $type', () => {
+      const result = CredentialSchema.safeParse({
+        $id: 'https://example.com/credentials/1',
+        $type: 'https://schema.org.ai/Session',
+        identityId: 'https://example.com/users/1',
+        credentialType: 'password',
+      })
+      expect(result.success).toBe(false)
+    })
+
+    it('should reject completely invalid data', () => {
+      const result = CredentialSchema.safeParse({ invalid: 'data' })
+      expect(result.success).toBe(false)
+    })
+
+    it('should reject non-object values', () => {
+      expect(CredentialSchema.safeParse(null).success).toBe(false)
+      expect(CredentialSchema.safeParse(undefined).success).toBe(false)
+      expect(CredentialSchema.safeParse('string').success).toBe(false)
+      expect(CredentialSchema.safeParse(123).success).toBe(false)
+    })
+  })
+
+  describe('isCredential type guard', () => {
+    it('should return true for valid Credential', () => {
+      const credential = {
+        $id: 'https://example.com/credentials/1',
+        $type: 'https://schema.org.ai/Credential',
+        identityId: 'https://example.com/users/1',
+        credentialType: 'password',
+      }
+      expect(isCredential(credential)).toBe(true)
+    })
+
+    it('should return true for Credential with provider', () => {
+      const credential = {
+        $id: 'https://example.com/credentials/1',
+        $type: 'https://schema.org.ai/Credential',
+        identityId: 'https://example.com/users/1',
+        credentialType: 'oauth',
+        provider: 'github',
+      }
+      expect(isCredential(credential)).toBe(true)
+    })
+
+    it('should return true for Credential with expiresAt', () => {
+      const credential = {
+        $id: 'https://example.com/credentials/1',
+        $type: 'https://schema.org.ai/Credential',
+        identityId: 'https://example.com/users/1',
+        credentialType: 'api_key',
+        expiresAt: new Date(Date.now() + 3600000).toISOString(),
+      }
+      expect(isCredential(credential)).toBe(true)
+    })
+
+    it('should return false for invalid data', () => {
+      expect(isCredential({ invalid: 'data' })).toBe(false)
+    })
+
+    it('should return false for null', () => {
+      expect(isCredential(null)).toBe(false)
+    })
+
+    it('should return false for undefined', () => {
+      expect(isCredential(undefined)).toBe(false)
+    })
+
+    it('should return false for Session type', () => {
+      const session = {
+        $id: 'https://example.com/sessions/1',
+        $type: 'https://schema.org.ai/Session',
+        identityId: 'https://example.com/users/1',
+        token: 'abc123',
+        expiresAt: new Date(Date.now() + 3600000).toISOString(),
+      }
+      expect(isCredential(session)).toBe(false)
+    })
+  })
+
+  describe('createCredential factory', () => {
+    it('should create a valid Credential with required fields', () => {
+      const credential = createCredential({
+        identityId: 'https://example.com/users/1',
+        credentialType: 'password',
+      })
+      expect(credential.$type).toBe('https://schema.org.ai/Credential')
+      expect(credential.identityId).toBe('https://example.com/users/1')
+      expect(credential.credentialType).toBe('password')
+    })
+
+    it('should auto-generate $id', () => {
+      const credential = createCredential({
+        identityId: 'https://example.com/users/1',
+        credentialType: 'password',
+      })
+      expect(credential.$id).toBeDefined()
+      expect(credential.$id).toMatch(/^https:\/\//)
+    })
+
+    it('should allow custom $id override', () => {
+      const customId = 'https://custom.com/credentials/custom-1'
+      const credential = createCredential({
+        $id: customId,
+        identityId: 'https://example.com/users/1',
+        credentialType: 'password',
+      })
+      expect(credential.$id).toBe(customId)
+    })
+
+    it('should accept optional provider', () => {
+      const credential = createCredential({
+        identityId: 'https://example.com/users/1',
+        credentialType: 'oauth',
+        provider: 'google',
+      })
+      expect(credential.provider).toBe('google')
+    })
+
+    it('should accept optional expiresAt', () => {
+      const expiresAt = new Date(Date.now() + 3600000).toISOString()
+      const credential = createCredential({
+        identityId: 'https://example.com/users/1',
+        credentialType: 'api_key',
+        expiresAt,
+      })
+      expect(credential.expiresAt).toBe(expiresAt)
+    })
+
+    it('should create credentials for all credential types', () => {
+      const types: CredentialType[] = ['password', 'oauth', 'api_key', 'sso']
+      for (const credType of types) {
+        const credential = createCredential({
+          identityId: 'https://example.com/users/1',
+          credentialType: credType,
+        })
+        expect(credential.credentialType).toBe(credType)
+        expect(isCredential(credential)).toBe(true)
+      }
+    })
+
+    it('should pass validation after creation', () => {
+      const credential = createCredential({
+        identityId: 'https://example.com/users/1',
+        credentialType: 'password',
+      })
+      expect(isCredential(credential)).toBe(true)
+      expect(CredentialSchema.safeParse(credential).success).toBe(true)
+    })
+  })
+})