Postgres and SQLite

The storage adapters, migrations, limit stores, secret stores and agent stores in @intentface/latch-drizzle.

@intentface/latch-drizzle keeps everything in your own Postgres or SQLite database (including libSQL and Turso), through a Drizzle instance you create and own.

Storage adapters

import { createPostgresAdapter, migratePostgres } from "@intentface/latch-drizzle";

await migratePostgres(db); // once per deploy: creates and updates the latch_* tables
const storage = createPostgresAdapter<Principal>(db, { owner: (p) => [p.orgId, p.userId] });

createSqliteAdapter and migrate do the same for SQLite. Both adapters take:

Option	Type	Default	Details
`owner`	`(principal: P) => string[]`	—
Whose conversation is whose. Every chat is stamped with this key when it's created, and every read checks it: `[p.orgId, p.userId]` gives each person their own chats, `[p.orgId]` shares them with the whole team. Build it only from the principal your login produced, never from what the client sends. `(principal: P) => string[]`

Postgres needs a driver that supports transactions (pg, postgres, Neon's neon-serverless), not neon-http.

Everything else in the package

Export	What it is
`createPostgresLimitStore(db)`, `createSqliteLimitStore(db)`	Counters for limits.
`createPostgresSecretStore(db, { owner })`, `createSqliteSecretStore(db, { owner })`	Where the vault keeps encrypted secrets. Its `owner` can differ from storage's: shared per team while chats are per person.
`createPostgresAgentBuilderStore(db, options)`, `createSqliteAgentBuilderStore(db, options)`	Agents in a database, with versions. Options below.
`createPostgresMemoryJobStore`, `createMemoryJobStore`	For memory, which is experimental.
`schema`, `pgSchema`	The Drizzle table definitions, for your own queries.

Agent store options

Option	Type	Default
`owner`	`(principal: P, scope: AgentScope) => string[]`	—
Who owns an agent at each scope: `"org"` agents are shared by the organization, `"user"` agents belong to one person. For example `(p, scope) => scope === "org" ? [p.orgId] : [p.orgId, p.userId]`. `(principal: P, scope: AgentScope) => string[]`
`modelFor`	`(id: string) => LanguageModel`	—
Turns a model id saved with an agent into a model, for example `(id) => gateway(id)`. `(id: string) => LanguageModel`
`loadAuthoredTools?`	`function`	—
Loads tools your users wrote themselves, by name, if your app lets them. When omitted, an agent's `authoredTools` are simply not attached. `((principal: P, names: string[], agentScope: AgentScope) => Promise<Record<string, unknown>>) \| undefined`
`decorateResolve?`	`function`	—
Adjusts each agent after it's built from its saved record: add tools every agent gets, change which tools need approval. Return the config to use. `((cfg: AgentConfig<P>, record: AgentRecord, principal: P) => AgentConfig<P>) \| undefined`
`editorKey?`	`((principal: P) => string)`	the `"user"` scope's owner key
Who is editing: one person, for their own drafts and for crediting a publish. Separate from `owner`, which a whole organization shares, so two admins never overwrite each other's draft. `((principal: P) => string) \| undefined`

The store's methods: Agent store.