@agentuity/claude-code 2.0.10 → 3.0.0-alpha.0

package/skills/agentuity-backend/SKILL.md

@@ -1,13 +1,11 @@
 ---
 name: agentuity-backend
-description: When working with Agentuity SDK backend packages including @agentuity/runtime, @agentuity/schema, @agentuity/drizzle, @agentuity/postgres, @agentuity/evals, @agentuity/core, or @agentuity/server. Activates when writing agent handlers, using ctx.* APIs, setting up schemas, database connections, or evaluation frameworks.
-version: 1.0.0
+description: When building AI agents, backend APIs, or server-side logic with Agentuity. Covers @agentuity/runtime for agent handlers and HTTP routing, @agentuity/schema for validation, @agentuity/drizzle and @agentuity/postgres for database access, and @agentuity/evals for testing agent quality.
+version: 2.0.0
 ---
 
 # Agentuity Backend Reference
 
-Deep reference material for the Agentuity SDK backend packages used to build agents, APIs, and server-side applications.
-
 ## Package Overview
 
 | Package               | Purpose                                             |
@@ -31,450 +29,255 @@ Deep reference material for the Agentuity SDK backend packages used to build age
 | `zod`                  | `@agentuity/schema`   | Lightweight, built-in, StandardSchemaV1              |
 | `console.log`          | `ctx.logger`          | Structured, observable, OpenTelemetry                |
 | Generic SQL clients    | Bun's native `sql`    | Bun-native, auto-credentials                         |
+| `createRouter()` wrapper | `new Hono<Env>()` directly | Chained methods enable hc<AppRouter>() type safety |
 
 **Note:** Both Zod and @agentuity/schema implement StandardSchemaV1, so agent schemas accept either.
 
-## Reference URLs
-
-When uncertain, look up:
-
-- **SDK Source**: https://github.com/agentuity/sdk/tree/main/packages
-- **Docs**: https://agentuity.dev
-- **Runtime**: https://github.com/agentuity/sdk/tree/main/packages/runtime/src
-- **Examples**: https://github.com/agentuity/sdk/tree/main/apps/testing/integration-suite
-
----
-
-## @agentuity/runtime
+## AI Gateway (Default — No API Keys Needed)
 
-### createAgent()
+LLM requests automatically route through Agentuity's **AI Gateway** when running via `agentuity dev` or deployed. **Do not ask users for LLM provider API keys.** The gateway supports models from any provider (OpenAI, Anthropic, Groq, etc.) — use the provider SDK that matches the model:
 
 ```typescript
-import { createAgent } from '@agentuity/runtime';
-import { s } from '@agentuity/schema';
-
-export default createAgent('my-agent', {
-	description: 'What this agent does',
-	schema: {
-		input: s.object({ message: s.string() }),
-		output: s.object({ reply: s.string() }),
-	},
-	// Optional: setup runs once on app startup
-	setup: async (app) => {
-		const cache = new Map();
-		return { cache }; // Available via ctx.config
-	},
-	// Optional: cleanup on shutdown
-	shutdown: async (app, config) => {
-		config.cache.clear();
-	},
-	handler: async (ctx, input) => {
-		// ctx has all services
-		return { reply: `Got: ${input.message}` };
-	},
+// For OpenAI models (gpt-5-mini, gpt-5, etc.) — use the OpenAI SDK
+import OpenAI from 'openai';
+const openai = new OpenAI();
+const res = await openai.chat.completions.create({
+  model: 'gpt-5-mini',
+  messages: [{ role: 'user', content: input.message }],
 });
 ```
 
