@elevasis/core 0.46.0 → 0.47.0

package/dist/auth/index.d.ts

@@ -2880,6 +2880,138 @@ type Database = {
                 };
                 Relationships: [];
             };
+            agent_access_grants: {
+                Row: {
+                    allowed_origins: string[];
+                    branding: Json;
+                    capture_fields: Json;
+                    code_hash: string | null;
+                    code_salt: string | null;
+                    created_at: string;
+                    disabled_at: string | null;
+                    expires_at: string | null;
+                    id: string;
+                    max_sessions_per_visitor: number;
+                    max_turns_per_session: number;
+                    mode: string;
+                    organization_id: string;
+                    resource_id: string;
+                    slug: string;
+                    tool_policy: Json;
+                    updated_at: string;
+                };
+                Insert: {
+                    allowed_origins?: string[];
+                    branding?: Json;
+                    capture_fields?: Json;
+                    code_hash?: string | null;
+                    code_salt?: string | null;
+                    created_at?: string;
+                    disabled_at?: string | null;
+                    expires_at?: string | null;
+                    id?: string;
+                    max_sessions_per_visitor?: number;
+                    max_turns_per_session?: number;
+                    mode?: string;
+                    organization_id: string;
+                    resource_id: string;
+                    slug: string;
+                    tool_policy?: Json;
+                    updated_at?: string;
+                };
+                Update: {
+                    allowed_origins?: string[];
+                    branding?: Json;
+                    capture_fields?: Json;
+                    code_hash?: string | null;
+                    code_salt?: string | null;
+                    created_at?: string;
+                    disabled_at?: string | null;
+                    expires_at?: string | null;
+                    id?: string;
+                    max_sessions_per_visitor?: number;
+                    max_turns_per_session?: number;
+                    mode?: string;
+                    organization_id?: string;
+                    resource_id?: string;
+                    slug?: string;
+                    tool_policy?: Json;
+                    updated_at?: string;
+                };
+                Relationships: [
+                    {
+                        foreignKeyName: "agent_access_grants_organization_id_fkey";
+                        columns: ["organization_id"];
+                        isOneToOne: false;
+                        referencedRelation: "organizations";
+                        referencedColumns: ["id"];
+                    }
+                ];
+            };
+            agent_chat_capabilities: {
+                Row: {
+                    created_at: string;
+                    expires_at: string;
+                    grant_id: string;
+                    id: string;
+                    organization_id: string;
+                    origin: string | null;
+                    resource_id: string;
+                    revoked_at: string | null;
+                    session_id: string | null;
+                    token_hash: string;
+                    visitor_id: string | null;
+                };
+                Insert: {
+                    created_at?: string;
+                    expires_at: string;
+                    grant_id: string;
+                    id?: string;
+                    organization_id: string;
+                    origin?: string | null;
+                    resource_id: string;
+                    revoked_at?: string | null;
+                    session_id?: string | null;
+                    token_hash: string;
+                    visitor_id?: string | null;
+                };
+                Update: {
+                    created_at?: string;
+                    expires_at?: string;
+                    grant_id?: string;
+                    id?: string;
+                    organization_id?: string;
+                    origin?: string | null;
+                    resource_id?: string;
+                    revoked_at?: string | null;
+                    session_id?: string | null;
+                    token_hash?: string;
+                    visitor_id?: string | null;
+                };
+                Relationships: [
+                    {
+                        foreignKeyName: "agent_chat_capabilities_grant_id_fkey";
+                        columns: ["grant_id"];
+                        isOneToOne: false;
+                        referencedRelation: "agent_access_grants";
+                        referencedColumns: ["id"];
+                    },
+                    {
+                        foreignKeyName: "agent_chat_capabilities_organization_id_fkey";
+                        columns: ["organization_id"];
+                        isOneToOne: false;
+                        referencedRelation: "organizations";
+                        referencedColumns: ["id"];
+                    },
+                    {
+                        foreignKeyName: "agent_chat_capabilities_session_id_fkey";
+                        columns: ["session_id"];
+                        isOneToOne: false;
+                        referencedRelation: "sessions";
+                        referencedColumns: ["session_id"];
+                    }
+                ];
+            };
             organizations: {
                 Row: {
                     config: Json;

package/dist/test-utils/index.d.ts

@@ -2117,6 +2117,138 @@ type Database = {
                 };
                 Relationships: [];
             };
+            agent_access_grants: {
+                Row: {
+                    allowed_origins: string[];
+                    branding: Json;
+                    capture_fields: Json;
+                    code_hash: string | null;
+                    code_salt: string | null;
+                    created_at: string;
+                    disabled_at: string | null;
+                    expires_at: string | null;
+                    id: string;
+                    max_sessions_per_visitor: number;
+                    max_turns_per_session: number;
+                    mode: string;
+                    organization_id: string;
+                    resource_id: string;
+                    slug: string;
+                    tool_policy: Json;
+                    updated_at: string;
+                };
+                Insert: {
+                    allowed_origins?: string[];
+                    branding?: Json;
+                    capture_fields?: Json;
+                    code_hash?: string | null;
+                    code_salt?: string | null;
+                    created_at?: string;
+                    disabled_at?: string | null;
+                    expires_at?: string | null;
+                    id?: string;
+                    max_sessions_per_visitor?: number;
+                    max_turns_per_session?: number;
+                    mode?: string;
+                    organization_id: string;
+                    resource_id: string;
+                    slug: string;
+                    tool_policy?: Json;
+                    updated_at?: string;
+                };
+                Update: {
+                    allowed_origins?: string[];
+                    branding?: Json;
+                    capture_fields?: Json;
+                    code_hash?: string | null;
+                    code_salt?: string | null;
+                    created_at?: string;
+                    disabled_at?: string | null;
+                    expires_at?: string | null;
+                    id?: string;
+                    max_sessions_per_visitor?: number;
+                    max_turns_per_session?: number;
+                    mode?: string;
+                    organization_id?: string;
+                    resource_id?: string;
+                    slug?: string;
+                    tool_policy?: Json;
+                    updated_at?: string;
+                };
+                Relationships: [
+                    {
+                        foreignKeyName: "agent_access_grants_organization_id_fkey";
+                        columns: ["organization_id"];
+                        isOneToOne: false;
+                        referencedRelation: "organizations";
+                        referencedColumns: ["id"];
+                    }
+                ];
+            };
+            agent_chat_capabilities: {
+                Row: {
+                    created_at: string;
+                    expires_at: string;
+                    grant_id: string;
+                    id: string;
+                    organization_id: string;
+                    origin: string | null;
+                    resource_id: string;
+                    revoked_at: string | null;
+                    session_id: string | null;
+                    token_hash: string;
+                    visitor_id: string | null;
+                };
+                Insert: {
+                    created_at?: string;
+                    expires_at: string;
+                    grant_id: string;
+                    id?: string;
+                    organization_id: string;
+                    origin?: string | null;
+                    resource_id: string;
+                    revoked_at?: string | null;
+                    session_id?: string | null;
+                    token_hash: string;
+                    visitor_id?: string | null;
+                };
+                Update: {
+                    created_at?: string;
+                    expires_at?: string;
+                    grant_id?: string;
+                    id?: string;
+                    organization_id?: string;
+                    origin?: string | null;
+                    resource_id?: string;
+                    revoked_at?: string | null;
+                    session_id?: string | null;
+                    token_hash?: string;
+                    visitor_id?: string | null;
+                };
+                Relationships: [
+                    {
+                        foreignKeyName: "agent_chat_capabilities_grant_id_fkey";
+                        columns: ["grant_id"];
+                        isOneToOne: false;
+                        referencedRelation: "agent_access_grants";
+                        referencedColumns: ["id"];
+                    },
+                    {
+                        foreignKeyName: "agent_chat_capabilities_organization_id_fkey";
+                        columns: ["organization_id"];
+                        isOneToOne: false;
+                        referencedRelation: "organizations";
+                        referencedColumns: ["id"];
+                    },
+                    {
+                        foreignKeyName: "agent_chat_capabilities_session_id_fkey";
+                        columns: ["session_id"];
+                        isOneToOne: false;
+                        referencedRelation: "sessions";
+                        referencedColumns: ["session_id"];
+                    }
+                ];
+            };
             organizations: {
                 Row: {
                     config: Json;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elevasis/core",
-  "version": "0.46.0",
+  "version": "0.47.0",
   "license": "MIT",
   "description": "Minimal shared constants across Elevasis monorepo",
   "sideEffects": false,
@@ -75,6 +75,7 @@
     "lint": "eslint src --max-warnings 0",
     "check-types": "tsc --noEmit",
     "test": "vitest run",
+    "test:publish-artifacts": "pnpm build:publish && vitest run src/__tests__/publish.test.ts src/__tests__/published-artifact.test.ts",
     "test:watch": "vitest watch",
     "clean": "rm -rf dist"
   }

package/src/__tests__/observability-exports.test.ts

@@ -1,25 +1,30 @@
-import { describe, it, expect } from 'vitest'
-
-describe('Observability Exports', () => {
-  it('exports error tracking types from main package', async () => {
-    // Test that types can be imported from the main package
-    const {
-      ErrorRecordSchema,
-      ErrorDetailFullSchema,
-      ErrorDistributionSchema,
-      ErrorTrendSchema
-    } = await import('../index')
-
-    expect(ErrorRecordSchema).toBeDefined()
-    expect(ErrorDetailFullSchema).toBeDefined()
-    expect(ErrorDistributionSchema).toBeDefined()
-    expect(ErrorTrendSchema).toBeDefined()
-  })
-
-  it('schemas validate correctly when imported from main package', async () => {
-    const { ErrorRecordSchema } = await import('../index')
-
-    const validRecord = {
+import { beforeAll, describe, it, expect } from 'vitest'
+
+let coreExports: typeof import('../index')
+
+describe('Observability Exports', () => {
+  beforeAll(async () => {
+    coreExports = await import('../index')
+  }, 60000)
+
+  it('exports error tracking types from main package', () => {
+    const {
+      ErrorRecordSchema,
+      ErrorDetailFullSchema,
+      ErrorDistributionSchema,
+      ErrorTrendSchema
+    } = coreExports
+
+    expect(ErrorRecordSchema).toBeDefined()
+    expect(ErrorDetailFullSchema).toBeDefined()
+    expect(ErrorDistributionSchema).toBeDefined()
+    expect(ErrorTrendSchema).toBeDefined()
+  })
+
+  it('schemas validate correctly when imported from main package', () => {
+    const { ErrorRecordSchema } = coreExports
+
+    const validRecord = {
       id: '123e4567-e89b-12d3-a456-426614174000',
       timestamp: '2024-01-15T10:30:00Z',
       errorType: 'ValidationError',

package/src/__tests__/published-artifact.test.ts

@@ -0,0 +1,99 @@
+import { afterEach, describe, expect, it } from 'vitest'
+import { execFile } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+import { promisify } from 'node:util'
+
+const execFileAsync = promisify(execFile)
+const coreRoot = path.resolve(import.meta.dirname, '../..')
+const distRoot = path.resolve(coreRoot, 'dist')
+const packageJsonPath = path.resolve(coreRoot, 'package.json')
+const tempRoots: string[] = []
+
+const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8')) as {
+  version: string
+  type: string
+  sideEffects?: boolean | string[]
+  publishConfig?: {
+    name?: string
+    exports?: Record<string, string | { types?: string; import?: string }>
+  }
+}
+
+function packagePath(target: string): string {
+  return path.resolve(coreRoot, target.replace(/^\.\//, ''))
+}
+
+function createConsumerPackage(): string {
+  const tempRoot = fs.mkdtempSync(path.join(coreRoot, '.tmp-published-core-'))
+  tempRoots.push(tempRoot)
+
+  const packageRoot = path.join(tempRoot, 'node_modules', '@elevasis', 'core')
+  fs.mkdirSync(packageRoot, { recursive: true })
+  fs.cpSync(distRoot, path.join(packageRoot, 'dist'), { recursive: true })
+  fs.writeFileSync(
+    path.join(packageRoot, 'package.json'),
+    JSON.stringify(
+      {
+        name: packageJson.publishConfig?.name,
+        version: packageJson.version,
+        type: packageJson.type,
+        sideEffects: packageJson.sideEffects,
+        exports: packageJson.publishConfig?.exports
+      },
+      null,
+      2
+    )
+  )
+
+  return tempRoot
+}
+
+describe.skipIf(!fs.existsSync(distRoot))('published @elevasis/core artifact', { timeout: 30_000 }, () => {
+  afterEach(() => {
+    for (const tempRoot of tempRoots.splice(0)) {
+      fs.rmSync(tempRoot, { recursive: true, force: true })
+    }
+  })
+
+  it('has publish-ready runtime and declaration artifacts for every public export', () => {
+    expect(packageJson.publishConfig?.name).toBe('@elevasis/core')
+
+    for (const [subpath, entry] of Object.entries(packageJson.publishConfig?.exports ?? {})) {
+      if (typeof entry === 'string') {
+        expect(entry, `${subpath} must point at dist`).toMatch(/^\.\//)
+        expect(fs.existsSync(packagePath(entry)), `${subpath} target does not exist: ${entry}`).toBe(true)
+        continue
+      }
+
+      expect(entry.types, `${subpath} is missing a types condition`).toBeTruthy()
+      expect(entry.import, `${subpath} is missing an import condition`).toBeTruthy()
+      expect(fs.existsSync(packagePath(entry.types ?? '')), `${subpath} types do not exist: ${entry.types}`).toBe(true)
+      expect(fs.existsSync(packagePath(entry.import ?? '')), `${subpath} runtime does not exist: ${entry.import}`).toBe(
+        true
+      )
+    }
+  })
+
+  it('resolves public runtime subpaths from a temp consumer package', async () => {
+    const consumerRoot = createConsumerPackage()
+    const smokeScript = `
+      const core = await import('@elevasis/core')
+      const auth = await import('@elevasis/core/auth')
+      const orgModel = await import('@elevasis/core/organization-model')
+      const entities = await import('@elevasis/core/entities')
+      const knowledge = await import('@elevasis/core/knowledge')
+
+      if (!core.DEFAULT_ORGANIZATION_MODEL) throw new Error('missing DEFAULT_ORGANIZATION_MODEL')
+      if (!auth.AccessKeys) throw new Error('missing AccessKeys')
+      if (typeof orgModel.defineOrganizationModel !== 'function') throw new Error('missing defineOrganizationModel')
+      if (!entities.BaseProjectSchema) throw new Error('missing BaseProjectSchema')
+      if (typeof knowledge.parsePath !== 'function') throw new Error('missing parsePath')
+    `
+
+    await execFileAsync(process.execPath, ['--input-type=module', '--eval', smokeScript], {
+      cwd: consumerRoot,
+      maxBuffer: 1024 * 1024
+    })
+  })
+})

package/src/execution/engine/llm/__tests__/model-info.test.ts

@@ -1,10 +1,10 @@
-/**
- * Model Info Tests
- * Verifies registration of gemini-3.1-flash-lite-preview in MODEL_INFO and GoogleConfigSchema
- */
-
-import { describe, it, expect } from 'vitest'
-import { MODEL_INFO, GoogleConfigSchema } from '../model-info'
+/**
+ * Model Info Tests
+ * Verifies model registrations in MODEL_INFO and provider config schemas
+ */
+
+import { describe, it, expect } from 'vitest'
+import { AnthropicConfigSchema, MODEL_INFO, GoogleConfigSchema } from '../model-info'
 
 describe('gemini-3.1-flash-lite-preview registration', () => {
   it('exists in MODEL_INFO with correct pricing', () => {
@@ -46,5 +46,78 @@ describe('gemini-3.1-flash-lite-preview registration', () => {
   it('GoogleModel type includes gemini-3.1-flash-lite-preview via MODEL_INFO key check', () => {
     const modelKeys = Object.keys(MODEL_INFO)
     expect(modelKeys).toContain('gemini-3.1-flash-lite-preview')
-  })
-})
+  })
+})
+
+describe('current Anthropic model registration', () => {
+  it('registers Opus 4.8 with current pricing and token limits', () => {
+    const info = MODEL_INFO['claude-opus-4-8']
+
+    expect(info).toBeDefined()
+    expect(info.inputCostPer1M).toBe(500)
+    expect(info.outputCostPer1M).toBe(2500)
+    expect(info.maxTokens).toBe(1000000)
+    expect(info.maxOutputTokens).toBe(128000)
+  })
+
+  it('registers Sonnet 4.6 with current pricing and token limits', () => {
+    const info = MODEL_INFO['claude-sonnet-4-6']
+
+    expect(info).toBeDefined()
+    expect(info.inputCostPer1M).toBe(300)
+    expect(info.outputCostPer1M).toBe(1500)
+    expect(info.maxTokens).toBe(1000000)
+    expect(info.maxOutputTokens).toBe(64000)
+  })
+
+  it('registers Haiku 4.5 dated ID and alias with current pricing and token limits', () => {
+    const datedInfo = MODEL_INFO['claude-haiku-4-5-20251001']
+    const aliasInfo = MODEL_INFO['claude-haiku-4-5']
+
+    expect(datedInfo).toBeDefined()
+    expect(aliasInfo).toBeDefined()
+    expect(datedInfo.inputCostPer1M).toBe(100)
+    expect(datedInfo.outputCostPer1M).toBe(500)
+    expect(datedInfo.maxTokens).toBe(200000)
+    expect(datedInfo.maxOutputTokens).toBe(64000)
+    expect(aliasInfo).toMatchObject({
+      inputCostPer1M: datedInfo.inputCostPer1M,
+      outputCostPer1M: datedInfo.outputCostPer1M,
+      maxTokens: datedInfo.maxTokens,
+      maxOutputTokens: datedInfo.maxOutputTokens
+    })
+  })
+
+  it.each(['claude-opus-4-8', 'claude-sonnet-4-6', 'claude-haiku-4-5-20251001', 'claude-haiku-4-5'])(
+    'AnthropicConfigSchema validates %s',
+    (model) => {
+      const result = AnthropicConfigSchema.safeParse({
+        model,
+        provider: 'anthropic',
+        apiKey: 'test-key',
+        maxOutputTokens: 4000
+      })
+
+      expect(result.success).toBe(true)
+    }
+  )
+
+  it('rejects non-default Opus 4.8 sampling parameters', () => {
+    const temperatureResult = AnthropicConfigSchema.safeParse({
+      model: 'claude-opus-4-8',
+      provider: 'anthropic',
+      apiKey: 'test-key',
+      temperature: 0.7
+    })
+
+    const topPResult = AnthropicConfigSchema.safeParse({
+      model: 'claude-opus-4-8',
+      provider: 'anthropic',
+      apiKey: 'test-key',
+      topP: 0.9
+    })
+
+    expect(temperatureResult.success).toBe(false)
+    expect(topPResult.success).toBe(false)
+  })
+})

package/src/execution/engine/llm/__tests__/model-validation.test.ts

@@ -71,20 +71,47 @@ describe('validateModelConfig', () => {
       }).not.toThrow()
     })
 
-    it('passes for config without topP', () => {
-      expect(() => {
-        validateModelConfig({
-          model: 'gpt-5',
-          provider: 'openai',
+    it('passes for config without topP', () => {
+      expect(() => {
+        validateModelConfig({
+          model: 'gpt-5',
+          provider: 'openai',
           apiKey: 'test-key',
           temperature: 1,
           maxOutputTokens: 8000
-        })
-      }).not.toThrow()
-    })
-  })
+        })
+      }).not.toThrow()
+    })
+
+    it.each(['claude-opus-4-8', 'claude-sonnet-4-6', 'claude-haiku-4-5-20251001', 'claude-haiku-4-5'] as const)(
+      'passes for Anthropic %s',
+      (model) => {
+        expect(() => {
+          validateModelConfig({
+            model,
+            provider: 'anthropic',
+            apiKey: 'test-key',
+            maxOutputTokens: 4000
+          })
+        }).not.toThrow()
+      }
+    )
+
+    it('passes for Sonnet 4.6 with sampling parameters', () => {
+      expect(() => {
+        validateModelConfig({
+          model: 'claude-sonnet-4-6',
+          provider: 'anthropic',
+          apiKey: 'test-key',
+          temperature: 0.7,
+          topP: 0.9,
+          maxOutputTokens: 4000
+        })
+      }).not.toThrow()
+    })
+  })
 
-  describe('Invalid Temperature', () => {
+  describe('Invalid Temperature', () => {
     it('throws for gpt-5 with temperature=0.7', () => {
       expect(() => {
         validateModelConfig({
@@ -109,9 +136,9 @@ describe('validateModelConfig', () => {
       }).toThrow(ModelConfigError)
     })
 
-    it('provides correct error details for invalid temperature', () => {
-      try {
-        validateModelConfig({
+    it('provides correct error details for invalid temperature', () => {
+      try {
+        validateModelConfig({
           model: 'gpt-5',
           provider: 'openai',
           apiKey: 'test-key',
@@ -123,10 +150,48 @@ describe('validateModelConfig', () => {
         expect(error).toBeInstanceOf(ModelConfigError)
         const modelError = error as ModelConfigError
         expect(modelError.field).toBe('temperature')
-        expect(modelError.model).toBe('gpt-5')
-      }
-    })
-  })
+        expect(modelError.model).toBe('gpt-5')
+      }
+    })
+
+    it('throws for Opus 4.8 with non-default temperature', () => {
+      expect(() => {
+        validateModelConfig({
+          model: 'claude-opus-4-8',
+          provider: 'anthropic',
+          apiKey: 'test-key',
+          temperature: 0.7,
+          maxOutputTokens: 4000
+        })
+      }).toThrow(ModelConfigError)
+    })
+  })
+
+  describe('Invalid Anthropic Sampling Parameters', () => {
+    it('throws for Opus 4.8 with non-default topP', () => {
+      expect(() => {
+        validateModelConfig({
+          model: 'claude-opus-4-8',
+          provider: 'anthropic',
+          apiKey: 'test-key',
+          topP: 0.9,
+          maxOutputTokens: 4000
+        })
+      }).toThrow(ModelConfigError)
+    })
+
+    it('throws for Opus 4.8 with top_k', () => {
+      expect(() => {
+        validateModelConfig({
+          model: 'claude-opus-4-8',
+          provider: 'anthropic',
+          apiKey: 'test-key',
+          maxOutputTokens: 4000,
+          top_k: 40
+        } as unknown as Parameters<typeof validateModelConfig>[0])
+      }).toThrow(ModelConfigError)
+    })
+  })
 
   describe('Invalid maxOutputTokens', () => {
     it('throws for maxOutputTokens below minimum', () => {