@elevasis/core 0.46.0 → 0.48.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

@@ -1538,6 +1538,7 @@ interface OrganizationGraph {
  * @param systemId - The dotted system id (e.g. `sales.crm`).
  */
 declare function bySystem(graph: OrganizationGraph, systemId: string, knowledgeNodes: OrgKnowledgeNode[]): OrgKnowledgeNode[];
+declare function byOntology(graph: OrganizationGraph, ontologyId: string, knowledgeNodes: OrgKnowledgeNode[]): OrgKnowledgeNode[];
 /**
  * Returns all knowledge nodes whose `kind` matches the given kind.
  *
@@ -1745,5 +1746,5 @@ declare function formatKnowledgeInvocationLabel(invocation: OrganizationModelAct
 declare function resolveKnowledgeInvocationNeighbors(model: OrganizationModel, id: string): KnowledgeInvocationNeighborsResult | undefined;
 declare function formatKnowledgeInvocationNeighbors(result: KnowledgeInvocationNeighborsResult): string;
 
-export { OM_SEARCH_HIT_KINDS, byKind, byOwner, bySystem, formatIdsOnly, formatJson, formatKnowledgeInvocationLabel, formatKnowledgeInvocationNeighbors, formatKnowledgeResourcesList, formatKnowledgeRolesList, formatKnowledgeSystemsList, formatText, governedBy, governs, normalizeKnowledgeNodeId, parseKnowledgeSearchKinds, parseKnowledgeSearchLimit, parsePath, resolveKnowledgeInvocationNeighbors };
+export { OM_SEARCH_HIT_KINDS, byKind, byOntology, byOwner, bySystem, formatIdsOnly, formatJson, formatKnowledgeInvocationLabel, formatKnowledgeInvocationNeighbors, formatKnowledgeResourcesList, formatKnowledgeRolesList, formatKnowledgeSystemsList, formatText, governedBy, governs, normalizeKnowledgeNodeId, parseKnowledgeSearchKinds, parseKnowledgeSearchLimit, parsePath, resolveKnowledgeInvocationNeighbors };
 export type { KnowledgeInvocationNeighborsResult, KnowledgeInvocationSource, KnowledgeJsonEnvelope, KnowledgeMount, OmSearchHitKind, ParsedKnowledgePath };

package/dist/knowledge/index.js

@@ -140,6 +140,22 @@ function bySystem(graph, systemId, knowledgeNodes) {
   }
   return knowledgeNodes.filter((n) => matchingOmIds.has(n.id));
 }
+function byOntology(graph, ontologyId, knowledgeNodes) {
+  const targetGraphNodeId = toTargetGraphNodeId(ontologyId);
+  const governingKnowledgeNodeIds = /* @__PURE__ */ new Set();
+  for (const edge of graph.edges) {
+    if (edge.kind === "governs" && edge.targetId === targetGraphNodeId && edge.sourceId.startsWith("knowledge:")) {
+      governingKnowledgeNodeIds.add(edge.sourceId);
+    }
+  }
+  const sourceIdMap = buildKnowledgeSourceIdMap(graph);
+  const matchingOmIds = /* @__PURE__ */ new Set();
+  for (const graphNodeId of governingKnowledgeNodeIds) {
+    const omId = sourceIdMap.get(graphNodeId);
+    if (omId) matchingOmIds.add(omId);
+  }
+  return knowledgeNodes.filter((n) => matchingOmIds.has(n.id));
+}
 function byKind(_graph, kind, knowledgeNodes) {
   return knowledgeNodes.filter((n) => n.kind === kind);
 }
@@ -433,4 +449,4 @@ function formatKnowledgeInvocationNeighbors(result) {
   return lines.join("\n");
 }
 
-export { OM_SEARCH_HIT_KINDS, byKind, byOwner, bySystem, formatIdsOnly, formatJson, formatKnowledgeInvocationLabel, formatKnowledgeInvocationNeighbors, formatKnowledgeResourcesList, formatKnowledgeRolesList, formatKnowledgeSystemsList, formatText, governedBy, governs, normalizeKnowledgeNodeId, parseKnowledgeSearchKinds, parseKnowledgeSearchLimit, parsePath, resolveKnowledgeInvocationNeighbors };
+export { OM_SEARCH_HIT_KINDS, byKind, byOntology, byOwner, bySystem, formatIdsOnly, formatJson, formatKnowledgeInvocationLabel, formatKnowledgeInvocationNeighbors, formatKnowledgeResourcesList, formatKnowledgeRolesList, formatKnowledgeSystemsList, formatText, governedBy, governs, normalizeKnowledgeNodeId, parseKnowledgeSearchKinds, parseKnowledgeSearchLimit, parsePath, resolveKnowledgeInvocationNeighbors };

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.48.0",
   "license": "MIT",
   "description": "Minimal shared constants across Elevasis monorepo",
   "sideEffects": false,
@@ -45,8 +45,8 @@
     "rollup-plugin-dts": "^6.3.0",
     "tsup": "^8.0.0",
     "typescript": "5.9.2",
-    "@repo/eslint-config": "0.0.0",
-    "@repo/typescript-config": "0.0.0"
+    "@repo/typescript-config": "0.0.0",
+    "@repo/eslint-config": "0.0.0"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.62.0",
@@ -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)
+  })
+})