@elevasis/core 0.45.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/knowledge/index.d.ts

@@ -1597,22 +1597,24 @@ declare function listAllResources(model: OrganizationModel): NonNullable<Organiz
  */
 declare function listAllRoles(model: OrganizationModel): NonNullable<OrganizationModel['roles']>[string][];
 /** The recognized mount axes for Knowledge Map paths. */
-type KnowledgeMount = 'by-system' | 'by-ontology' | 'by-kind' | 'by-owner' | 'graph' | 'node' | 'all-systems' | 'all-resources' | 'all-roles';
+type KnowledgeMount = 'by-system' | 'by-ontology' | 'by-kind' | 'by-owner' | 'graph' | 'node' | 'all-systems' | 'all-resources' | 'all-roles' | 'by-domain' | 'by-item';
 /**
  * The result of parsing a Knowledge Map path string.
  *
  * Shape: `{ mount: KnowledgeMount, args: string[] }`
  *
  * Per-mount arg arrays:
- * - `by-system`:    `[systemId]`   (e.g. `['sales.crm']`)
- * - `by-ontology`:  `[ontologyId]` (e.g. `['sales.crm:object/deal']`)
- * - `by-kind`:      `[kind]`       (e.g. `['playbook']`)
- * - `by-owner`:     `[ownerId]`    (e.g. `['role.ops-lead']`)
- * - `graph`:        `[nodeId, verb]` where verb is `'governs'` or `'governed-by'`
- * - `node`:         `[nodeId]`     (single node lookup, no sub-path)
- * - `all-systems`:  `[]`           (no args — returns all systems flattened)
- * - `all-resources`:`[]`           (no args — returns all resources)
- * - `all-roles`:    `[]`           (no args — returns all roles)
+ * - `by-system`:    `[systemId]`      (e.g. `['sales.crm']`)
+ * - `by-ontology`:  `[ontologyId]`    (e.g. `['sales.crm:object/deal']`)
+ * - `by-kind`:      `[kind]`          (e.g. `['playbook']`)
+ * - `by-owner`:     `[ownerId]`       (e.g. `['role.ops-lead']`)
+ * - `graph`:        `[nodeId, verb]`  where verb is `'governs'` or `'governed-by'`
+ * - `node`:         `[nodeId]`        (single node lookup, no sub-path)
+ * - `all-systems`:  `[]`              (no args — returns all systems flattened)
+ * - `all-resources`:`[]`              (no args — returns all resources)
+ * - `all-roles`:    `[]`              (no args — returns all roles)
+ * - `by-domain`:    `[domain]`        (e.g. `['clients']`) — enumerate all items in domain
+ * - `by-item`:      `[domain, itemId]` (e.g. `['clients', '<uuid>']`) — single domain-item
  */
 interface ParsedKnowledgePath {
     mount: KnowledgeMount;
@@ -1632,6 +1634,8 @@ interface ParsedKnowledgePath {
  *   `/all-systems`                    -> `{ mount: ‘all-systems’,  args: [] }`
  *   `/all-resources`                  -> `{ mount: ‘all-resources’,args: [] }`
  *   `/all-roles`                      -> `{ mount: ‘all-roles’,    args: [] }`
+ *   `/by-domain/<domain>`             -> `{ mount: ‘by-domain’,    args: [‘<domain>’] }`
+ *   `/by-item/<domain>/<itemId>`      -> `{ mount: ‘by-item’,      args: [‘<domain>’, ‘<itemId>’] }`
  *
  * The path MUST start with `/`.  Trailing slashes are stripped before parsing.
  *

package/dist/knowledge/index.js

@@ -101,6 +101,7 @@ function getSystem(model, path) {
 }
 
 // src/knowledge/queries.ts
+var DOMAIN_ITEM_KINDS = ["clients", "roles", "policies", "customers", "offerings", "goals"];
 function toGraphNodeId(omNodeId) {
   return `knowledge:${omNodeId}`;
 }
@@ -224,11 +225,32 @@ function parsePath(pathString) {
   if (first === "all-roles" && rest.length === 0) {
     return { mount: "all-roles", args: [] };
   }
+  if (first === "by-domain") {
+    if (rest.length === 0) {
+      throw new Error(`parsePath: /by-domain requires a domain argument, got: "${pathString}"`);
+    }
+    const domain = rest[0];
+    if (!DOMAIN_ITEM_KINDS.includes(domain)) {
+      throw new Error(`parsePath: /by-domain unknown domain "${domain}". Supported: ${DOMAIN_ITEM_KINDS.join(", ")}`);
+    }
+    return { mount: "by-domain", args: [domain] };
+  }
+  if (first === "by-item") {
+    if (rest.length < 2) {
+      throw new Error(`parsePath: /by-item requires <domain>/<itemId>, got: "${pathString}"`);
+    }
+    const domain = rest[0];
+    if (!DOMAIN_ITEM_KINDS.includes(domain)) {
+      throw new Error(`parsePath: /by-item unknown domain "${domain}". Supported: ${DOMAIN_ITEM_KINDS.join(", ")}`);
+    }
+    const itemId = rest.slice(1).join("/");
+    return { mount: "by-item", args: [domain, itemId] };
+  }
   if (segments.length === 1) {
     return { mount: "node", args: [first] };
   }
   throw new Error(
-    `parsePath: unrecognized path pattern "${pathString}". Supported: /by-system/<id>, /by-kind/<kind>, /by-owner/<id>, /graph/<nodeId>/governs, /graph/<nodeId>/governed-by, /<nodeId>, /all-systems, /all-resources, /all-roles`
+    `parsePath: unrecognized path pattern "${pathString}". Supported: /by-system/<id>, /by-kind/<kind>, /by-owner/<id>, /by-domain/<domain>, /by-item/<domain>/<itemId>, /graph/<nodeId>/governs, /graph/<nodeId>/governed-by, /<nodeId>, /all-systems, /all-resources, /all-roles`
   );
 }
 

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.45.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)
+  })
+})