-**CRITICAL:** Do NOT add type annotations to handler parameters - let TypeScript infer them from schema.
-
-### AgentContext (ctx)
-
-| Property          | Purpose                                                |
-| ----------------- | ------------------------------------------------------ |
-| `ctx.logger`      | Structured logging (trace/debug/info/warn/error/fatal) |
-| `ctx.tracer`      | OpenTelemetry tracing                                  |
-| `ctx.kv`          | Key-value storage                                      |
-| `ctx.vector`      | Semantic search                                        |
-| `ctx.stream`      | Stream storage                                         |
-| `ctx.sandbox`     | Code execution                                         |
-| `ctx.auth`        | User authentication (if configured)                    |
-| `ctx.thread`      | Conversation context (up to 1 hour)                    |
-| `ctx.session`     | Request-scoped context                                 |
-| `ctx.state`       | Request-scoped Map (sync)                              |
-| `ctx.config`      | Agent config from setup()                              |
-| `ctx.app`         | App state from createApp setup()                       |
-| `ctx.current`     | Agent metadata (name, agentId, version)                |
-| `ctx.sessionId`   | Unique request ID                                      |
-| `ctx.waitUntil()` | Background tasks after response                        |
-
-### State Management
-
 ```typescript
-handler: async (ctx, input) => {
-	// Thread state - persists across requests in same conversation (async)
-	const history = (await ctx.thread.state.get<Message[]>('messages')) || [];
-	history.push({ role: 'user', content: input.message });
-	await ctx.thread.state.set('messages', history);
-
-	// Session state - persists for request duration (sync)
-	ctx.session.state.set('lastInput', input.message);
-
-	// Request state - cleared after handler (sync)
-	ctx.state.set('startTime', Date.now());
-
-	// KV - persists across threads/projects
-	await ctx.kv.set('namespace', 'key', value);
-};
-```
-
-### Calling Other Agents
-
-```typescript
-// Import at top of file
-import otherAgent from '@agent/other-agent';
-
-handler: async (ctx, input) => {
-	// Type-safe call
-	const result = await otherAgent.run({ query: input.text });
-	return { data: result };
-};
+// For Anthropic models (claude-sonnet-4-6, etc.) — use the Anthropic SDK
+import Anthropic from '@anthropic-ai/sdk';
+const anthropic = new Anthropic();
+const res = await anthropic.messages.create({
+  model: 'claude-sonnet-4-6',
+  max_tokens: 1024,
+  messages: [{ role: 'user', content: input.message }],
+});
 ```
 
-### Streaming Responses
-
 ```typescript
-import { createAgent } from '@agentuity/runtime';
-import { streamText } from 'ai';
+// Or use the Vercel AI SDK for a provider-agnostic approach
+import { generateText } from 'ai';
 import { openai } from '@ai-sdk/openai';
-
-export default createAgent('chat', {
-	schema: {
-		input: s.object({ message: s.string() }),
-		stream: true, // Enable streaming
-	},
-	handler: async (ctx, input) => {
-		const { textStream } = streamText({
-			model: openai('gpt-4o'),
-			prompt: input.message,
-		});
-		return textStream;
-	},
+const { text } = await generateText({
+  model: openai('gpt-5-mini'),
+  prompt: input.message,
 });
 ```
 
-### Background Tasks
+No API keys needed — the gateway sets provider base URLs automatically. **Match the SDK to the model provider** — don't pass Anthropic model names to the OpenAI client or vice versa.
 
-```typescript
-handler: async (ctx, input) => {
-	// Schedule non-blocking work after response
-	ctx.waitUntil(async () => {
-		await ctx.vector.upsert('docs', {
-			key: input.docId,
-			document: input.content,
-		});
-	});
-
-	return { status: 'Queued for indexing' };
-};
-```
+**Important:** The AI Gateway only works when running via `agentuity dev` or when deployed to Agentuity. It does NOT work with raw `bun run app.ts`.
 
-### Route Validation with agent.validator()
+- Docs: https://agentuity.dev/agents/ai-gateway.md
+- Docs: https://agentuity.dev/agents/ai-sdk-integration.md
 
