The TypeScript framework for
governed AI agents

import { defineAgent } from '@elsium-ai/agents'
import { defineTool, createToolkit } from '@elsium-ai/tools'
import { z } from 'zod'

const weatherTool = defineTool({
  name: 'get_weather',
  description: 'Get current weather for a city',
  input: z.object({
    city: z.string().describe('City name'),
  }),
  handler: async ({ city }) => {
    return { temperature: 22, condition: 'sunny', city }
  },
})

const tools = createToolkit('weather', [weatherTool])

const agent = defineAgent(
  {
    name: 'weather-assistant',
    system: 'You help users check the weather.',
    tools: [...tools.tools],
    guardrails: {
      maxIterations: 5,
      security: { detectPromptInjection: true },
    },
  },
  { complete: (req) => llm.complete(req) },
)

const result = await agent.run('Weather in Tokyo?')

import { createProviderMesh, securityMiddleware } from '@elsium-ai/gateway'
import { createPolicySet, policyMiddleware, costLimitPolicy } from '@elsium-ai/core'
import { createAuditTrail, auditMiddleware } from '@elsium-ai/observe'

// Multi-provider mesh with auto-failover
const mesh = createProviderMesh({
  providers: [
    { name: 'anthropic', config: { apiKey: env('ANTHROPIC_API_KEY') } },
    { name: 'openai',    config: { apiKey: env('OPENAI_API_KEY')    } },
  ],
  strategy: 'fallback',
  circuitBreaker: { failureThreshold: 5, resetTimeoutMs: 30_000 },
})

// Governance: policies + audit + security
const policies = createPolicySet([costLimitPolicy(5.00)])
const audit = createAuditTrail({ hashChain: true })

const llm = gateway({
  provider: 'anthropic',
  apiKey: env('ANTHROPIC_API_KEY'),
  middleware: [
    securityMiddleware({ promptInjection: true, secretRedaction: true }),
    policyMiddleware(policies),
    auditMiddleware(audit),
  ],
})