@elevasis/core 0.45.0 → 0.47.0

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

@@ -26,10 +26,15 @@ export type OpenRouterModel = 'openrouter/z-ai/glm-5'
  */
 export type GoogleModel = 'gemini-3-flash-preview' | 'gemini-3.1-flash-lite-preview'
 
-/**
- * Supported Anthropic models (direct SDK access via @anthropic-ai/sdk)
- */
-export type AnthropicModel = 'claude-sonnet-4-5'
+/**
+ * Supported Anthropic models (direct SDK access via @anthropic-ai/sdk)
+ */
+export type AnthropicModel =
+  | 'claude-opus-4-8'
+  | 'claude-sonnet-4-6'
+  | 'claude-haiku-4-5-20251001'
+  | 'claude-haiku-4-5'
+  | 'claude-sonnet-4-5'
 
 /** Supported LLM models */
 export type LLMModel = OpenAIModel | OpenRouterModel | GoogleModel | AnthropicModel | 'mock'
@@ -122,26 +127,48 @@ export const GoogleConfigSchema = z.object({
   modelOptions: GoogleOptionsSchema.optional()
 })
 
-/**
- * Anthropic model options schema
- * Currently empty - future options: budget_tokens for extended thinking
- */
-const AnthropicOptionsSchema = z.object({})
-
-/**
- * Anthropic config schema
- * Validates ModelConfig for Anthropic provider (direct SDK access)
- */
-export const AnthropicConfigSchema = z.object({
-  model: z.enum(['claude-sonnet-4-5']),
-  provider: z.literal('anthropic'),
-  apiKey: z.string(),
-  temperature: z.number().min(0).max(1).optional(),
-  maxOutputTokens: z.number().min(1000).optional(), // Anthropic requires max_tokens
-  topP: z.number().min(0).max(1).optional(),
-  modelOptions: AnthropicOptionsSchema.optional()
-})
+/**
+ * Anthropic model options schema
+ * Currently empty - future options must be added per supported model family
+ */
+const AnthropicOptionsSchema = z.object({}).strict()
 
+/**
+ * Anthropic config schema
+ * Validates ModelConfig for Anthropic provider (direct SDK access)
+ */
+const AnthropicStandardConfigSchema = z.object({
+  model: z.enum([
+    'claude-sonnet-4-6',
+    'claude-haiku-4-5-20251001',
+    'claude-haiku-4-5',
+    'claude-sonnet-4-5'
+  ]),
+  provider: z.literal('anthropic'),
+  apiKey: z.string(),
+  temperature: z.number().min(0).max(1).optional(),
+  maxOutputTokens: z.number().min(1000).max(64000).optional(), // Anthropic requires max_tokens
+  topP: z.number().min(0).max(1).optional(),
+  modelOptions: AnthropicOptionsSchema.optional()
+})
+
+const AnthropicOpus48ConfigSchema = z.object({
+  model: z.literal('claude-opus-4-8'),
+  provider: z.literal('anthropic'),
+  apiKey: z.string(),
+  temperature: z.literal(1).optional(),
+  maxOutputTokens: z.number().min(1000).max(128000).optional(), // Anthropic requires max_tokens
+  topP: z.literal(1).optional(),
+  topK: z.undefined().optional(),
+  top_k: z.undefined().optional(),
+  modelOptions: AnthropicOptionsSchema.optional()
+})
+
+export const AnthropicConfigSchema = z.discriminatedUnion('model', [
+  AnthropicOpus48ConfigSchema,
+  AnthropicStandardConfigSchema
+])
+
 /**
  * Infer TypeScript types from schemas
  */
@@ -191,16 +218,18 @@ export interface ModelInfo {
   minTokens: number
   /** Recommended tokens for production use (typically 2x minimum) */
   recommendedTokens: number
-  /** Maximum context window size (total tokens: input + output) */
-  maxTokens: number
-  /** Model category for grouping and documentation */
-  category: 'reasoning' | 'standard' | 'embedding'
-  /** Zod schema for validating complete ModelConfig (replaces constraints + optionsSchema) */
-  configSchema?: z.ZodType<ModelConfig>
-}
+  /** Maximum context window size (total tokens: input + output) */
+  maxTokens: number
+  /** Maximum output tokens supported by the synchronous generation API */
+  maxOutputTokens?: number
+  /** Model category for grouping and documentation */
+  category: 'reasoning' | 'standard' | 'embedding'
+  /** Zod schema for validating complete ModelConfig (replaces constraints + optionsSchema) */
+  configSchema?: z.ZodType<ModelConfig>
+}
 