-```typescript
-import { createRouter } from '@agentuity/runtime';
-import myAgent from '@agent/my-agent';
+## Key Concepts
 
-const router = createRouter();
+- Agents are created with `createAgent('name', { description, schema, handler })` from `@agentuity/runtime`
+- Agents must be barrel-exported from `src/agent/index.ts` and passed to `createApp({ agents })`
+- Handler receives `ctx` (AgentContext) and typed `input`
+- `ctx` provides: logger, tracer, kv, vector, stream, sandbox, auth, thread, session, state, config
+- Schemas use `@agentuity/schema` (or Zod — both implement StandardSchemaV1)
+- Call other agents via `@agent/<name>` import alias
+- DON'T add type annotations to handler params — let TS infer from schema
 
-// Use agent's schema for automatic validation
-router.post('/', myAgent.validator(), async (c) => {
-	const data = c.req.valid('json'); // Fully typed!
-	return c.json(await myAgent.run(data));
-});
+## Agents Need API Routes
+
+**Agents are NOT HTTP endpoints.** To expose an agent over HTTP, create a route in `src/api/` that calls it. Use Hono directly with chained methods for type safety:
+
+```typescript
+// src/api/index.ts — compose all routes into a single Hono instance
+import { Hono } from 'hono';
+import type { Env } from '@agentuity/runtime';
+import chat from '@agent/chat';
+
+const router = new Hono<Env>()
+  .post('/chat', chat.validator(), async (c) => {
+    const data = c.req.valid('json');
+    const result = await chat.run(data);
+    return c.json(result);
+  });
+
+export default router;
 ```
 
----
+For streaming responses, use the `stream()` middleware:
 
-## @agentuity/schema
+```typescript
+import { Hono } from 'hono';
+import type { Env } from '@agentuity/runtime';
+import { stream } from '@agentuity/runtime';
+import chat from '@agent/chat';
+
+const router = new Hono<Env>()
+  .post('/chat', stream(async (c) => {
+    const body = await c.req.json();
+    return chat.run(body);
+  }));
+
+export default router;
+```
 
-Lightweight schema validation implementing StandardSchemaV1.
+For routes that don't call agents, use the standalone `validator()` for schema validation:
 
 ```typescript
+import { Hono } from 'hono';
+import type { Env } from '@agentuity/runtime';
+import { validator } from '@agentuity/runtime';
 import { s } from '@agentuity/schema';
 
-const userSchema = s.object({
-	name: s.string(),
-	email: s.string(),
-	age: s.number().optional(),
-	role: s.enum(['admin', 'user', 'guest']),
-	metadata: s
-		.object({
-			createdAt: s.string(),
-		})
-		.optional(),
-	tags: s.array(s.string()),
+const OutputSchema = s.object({
+  history: s.array(s.object({ text: s.string(), timestamp: s.string() })),
 });
 
-// Type inference
-type User = s.Infer<typeof userSchema>;
+const router = new Hono<Env>()
+  .get('/history', validator({ output: OutputSchema }), async (c) => {
+    const history = (await c.var.thread.state.get('history')) ?? [];
+    return c.json({ history });
+  });
 
-// Coercion schemas
-s.coerce.string(); // Coerces to string
-s.coerce.number(); // Coerces to number
-s.coerce.boolean(); // Coerces to boolean
-s.coerce.date(); // Coerces to Date
+export default router;
 ```
 
-**When to use Zod instead:**
+- Docs: https://agentuity.dev/routes/http.md
 
-- Complex validation rules (.email(), .url(), .min(), .max())
-- User prefers Zod
-- Existing Zod schemas in codebase
+## Agent Context vs Route Context
 
-Both work with StandardSchemaV1 - agent schemas accept either.
+**Different APIs for agents and routes — don't mix them up:**
 
----
+| Service | In agents (`handler`) | In routes (`router`) |
+| --- | --- | --- |
+| Logger | `ctx.logger` | `c.var.logger` |
+| KV Storage | `ctx.kv` | `c.var.kv` |
+| Vector | `ctx.vector` | `c.var.vector` |
+| Stream | `ctx.stream` | `c.var.stream` |
+| Sandbox | `ctx.sandbox` | `c.var.sandbox` |
+| Thread | `ctx.thread` | `c.var.thread` |
+| Session | `ctx.session` | `c.var.session` |
 
-## @agentuity/drizzle
+- Docs: https://agentuity.dev/agents/creating-agents.md
 
-**ALWAYS use this instead of drizzle-orm directly for Agentuity projects.**
+## KV Storage API
 
-```typescript
-import { createPostgresDrizzle, pgTable, text, serial, eq } from '@agentuity/drizzle';
-
-// Define schema
-const users = pgTable('users', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	email: text('email').notNull().unique(),
-});
-
-// Create database instance (uses DATABASE_URL by default)
-const { db, client, close } = createPostgresDrizzle({
-	schema: { users },
-});
-
-// Or with explicit configuration
-const { db, close } = createPostgresDrizzle({
-	connectionString: 'postgres://user:pass@localhost:5432/mydb',
-	schema: { users },
-	logger: true,
-	reconnect: {
-		maxAttempts: 5,
-		initialDelayMs: 100,
-	},
-	onReconnected: () => console.log('Reconnected!'),
-});
-
-// Execute type-safe queries
-const allUsers = await db.select().from(users);
-const user = await db.select().from(users).where(eq(users.id, 1));
-
-// Clean up
-await close();
-```
-
-### Integration with @agentuity/auth
+**`ctx.kv` requires a namespace and key — NOT just a key.** Returns a `DataResult<T>` discriminated union, not `T | null`:
 
 ```typescript
-import { createPostgresDrizzle, drizzleAdapter } from '@agentuity/drizzle';
-import { createAuth } from '@agentuity/auth';
-import * as schema from './schema';
+// GET — check .exists before accessing .data
+const result = await ctx.kv.get<MyType>('my-namespace', 'my-key');
+const data: MyType[] = result.exists ? result.data : [];
 
-const { db, close } = createPostgresDrizzle({ schema });
+// SET — namespace, key, value, optional params
+await ctx.kv.set('my-namespace', 'my-key', { count: 42 }, { ttl: 3600 });
 
-const auth = createAuth({
-	database: drizzleAdapter(db, { provider: 'pg' }),
-});
+// DELETE
+await ctx.kv.delete('my-namespace', 'my-key');
 ```
 
-### Re-exports
-
-The package re-exports commonly used items:
-
-- From drizzle-orm: `sql`, `eq`, `and`, `or`, `not`, `desc`, `asc`, `gt`, `gte`, `lt`, `lte`, etc.
-- From drizzle-orm/pg-core: `pgTable`, `pgSchema`, `pgEnum`, column types
-- From @agentuity/postgres: `postgres`, `PostgresClient`, etc.
+Namespaces are auto-created on first write with a 7-day default TTL. Override per-key via `{ ttl: seconds }` (min 60s, max 365 days). In routes, use `c.var.kv` instead of `ctx.kv` — same API.
 
----
+- Docs: https://agentuity.dev/services/storage/key-value.md
 
-## @agentuity/postgres
+## Agent Evaluations
 
-**ALWAYS use this instead of pg/postgres for Agentuity projects.**
+Use `@agentuity/evals` for preset evaluations and `agent.createEval()` for custom ones:
 
 ```typescript
-import { postgres } from '@agentuity/postgres';
-
-// Create client (uses DATABASE_URL by default)
-const sql = postgres();
-
-// Or with explicit config
-const sql = postgres({
-	hostname: 'localhost',
-	port: 5432,
-	database: 'mydb',
-	reconnect: {
-		maxAttempts: 5,
-		initialDelayMs: 100,
-	},
+// Preset eval (e.g., adversarial testing)
+import { adversarial } from '@agentuity/evals';
+import agent from './index';
+
+export const adversarialEval = agent.createEval(
+  adversarial({
+    middleware: {
+      transformInput: (input) => ({ request: input.text }),
+      transformOutput: (output) => ({ response: output.result }),
+    },
+  })
+);
+
+// Custom eval
+export const qualityEval = agent.createEval('quality-check', {
+  description: 'Verifies output quality meets threshold',
+  handler: async (ctx, input, output) => {
+    return {
+      passed: output.result.length > 0,
+      reason: output.result.length > 0 ? 'Output is non-empty' : 'Empty output',
+    };
+  },
 });
-
-// Query using tagged template literals
-const users = await sql`SELECT * FROM users WHERE active = ${true}`;
-
-// Transactions
-const tx = await sql.begin();
-try {
-	await tx`INSERT INTO users (name) VALUES (${name})`;
-	await tx.commit();
-} catch (error) {
-	await tx.rollback();
-	throw error;
-}
 ```
 
-### Key Features
-
-- **Lazy connections**: Connection established on first query (set `preconnect: true` for immediate)
-- **Auto-reconnection**: Exponential backoff with jitter
-- **Graceful shutdown**: Detects SIGTERM/SIGINT, prevents reconnection during shutdown
-- **Global registry**: All clients tracked for coordinated shutdown
+Place eval files alongside the agent: `src/agent/<name>/eval.ts`.
 
-### When to use Bun SQL instead
+- Docs: https://agentuity.dev/agents/evaluations.md
 
-Use Bun's native `sql` for simple queries:
+## v2 Migration
 
-```typescript
-import { sql } from 'bun';
-const rows = await sql`SELECT * FROM users`;
-```
+If upgrading from v1, run `npx @agentuity/migrate` to auto-convert `createRouter()` to chained Hono style and generate barrel files. See the [Migration Guide](https://agentuity.dev/reference/migration-guide.md).
 
-Use @agentuity/postgres when you need:
+## Documentation Links
 
-- Resilient connections with auto-retry
-- Connection pooling with stats
-- Coordinated shutdown across multiple clients
-
----
+| Topic | Link |
+| --- | --- |
+| Creating Agents | https://agentuity.dev/agents/creating-agents.md |
+| State Management | https://agentuity.dev/agents/state-management.md |
+| Streaming Responses | https://agentuity.dev/agents/streaming-responses.md |
+| Schema Libraries | https://agentuity.dev/agents/schema-libraries.md |
+| Calling Other Agents | https://agentuity.dev/agents/calling-other-agents.md |
+| Events & Lifecycle | https://agentuity.dev/agents/events-lifecycle.md |
+| Evaluations | https://agentuity.dev/agents/evaluations.md |
+| AI SDK Integration | https://agentuity.dev/agents/ai-sdk-integration.md |
+| AI Gateway | https://agentuity.dev/agents/ai-gateway.md |
+| Drizzle ORM | https://agentuity.dev/services/database/drizzle.md |
+| Postgres Client | https://agentuity.dev/services/database/postgres.md |
+| SDK Reference | https://agentuity.dev/reference/sdk-reference.md |
+| Migration Guide | https://agentuity.dev/reference/migration-guide.md |
 
-## @agentuity/evals
+## Common Mistakes
 
-Agent evaluation framework for testing agent behavior.
+| Mistake                                              | Better Approach                                 | Why                            |
+| ---------------------------------------------------- | ----------------------------------------------- | ------------------------------ |
+| `handler: async (ctx: AgentContext, input: MyInput)` | `handler: async (ctx, input)`                   | Let TS infer types from schema |
+| `const schema = { name: s.string() }`                | `const schema = s.object({ name: s.string() })` | Must use s.object() wrapper    |
+| `console.log('debug')` in production                 | `ctx.logger.debug('debug')`                     | Structured, observable         |
+| Ignoring connection resilience                       | Use @agentuity/drizzle or @agentuity/postgres   | Auto-reconnect on failures     |
+| Asking for OpenAI/Anthropic API keys                 | Use the AI Gateway (works with SDK key)          | LLM requests route through Agentuity automatically |
+| Using `c.var.logger` in agent handlers               | Use `ctx.logger` in agents                       | Agent context and route context have different APIs |
+| Using `ctx.logger` in route handlers                 | Use `c.var.logger` in routes                     | Agent context and route context have different APIs |
+| Exposing agents without routes                       | Create API routes in `src/api/`                  | Agents are not HTTP endpoints  |
+| Skipping agent evaluations                           | Add eval.ts alongside agent index.ts             | Evals catch regressions and validate quality    |
+| Using mutating router style (.get() separately)     | Use chained Hono methods (.get().post())        | Chained style required for hc<AppRouter>() types |
+| Missing agent barrel file                             | Create src/agent/index.ts re-exporting agents    | v2 requires explicit agent registration          |
+| `ctx.kv.get('key')` (missing namespace)               | `ctx.kv.get<T>('namespace', 'key')` — check `.exists` | KV requires namespace + key, returns DataResult not T |
+| Passing Claude model to `new OpenAI()`                | Use `new Anthropic()` for Claude models              | Match the SDK to the model provider — gateway routes automatically |
+| Running `new OpenAI()` outside `agentuity dev`        | Always run via `agentuity dev` or deploy first       | AI Gateway only sets provider base URLs in the Agentuity runtime |
+
+## Example
 
 ```typescript
-import { createPresetEval, type BaseEvalOptions } from '@agentuity/evals';
+import { createAgent } from '@agentuity/runtime';
 import { s } from '@agentuity/schema';
 
-// Define custom options
-type ToneEvalOptions = BaseEvalOptions & {
-	expectedTone: 'formal' | 'casual' | 'friendly';
-};
-
-// Create preset eval
-export const toneEval = createPresetEval<
-	typeof inputSchema, // TInput
-	typeof outputSchema, // TOutput
-	ToneEvalOptions // TOptions
->({
-	name: 'tone-check',
-	description: 'Evaluates if response matches expected tone',
-	options: {
-		model: openai('gpt-4o'), // LanguageModel instance from AI SDK
-		expectedTone: 'friendly',
+export default createAgent('my-agent', {
+	schema: {
+		input: s.object({ message: s.string() }),
+		output: s.object({ reply: s.string() }),
 	},
-	handler: async (ctx, input, output, options) => {
-		// Evaluation logic - use options.model for LLM calls
-		return {
-			passed: true,
-			score: 0.85, // optional (0.0-1.0)
-			reason: 'Response matches friendly tone',
-		};
+	handler: async (ctx, input) => {
+		// ctx provides: logger, kv, vector, stream, sandbox, auth, thread, session, state
+		return { reply: `Got: ${input.message}` };
 	},
 });
-
-// Usage on agent
-agent.createEval(toneEval()); // Use defaults
-agent.createEval(toneEval({ expectedTone: 'formal' })); // Override options
-```
-
-**Key points:**
-
-- Use `s.object({...})` for typed input/output, or `undefined` for generic evals
-- Options are flattened (not nested under `options`)
-- Return `{ passed, score?, reason? }` - throw on error
-- Use middleware to transform agent input/output to eval's expected types
-
----
-
-## @agentuity/core
-
-Foundational types and utilities used by all Agentuity packages.
-
-### StructuredError
-
-```typescript
-import { StructuredError } from '@agentuity/core';
-
-const MyError = StructuredError('MyError', 'Something went wrong')<{
-	code: string;
-	details: string;
-}>();
-
-throw new MyError({ code: 'ERR_001', details: 'More info' });
-```
-
-### Core Types
-
-- **StructuredError**: Create typed errors with structured data
-- **StandardSchemaV1**: Interface for schema validation (implemented by @agentuity/schema and Zod)
-- **Json types**: Type utilities for JSON-serializable data
-- **Service interfaces**: KeyValueStorage, VectorStorage, StreamStorage
-
----
-
-## @agentuity/server
-
-Server utilities that work in both Node.js and Bun.
-
-```typescript
-import { validateDatabaseName, validateBucketName } from '@agentuity/server';
-
-// Validate before provisioning
-const dbResult = validateDatabaseName(userInput);
-if (!dbResult.valid) {
-	throw new Error(dbResult.error);
-}
-
-const bucketResult = validateBucketName(userInput);
-if (!bucketResult.valid) {
-	throw new Error(bucketResult.error);
-}
 ```
 
----
-
-## Common Patterns
+## When In Doubt, Check the Docs
 
-### Project Structure (after `agentuity new`)
+If you're unsure about any API signature, context method, or pattern, **check the documentation first** rather than guessing:
 
-```
-├── agentuity.json       # Project config (projectId, orgId)
-├── agentuity.config.ts  # Build config
-├── package.json
-├── src/
-│   ├── agent/<name>/    # Each agent in its own folder
-│   │   ├── agent.ts     # Agent definition
-│   │   └── index.ts     # Exports
-│   ├── api/             # API routes (Hono)
-│   └── web/             # React frontend
-└── .env                 # AGENTUITY_SDK_KEY, DATABASE_URL, etc.
-```
-
-### Bun-First Runtime
-
-Always prefer Bun built-in APIs:
-
-- `Bun.file(f).exists()` not `fs.existsSync(f)`
-- `import { sql } from 'bun'` for simple queries
-- `import { s3 } from 'bun'` for object storage
-
----
-
-## Common Mistakes
-
-| Mistake                                              | Better Approach                                 | Why                            |
-| ---------------------------------------------------- | ----------------------------------------------- | ------------------------------ |
-| `handler: async (ctx: AgentContext, input: MyInput)` | `handler: async (ctx, input)`                   | Let TS infer types from schema |
-| `const schema = { name: s.string() }`                | `const schema = s.object({ name: s.string() })` | Must use s.object() wrapper    |
-| `console.log('debug')` in production                 | `ctx.logger.debug('debug')`                     | Structured, observable         |
-| Ignoring connection resilience                       | Use @agentuity/drizzle or @agentuity/postgres   | Auto-reconnect on failures     |
+- Full docs: https://agentuity.dev
+- LLM-friendly index: https://agentuity.dev/llms.txt
+- AI Gateway: https://agentuity.dev/agents/ai-gateway.md