-// Model configuration as of 2026-03-17
-export const MODEL_INFO: Record<LLMModel, ModelInfo> = {
+// Model configuration as of 2026-06-09
+export const MODEL_INFO: Record<LLMModel, ModelInfo> = {
   // OpenAI GPT-5 (Reasoning Models)
   'gpt-5': {
     inputCostPer1M: 125, // $1.25 per 1M tokens
@@ -268,17 +297,58 @@ export const MODEL_INFO: Record<LLMModel, ModelInfo> = {
     category: 'standard',
     configSchema: GoogleConfigSchema
   },
-  // Anthropic Claude Models (direct SDK access via @anthropic-ai/sdk)
-  'claude-sonnet-4-5': {
-    inputCostPer1M: 300, // $3.00 per 1M tokens
-    outputCostPer1M: 1500, // $15.00 per 1M tokens
-    minTokens: 4000,
-    recommendedTokens: 8000,
-    maxTokens: 200000, // 200k context window
-    category: 'standard',
-    configSchema: AnthropicConfigSchema
-  }
-}
+  // Anthropic Claude Models (direct SDK access via @anthropic-ai/sdk)
+  'claude-opus-4-8': {
+    inputCostPer1M: 500, // $5.00 per 1M tokens
+    outputCostPer1M: 2500, // $25.00 per 1M tokens
+    minTokens: 4000,
+    recommendedTokens: 8000,
+    maxTokens: 1000000, // 1M context window
+    maxOutputTokens: 128000,
+    category: 'reasoning',
+    configSchema: AnthropicConfigSchema
+  },
+  'claude-sonnet-4-6': {
+    inputCostPer1M: 300, // $3.00 per 1M tokens
+    outputCostPer1M: 1500, // $15.00 per 1M tokens
+    minTokens: 4000,
+    recommendedTokens: 8000,
+    maxTokens: 1000000, // 1M context window
+    maxOutputTokens: 64000,
+    category: 'standard',
+    configSchema: AnthropicConfigSchema
+  },
+  'claude-haiku-4-5-20251001': {
+    inputCostPer1M: 100, // $1.00 per 1M tokens
+    outputCostPer1M: 500, // $5.00 per 1M tokens
+    minTokens: 4000,
+    recommendedTokens: 8000,
+    maxTokens: 200000, // 200k context window
+    maxOutputTokens: 64000,
+    category: 'standard',
+    configSchema: AnthropicConfigSchema
+  },
+  'claude-haiku-4-5': {
+    inputCostPer1M: 100, // $1.00 per 1M tokens
+    outputCostPer1M: 500, // $5.00 per 1M tokens
+    minTokens: 4000,
+    recommendedTokens: 8000,
+    maxTokens: 200000, // 200k context window
+    maxOutputTokens: 64000,
+    category: 'standard',
+    configSchema: AnthropicConfigSchema
+  },
+  'claude-sonnet-4-5': {
+    inputCostPer1M: 300, // $3.00 per 1M tokens
+    outputCostPer1M: 1500, // $15.00 per 1M tokens
+    minTokens: 4000,
+    recommendedTokens: 8000,
+    maxTokens: 200000, // 200k context window
+    maxOutputTokens: 64000,
+    category: 'standard',
+    configSchema: AnthropicConfigSchema
+  }
+}
 
 /**
  * Get model information (pricing and token requirements)

package/src/knowledge/__tests__/queries.test.ts

@@ -1097,3 +1097,177 @@ describe('formatOmDescribe', () => {
     expect(output).toContain('System: sales.lead-gen')
   })
 })
+
+// ---------------------------------------------------------------------------
+// Domain-item resolution (item:<domain>:<id> + bare-id back-compat)
+// ---------------------------------------------------------------------------
+
+/**
+ * Fixture exercising all six graph-projected domain-item kinds.
+ * `knowledge.brand-guide` governs the client via a `client:client-1` link.
+ */
+const DOMAIN_ITEM_MODEL = {
+  knowledge: {
+    'knowledge.brand-guide': {
+      id: 'knowledge.brand-guide',
+      kind: 'reference',
+      title: 'Brand Guide',
+      summary: 'Branding rules for the client.',
+      body: '## Brand Guide\n\nVoice and palette.',
+      links: [{ nodeId: 'client:client-1' }],
+      ownerIds: [],
+      updatedAt: '2026-01-01'
+    }
+  },
+  clients: {
+    'client-1': {
+      id: 'client-1',
+      name: 'Byron for Irvine',
+      organizationName: 'Byron for Irvine Campaign',
+      shortName: 'Byron',
+      clientBrief: 'Local city-council campaign.',
+      candidateName: 'Byron'
+    }
+  },
+  roles: {
+    'role.ops-lead': {
+      id: 'role.ops-lead',
+      order: 10,
+      title: 'Ops Lead',
+      responsibilities: ['Run operations.'],
+      responsibleFor: []
+    }
+  },
+  policies: {
+    'policy.review-spend': {
+      id: 'policy.review-spend',
+      order: 10,
+      label: 'Review Spend',
+      description: 'Review spend over threshold.'
+    }
+  },
+  customers: {
+    'cust-1': {
+      id: 'cust-1',
+      name: 'SMB Automation Segment',
+      description: 'Small businesses adopting automation.'
+    }
+  },
+  offerings: {
+    'off-1': {
+      id: 'off-1',
+      name: 'Automation Starter Package',
+      description: 'Entry automation engagement.'
+    }
+  },
+  goals: {
+    'goal-1': {
+      id: 'goal-1',
+      description: 'Double recurring revenue this year.'
+    }
+  }
+} as unknown as OrganizationModel
+
+describe('omDescribe — domain items', () => {
+  it('resolves item:clients:<id> to the full client profile + location + governing knowledge', () => {
+    const result = omDescribe(DOMAIN_ITEM_MODEL, 'item:clients:client-1')
+    expect(result).toBeDefined()
+    if (!result || result.kind !== 'domain-item') throw new Error('expected domain-item result')
+    expect(result.domain).toBe('clients')
+    expect(result.id).toBe('item:clients:client-1')
+    expect(result.name).toBe('Byron for Irvine')
+    // Full ClientProfile payload is carried in `record`.
+    expect(result.record).toMatchObject({
+      organizationName: 'Byron for Irvine Campaign',
+      candidateName: 'Byron'
+    })
+    // Location.
+    expect(result.location.domainLabel).toBe('Clients')
+    expect(result.location.graphNodeId).toBe('client:client-1')
+    expect(result.location.containsParentIds).toContain('organization-model')
+    // Governing knowledge.
+    expect(result.governingKnowledge.map((g) => g.id)).toContain('knowledge.brand-guide')
+  })
+
+  it('resolves bare client:<id> identically to the item: form (back-compat)', () => {
+    const bare = omDescribe(DOMAIN_ITEM_MODEL, 'client:client-1')
+    const canonical = omDescribe(DOMAIN_ITEM_MODEL, 'item:clients:client-1')
+    expect(bare).toEqual(canonical)
+  })
+
+  it('resolves the other five domain kinds via item: and bare ids', () => {
+    const cases: Array<{ item: string; bare: string; domain: string; name: string }> = [
+      { item: 'item:roles:role.ops-lead', bare: 'role:role.ops-lead', domain: 'roles', name: 'Ops Lead' },
+      {
+        item: 'item:policies:policy.review-spend',
+        bare: 'policy:policy.review-spend',
+        domain: 'policies',
+        name: 'Review Spend'
+      },
+      { item: 'item:customers:cust-1', bare: 'customer:cust-1', domain: 'customers', name: 'SMB Automation Segment' },
+      { item: 'item:offerings:off-1', bare: 'offering:off-1', domain: 'offerings', name: 'Automation Starter Package' },
+      { item: 'item:goals:goal-1', bare: 'goal:goal-1', domain: 'goals', name: 'Double recurring revenue this year.' }
+    ]
+    for (const c of cases) {
+      const viaItem = omDescribe(DOMAIN_ITEM_MODEL, c.item)
+      expect(viaItem, `item form ${c.item}`).toBeDefined()
+      if (!viaItem || viaItem.kind !== 'domain-item') throw new Error(`expected domain-item for ${c.item}`)
+      expect(viaItem.domain).toBe(c.domain)
+      expect(viaItem.name).toBe(c.name)
+      // Bare form resolves to the same result.
+      expect(omDescribe(DOMAIN_ITEM_MODEL, c.bare)).toEqual(viaItem)
+    }
+  })
+
+  it('returns undefined for an unknown item id', () => {
+    expect(omDescribe(DOMAIN_ITEM_MODEL, 'item:clients:does-not-exist')).toBeUndefined()
+    expect(omDescribe(DOMAIN_ITEM_MODEL, 'client:does-not-exist')).toBeUndefined()
+  })
+
+  it('returns undefined for an item ref with an unknown domain', () => {
+    expect(omDescribe(DOMAIN_ITEM_MODEL, 'item:widgets:thing-1')).toBeUndefined()
+  })
+})
+
+describe('parsePath — domain-item mounts', () => {
+  it('parses /by-domain/<domain> into a by-domain mount', () => {
+    expect(parsePath('/by-domain/clients')).toEqual({ mount: 'by-domain', args: ['clients'] })
+  })
+
+  it('parses /by-item/<domain>/<itemId> into a by-item mount', () => {
+    expect(parsePath('/by-item/clients/client-1')).toEqual({ mount: 'by-item', args: ['clients', 'client-1'] })
+  })
+
+  it('throws on an unknown domain for /by-domain', () => {
+    expect(() => parsePath('/by-domain/widgets')).toThrow(/unknown domain/i)
+  })
+
+  it('throws on an unknown domain for /by-item', () => {
+    expect(() => parsePath('/by-item/widgets/thing-1')).toThrow(/unknown domain/i)
+  })
+
+  it('throws when /by-item is missing the itemId', () => {
+    expect(() => parsePath('/by-item/clients')).toThrow(/by-item/i)
+  })
+})
+
+describe('formatOmDescribe — domain items', () => {
+  it('renders a domain-item header, location, record, and governing knowledge', () => {
+    const result = omDescribe(DOMAIN_ITEM_MODEL, 'item:clients:client-1')
+    const output = formatOmDescribe(result)
+    expect(output).toContain('Domain Item: item:clients:client-1')
+    expect(output).toContain('Domain: Clients')
+    expect(output).toContain('Name: Byron for Irvine')
+    expect(output).toContain('Graph node: client:client-1')
+    expect(output).toContain('Governing knowledge:')
+    expect(output).toContain('knowledge.brand-guide')
+  })
+
+  it('serializes the domain-item result directly via JSON.stringify', () => {
+    const result = omDescribe(DOMAIN_ITEM_MODEL, 'item:clients:client-1')
+    const json = JSON.parse(JSON.stringify(result))
+    expect(json.kind).toBe('domain-item')
+    expect(json.domain).toBe('clients')
+    expect(json.id).toBe('item:clients:client-1')
+  })
+})

package/src/knowledge/format.ts

@@ -1,6 +1,7 @@
 import type { OrgKnowledgeNode } from '../organization-model/domains/knowledge'
 import type {
   KnowledgeMount,
+  OmDescribeDomainItem,
   OmDescribeKnowledge,
   OmDescribeOntology,
   OmDescribePolicy,
@@ -170,6 +171,8 @@ export function formatOmDescribe(result: OmDescribeResult | undefined): string {
       return formatRoleDescribe(result)
     case 'policy':
       return formatPolicyDescribe(result)
+    case 'domain-item':
+      return formatDomainItemDescribe(result)
   }
 }
 
@@ -320,3 +323,39 @@ function formatPolicyDescribe(r: OmDescribePolicy): string {
 
   return join([header, effectSection, appliesSection])
 }
+
+function formatDomainItemDescribe(r: OmDescribeDomainItem): string {
+  const header = join([
+    `Domain Item: ${r.id}`,
+    [
+      field('Domain', r.location.domainLabel),
+      field('Name', r.name),
+      field('Graph node', r.location.graphNodeId),
+      field('Parent nodes', r.location.containsParentIds.join(', '))
+    ]
+      .filter((s) => s.length > 0)
+      .join('\n')
+  ])
+
+  // Key record fields — emit a compact subset of the record payload.
+  const recordLines: string[] = []
+  for (const [k, v] of Object.entries(r.record)) {
+    if (v === undefined || v === null) continue
+    if (typeof v === 'object' && !Array.isArray(v) && Object.keys(v).length === 0) continue
+    const display = Array.isArray(v)
+      ? v.length === 0
+        ? null
+        : `[${(v as unknown[]).slice(0, 5).join(', ')}${v.length > 5 ? `, ...+${v.length - 5}` : ''}]`
+      : typeof v === 'object'
+        ? JSON.stringify(v).slice(0, 120)
+        : String(v)
+    if (display === null) continue
+    recordLines.push(`  ${k}: ${display}`)
+  }
+  const recordSection = recordLines.length ? `Record:\n${recordLines.join('\n')}` : ''
+
+  const govLines = r.governingKnowledge.map((g) => `  - ${g.id} [${g.knowledgeKind}] ${g.title}`)
+  const govSection = govLines.length ? `Governing knowledge:\n${govLines.join('\n')}` : 'Governing knowledge:\n  (none)'
+
+  return join([header, recordSection, govSection])
+}

package/src/knowledge/index.ts

@@ -10,7 +10,8 @@ export {
   omDescribe,
   listAllSystemsFlat,
   listAllResources,
-  listAllRoles
+  listAllRoles,
+  DOMAIN_ITEM_KINDS
 } from './queries'
 export type {
   KnowledgeMount,
@@ -24,7 +25,11 @@ export type {
   OmDescribeKnowledge,
   OmDescribeOntology,
   OmDescribeRole,
-  OmDescribePolicy
+  OmDescribePolicy,
+  OmDescribeDomainItem,
+  OmDescribeDomainItemLocation,
+  OmDescribeDomainItemKnowledgeRef,
+  DomainItemKind
 } from './queries'
 
 export { formatText, formatJson, formatIdsOnly, formatOmSearchHits, formatOmDescribe } from './format'