agentfootprint 7.28.0 → 8.1.0

package/AGENTS.md

@@ -56,9 +56,9 @@ await agent.run({ message: 'How long does a refund take?' });
 
 | Boundary | Mock for development | Production swap |
 |---|---|---|
-| LLM provider | `mock({ reply })` · `mock({ replies })` for scripted ReAct | `anthropic()` · `openai()` · `bedrock()` · `ollama()` |
+| LLM provider | `mock({ reply })` · `mock({ replies })` for scripted ReAct | `ollama('<model>')` — a real model, still $0 and no key · then `anthropic()` · `openai()` · `bedrock()` |
 | Embedder | `mockEmbedder()` | OpenAI / Cohere / Bedrock embedder factory |
-| Memory store | `InMemoryStore` | `RedisStore` (`agentfootprint/memory-redis`) · `AgentCoreStore` (`agentfootprint/memory-agentcore`) · DynamoDB / Postgres / Pinecone (planned) |
+| Memory store | `InMemoryStore` | `RedisStore` (`agentfootprint/memory`) · `AgentCoreStore` (`agentfootprint/memory`) · DynamoDB / Postgres / Pinecone (planned) |
 | MCP server | `mockMcpClient({ tools })` — in-memory, no SDK | `mcpClient({ transport })` to a real server |
 | Tool execute | inline `async () => '...'` closure | real implementation |
 
@@ -67,8 +67,8 @@ When generating starter code for users, **default to the mock surface** unless t
 **Subpath imports** for memory adapters keep the main barrel small + tree-shaking clean:
 
 ```typescript
-import { RedisStore } from 'agentfootprint/memory-redis';
-import { AgentCoreStore } from 'agentfootprint/memory-agentcore';
+import { RedisStore } from 'agentfootprint/memory';
+import { AgentCoreStore } from 'agentfootprint/memory';
 ```
 
 Both lazy-require their SDK (`ioredis` / `@aws-sdk/client-bedrock-agent-runtime`) and accept `_client` for test injection.
@@ -152,7 +152,7 @@ agent.rag(docs);
 
 ```typescript
 import { Agent, defineTool } from 'agentfootprint';
-import { anthropic } from 'agentfootprint/llm-providers';
+import { anthropic } from 'agentfootprint/providers';
 
 const agent = Agent.create({
   provider: anthropic({ apiKey: process.env.ANTHROPIC_API_KEY! }),
@@ -177,7 +177,7 @@ Builder methods:
 
 ```typescript
 import { LLMCall } from 'agentfootprint';
-import { anthropic } from 'agentfootprint/llm-providers';
+import { anthropic } from 'agentfootprint/providers';
 
 const call = LLMCall.create({ provider: anthropic(...), model: 'claude-sonnet-4-5-20250929' })
   .system('You are a terse assistant.')
@@ -401,21 +401,26 @@ Browse [`examples/patterns/`](examples/patterns/) — every pattern is a runnabl
 
 ```typescript
 import { mock } from 'agentfootprint';
-// Vendor-SDK providers (lazy peer-deps) live on the dedicated subpath:
-import { anthropic, openai, bedrock, ollama } from 'agentfootprint/llm-providers';
+import { anthropic, openai, bedrock, ollama } from 'agentfootprint/providers';
 
-// Adapter-swap testing: same agent, different provider, $0 in CI
+// The ladder: shape the logic on the mock → check it against a REAL model for
+// free → pay only in production. One argument changes; the agent does not.
 const provider = process.env.NODE_ENV === 'production'
   ? anthropic({ apiKey: process.env.ANTHROPIC_API_KEY! })
-  : mock({ reply: 'test response' });
+  : ollama('llama3.2');   // or mock({ reply: 'test response' }) for determinism
 ```
 
 Every provider implements the same `LLMProvider` interface. `mock`,
 `browserAnthropic`, `browserOpenai`, and `createProvider` ship on the main
-barrel; the vendor-SDK-backed providers (`anthropic` · `openai` · `bedrock`
-· `ollama`) live ONLY at `agentfootprint/llm-providers` (legacy alias:
-`agentfootprint/providers`) so bundlers never walk their lazy peer-dep
-requires. Browser variants exist for client-side use.
+barrel; `anthropic` · `openai` · `bedrock` · `ollama` live ONLY at
+`agentfootprint/providers` so bundlers never walk the vendor-SDK requires.
+Browser variants exist for client-side use.
+
+`ollama('<model>')` is the middle rung and needs NO vendor SDK — it talks
+Ollama's native API over `fetch`. Install Ollama, `ollama pull llama3.2`, done.
+When it can't work it says so in words that contain the fix (`ollama serve`,
+`ollama pull <model>`), never a raw connection error. `OLLAMA_MODEL=<model>`
+makes `providerFromEnv()` pick it, ahead of the cloud credentials.
 
 ### Pause / Resume (Human-in-the-Loop)
 
@@ -444,11 +449,11 @@ if (isPaused(result)) {
 
 ```typescript
 import { withRetry, withFallback, fallbackProvider, withCircuitBreaker } from 'agentfootprint/resilience';
-import { anthropic, openai, ollama } from 'agentfootprint/llm-providers';
+import { anthropic, openai, ollama } from 'agentfootprint/providers';
 
 const reliable = withRetry(provider, { maxAttempts: 3 });
 const resilient = withFallback(primary, fallback);
-const chain = fallbackProvider(anthropic({...}), openai({...}), ollama({...}));
+const chain = fallbackProvider(anthropic({...}), openai({...}), ollama('llama3.2'));
 const guarded = withCircuitBreaker(provider);
 ```
 
@@ -478,7 +483,7 @@ Recorders (auto-attached when relevant builder method is called):
 - `evalRecorder` · `memoryRecorder` · `skillRecorder`
 
 **Observer delivery tier (RFC-001 Block 10):** `Agent.create({ observerDelivery:
-'deferred' })` routes the bridge recorders above + consumer `.recorder()` /
+'deferred' })` routes the bridge recorders above + consumer `.watch()` /
 `agent.attach()` recorders through footprintjs's bounded capture queue —
 capture inline (≈ µs), deliver one beat behind, drain synchronously at run
 resolve / reject / pause. Default `'inline'` = byte-identical attach path, no
@@ -502,7 +507,7 @@ One builder call mounts ONE skill that, when the user asks a why-question, unloc
 
 - ❌ **Don't ship a `ReflexionAgent` class.** Compose `Sequence(Agent, critique-LLM, Agent)`.
 - ❌ **Don't use `agent.run('string')`** — use `agent.run({ message: '...', identity? })`.
-- ❌ **Don't import from non-existent subpaths** like `'agentfootprint/instructions'` — the injection factories live on the main barrel (or `'agentfootprint/injection-engine'`). NOTE: `'agentfootprint/observe'`, `'agentfootprint/security'`, `'agentfootprint/resilience'`, `'agentfootprint/llm-providers'`, `'agentfootprint/memory'`, `'agentfootprint/tool-providers'`, `'agentfootprint/locales'` ARE real subpaths — some surfaces (vendor providers, resilience decorators) live ONLY there, not on the main barrel.
+- ❌ **Don't import from non-existent subpaths** like `'agentfootprint/instructions'` — the injection factories live on the main barrel (or `'agentfootprint/context'`). NOTE: `'agentfootprint/observe'`, `'agentfootprint/security'`, `'agentfootprint/resilience'`, `'agentfootprint/providers'`, `'agentfootprint/memory'`, `'agentfootprint/providers'`, `'agentfootprint/observe'` ARE real subpaths — some surfaces (vendor providers, resilience decorators) live ONLY there, not on the main barrel.
 - ❌ **Don't use `.memoryPipeline(pipeline)`** — that's the v1 API. Use `.memory(defineMemory({...}))`.
 - ❌ **Don't fall back when TopK threshold returns nothing.** Strict semantics: garbage past context > none is wrong.
 - ❌ **Don't store closures or class instances in scope** — TransactionBuffer can't clone functions. Memory-store entries serialize to JSON.

package/README.md

@@ -102,21 +102,25 @@ const result = await agent.run({ message: 'Weather in Paris?' });
 console.log(result);  // → "I checked: it is 72°F and sunny."
 ```
 
-For production, import a real provider from `agentfootprint/llm-providers` and swap it in — `anthropic(...)` / `openai(...)` / `bedrock(...)` / `ollama(...)`. Only the import line changes; the agent code stays the same. (The vendor-SDK providers live on the `agentfootprint/llm-providers` subpath so the main `agentfootprint` barrel stays free of optional peer-dep requires; `mock`, `browserAnthropic`, and `browserOpenai` are on the main barrel.)
+For production, import a real provider from `agentfootprint/providers` and swap it in — `anthropic(...)` / `openai(...)` / `bedrock(...)` / `ollama(...)`. Only the import line changes; the agent code stays the same. (The vendor-SDK providers live on the `agentfootprint/providers` subpath so the main `agentfootprint` barrel stays free of optional peer-dep requires; `mock`, `browserAnthropic`, and `browserOpenai` are on the main barrel.)
 
-### Run against a local model (Ollama, llama.cpp, vLLM — any OpenAI-compatible endpoint)
+### Run against a local model — the free rung between the mock and the bill
 
-No cloud account, no API key, $0 per token. `openai({ baseURL })` targets any server that speaks the OpenAI Chat Completions API — Ollama has its own one-line shortcut:
+No cloud account, no API key, no vendor SDK, $0 per token:
 
 ```typescript
 import { Agent } from 'agentfootprint';
-import { ollama } from 'agentfootprint/llm-providers';
+import { ollama } from 'agentfootprint/providers';
 
-const agent = Agent.create({ provider: ollama({ defaultModel: 'llama3.1' }), model: 'llama3.1' }).build();
-// → talks to http://localhost:11434/v1 (run `ollama pull llama3.1` first)
+const agent = Agent.create({ provider: ollama('llama3.2'), model: 'llama3.2' }).build();
+// → talks to http://localhost:11434 (run `ollama pull llama3.2` first)
 ```
 
-For llama.cpp's `llama-server` or vLLM, swap in `openai({ baseURL: 'http://localhost:8080/v1', apiKey: 'not-needed', defaultModel: '…' })` — same `Agent` code either way. Local servers usually ignore `apiKey`, and most only accept the older `max_tokens` field; both are handled automatically whenever `baseURL` is set. Full recipes: [OpenAI-compatible endpoints](https://footprintjs.github.io/agentfootprint/docs/build/openai/#openai-compatible-endpoints-ollama-llamacpp-vllm-together-groq-lm-studio) · [Ollama guide](https://footprintjs.github.io/agentfootprint/docs/build/ollama/).
+This is the step that makes "the test run and the production run are the same code path" more than a slogan. A mock proves your control flow; it can't tell you whether a real model calls your tool, or what it makes of a tool description you wrote in a hurry. A local model can — and because it's free, you'll actually check before you pay.
+
+`ollama()` talks Ollama's native API directly, so there's nothing to install on this side, streamed calls report real token counts (so `.compaction()` and cost budgets work), and when it can't work it says why in words that contain the fix — `ollama serve` when nothing is listening, `ollama pull <model>` when the model isn't there, never a raw connection error and never a hang.
+
+For llama.cpp's `llama-server`, vLLM, Together or Groq, use `openai({ baseURL: 'http://localhost:8080/v1', apiKey: 'not-needed', defaultModel: '…' })` — any server speaking the OpenAI Chat Completions API, same `Agent` code either way. Full recipes: [Ollama guide](https://footprintjs.github.io/agentfootprint/docs/build/ollama/) · [OpenAI-compatible endpoints](https://footprintjs.github.io/agentfootprint/docs/build/openai/#openai-compatible-endpoints-ollama-llamacpp-vllm-together-groq-lm-studio).
 
 ### Then add context
 
@@ -309,7 +313,7 @@ source, and returns the same honest result `rerunWithoutSources` gives you. `for
 Branch, never rewrite.
 
 ```ts
-import { recordedChat } from 'agentfootprint/debug';
+import { recordedChat } from 'agentfootprint/observe';
 
 const chat = recordedChat({ makeAgent });          // your factory, specs applied at construction
 await chat.send('Should we BUY or HOLD?');         // recorded turn (frozen evidence)
@@ -624,6 +628,30 @@ npm run example examples/features/38-act.ts
 
 See [The moments of the loop](https://footprintjs.github.io/agentfootprint/docs/build/loop-moments/).
 
+### Watch — who is looking while it does
+
+`.act()` says what the agent may do. `.watch()` says who is looking while it does it. Observers handed to the builder are attached before `build()` returns, so there is no window where the agent has run and nobody was watching:
+
+```ts
+const routes  = routeRecorder();
+const choices = toolChoiceRecorder({ embedder: staticEmbedder() });
+
+const agent = Agent.create({ provider, model })
+  .watch(routes, choices)     // build-time — sees the very first run
+  .act({ beforeTool: [refundCeiling] })
+  .build();
+
+await agent.run({ message: 'refund order 4471' });
+
+console.log(await choices.getFlagged());   // calls where the tool choice was a near-tie
+```
+
+Variadic, because observers come in sets. It returns the builder — the runtime door is still `agent.attach(observer)`, which returns an `Unsubscribe` you own and call when the observer's life ends. Same mechanism underneath, so mixing them is fine and order is preserved.
+
+There is deliberately no list of "watch moments" to go with `.act()`'s five. A rule has to be *told* where it may speak, so that list is closed and compiler-pinned; an observer attends the whole stream, and any list we published would be a vocabulary we then had to keep true.
+
+*(`.recorder()` is the same door under its old, internals-flavoured name. It still works and is deprecated — see [8.0.0](./CHANGELOG.md).)*
+
 ---
 
 ## 🐛 Debug — see what your agent did
@@ -743,7 +771,7 @@ map; you decide.
 Answering *"why was the loan rejected?"* from captured evidence is the [debug door above](#-debug--see-what-your-agent-did). The audit door adds the integrity layer: prove the **record itself** hasn't been edited since capture. `auditExport()` hash-chains every typed event — decisions, tool calls, validation rejections, permission verdicts, costs — into an append-only bundle (EU AI Act Art. 12 record-keeping shape); `verifyAuditBundle()` re-checks it **offline** — no agent, no LLM — and names the exact record any tamper broke.
 
 ```ts
-import { auditExport, verifyAuditBundle } from 'agentfootprint/observability-providers';
+import { auditExport, verifyAuditBundle } from 'agentfootprint/observe';
 
 const audit = auditExport({ agent: 'ledger-auditor' });
 const stop = agent.enable.observability({ strategy: audit });
@@ -769,7 +797,7 @@ Build the entire app against in-memory mocks with **zero API cost**, then swap r
 
 | Boundary | Dev | Prod |
 |---|---|---|
-| LLM provider | `mock(...)` | `anthropic()` · `openai()` · `bedrock()` · `ollama()` |
+| LLM provider | `mock(...)` | `ollama('<model>')` free · `anthropic()` · `openai()` · `bedrock()` |
 | Memory store | `InMemoryStore` | `RedisStore` · `AgentCoreStore` |
 | MCP | `mockMcpClient(...)` | `mcpClient({ transport })` |
 | Cache strategy | `NoOpCacheStrategy` | auto-selected per provider |
@@ -799,7 +827,7 @@ The flowchart, recorders, and tests don't change between dev and prod.
 | `anthropic` | Claude (Sonnet, Opus, Haiku) via `@anthropic-ai/sdk` |
 | `openai` | GPT-4o, GPT-4-turbo via `openai` SDK |
 | `bedrock` | Claude / Titan / Mistral via AWS Bedrock runtime |
-| `ollama` | Local models via Ollama · `openai({ baseURL })` also reaches llama.cpp, vLLM, and any other OpenAI-compatible endpoint |
+| `ollama` | Local models, over Ollama's native API — no SDK, no key, real token counts, refusals that name `ollama serve` / `ollama pull` · `openai({ baseURL })` reaches llama.cpp, vLLM, and any other OpenAI-compatible endpoint |
 | `browserAnthropic` | Browser-side Claude calls (no proxy server) |
 | `browserOpenai` | Browser-side OpenAI calls (no proxy server) |
 | `mock` | Deterministic dev/test (zero API cost) |
@@ -855,7 +883,8 @@ Import one thing, ship one thing. agentfootprint is built so your bundle grows o
 
 - **Dual build, true ESM.** Ships CommonJS (`require`) **and** real ECMAScript Modules (`import`) with TypeScript types. The ESM build is `type:module` with explicit `.js` import extensions, so it loads as true ESM under Node, Vite, Next, Deno, and Bun — no shims.
 - **Per-file modules + honest `sideEffects`.** The dist is emitted file-by-file (never pre-bundled), so bundlers drop every export you don't touch. A small `import { defineTool }` doesn't pull in the Agent runtime, injection engine, memory stores, or LLM providers.
-- **Subpath exports + lazy peer-deps.** Heavyweight integrations live behind their own subpaths and load their SDK **only when you instantiate them** — importing agentfootprint never bundles `@anthropic-ai/sdk`, `ioredis`, the AWS SDKs, or the MCP SDK unless you actually use that adapter.
+- **Ten doors, named for what you're doing.** `agentfootprint` · `/providers` (plug in a backend) · `/memory` (state that outlives a turn) · `/observe` (everything that watches) · `/context` (how context gets assembled) · `/resilience` (when the call fails) · `/security` (who may do what) · `/hosting` (behind a wire) · `/events` (the typed wire vocabulary) · `/cache` (prompt caching). 8.0.0 consolidated 26 internals-named subpaths into these; every old path still resolves for all of 8.x.
+- **Lazy peer-deps.** Heavyweight integrations load their SDK **only when you instantiate them** — importing agentfootprint never bundles `@anthropic-ai/sdk`, `ioredis`, the AWS SDKs, or the MCP SDK unless you actually use that adapter.
 
 **Proven, not promised.** A CI smoke test bundles a minimal `import { defineTool }` and asserts the Agent runtime, injection engine, memory stores, and providers are pruned; a second test loads the main barrel and every subpath as true ESM and verifies the lazy-adapter loader works under ESM (`createRequire`, not a bare `require`). See [`test/esm-packaging.test.ts`](test/esm-packaging.test.ts).
 

package/ai-instructions/claude-code/SKILL.md

@@ -74,8 +74,8 @@ Build the entire agent + context engineering + tools + memory + RAG + MCP with i
 
 | Mock | Production swap |
 |---|---|
-| `mock({ reply })` · `mock({ replies })` for scripted multi-turn | `anthropic()` / `openai()` / `bedrock()` / `ollama()` |
-| `InMemoryStore` | `RedisStore` (`agentfootprint/memory-redis`) · `AgentCoreStore` (`agentfootprint/memory-agentcore`) · Dynamo · Postgres · Pinecone (planned) |
+| `mock({ reply })` · `mock({ replies })` for scripted multi-turn | `ollama('<model>')` — a real model, still $0 and no key · then `anthropic()` / `openai()` / `bedrock()` |
+| `InMemoryStore` | `RedisStore` (`agentfootprint/memory`) · `AgentCoreStore` (`agentfootprint/memory`) · Dynamo · Postgres · Pinecone (planned) |
 | `mockEmbedder()` | OpenAI / Cohere / Bedrock embedder factory |
 | `mockMcpClient({ tools })` — in-memory, no SDK | `mcpClient({ transport })` real server |
 | inline `defineTool({ execute: async () => '...' })` | real implementation |
@@ -253,7 +253,7 @@ The 7 **strategies**:
 
 ```typescript
 import { Agent } from 'agentfootprint';
-import { mcpClient } from 'agentfootprint/tool-providers';
+import { mcpClient } from 'agentfootprint/providers';
 
 const slack = await mcpClient({
   name: 'slack',

package/ai-instructions/clinerules

@@ -47,8 +47,8 @@ Build with `mock()` provider + `InMemoryStore` + `mockEmbedder()` + inline tool
 
 | Mock | Production swap |
 |---|---|
-| `mock({ reply })` · `mock({ replies })` for scripted multi-turn | `anthropic()` / `openai()` / `bedrock()` / `ollama()` |
-| `InMemoryStore` | `RedisStore` (`agentfootprint/memory-redis`) · `AgentCoreStore` (`agentfootprint/memory-agentcore`) · Dynamo · Postgres · Pinecone (planned) |
+| `mock({ reply })` · `mock({ replies })` for scripted multi-turn | `ollama('<model>')` — a real model, still $0 and no key · then `anthropic()` / `openai()` / `bedrock()` |
+| `InMemoryStore` | `RedisStore` (`agentfootprint/memory`) · `AgentCoreStore` (`agentfootprint/memory`) · Dynamo · Postgres · Pinecone (planned) |
 | `mockEmbedder()` | OpenAI / Cohere / Bedrock embedder factory |
 | `mockMcpClient({ tools })` — in-memory, no SDK | `mcpClient({ transport })` real server |
 

package/ai-instructions/copilot-instructions.md

@@ -47,8 +47,8 @@ Build with `mock()` provider + `InMemoryStore` + `mockEmbedder()` + inline tool
 
 | Mock | Production swap |
 |---|---|
-| `mock({ reply })` · `mock({ replies })` for scripted multi-turn | `anthropic()` / `openai()` / `bedrock()` / `ollama()` |
-| `InMemoryStore` | `RedisStore` (`agentfootprint/memory-redis`) · `AgentCoreStore` (`agentfootprint/memory-agentcore`) · Dynamo · Postgres · Pinecone (planned) |
+| `mock({ reply })` · `mock({ replies })` for scripted multi-turn | `ollama('<model>')` — a real model, still $0 and no key · then `anthropic()` / `openai()` / `bedrock()` |
+| `InMemoryStore` | `RedisStore` (`agentfootprint/memory`) · `AgentCoreStore` (`agentfootprint/memory`) · Dynamo · Postgres · Pinecone (planned) |
 | `mockEmbedder()` | OpenAI / Cohere / Bedrock embedder factory |
 | `mockMcpClient({ tools })` — in-memory, no SDK | `mcpClient({ transport })` real server |
 

package/ai-instructions/cursor/agentfootprint.md

@@ -47,8 +47,8 @@ Build with `mock()` provider + `InMemoryStore` + `mockEmbedder()` + inline tool
 
 | Mock | Production swap |
 |---|---|
-| `mock({ reply })` · `mock({ replies })` for scripted multi-turn | `anthropic()` / `openai()` / `bedrock()` / `ollama()` |
-| `InMemoryStore` | `RedisStore` (`agentfootprint/memory-redis`) · `AgentCoreStore` (`agentfootprint/memory-agentcore`) · Dynamo · Postgres · Pinecone (planned) |
+| `mock({ reply })` · `mock({ replies })` for scripted multi-turn | `ollama('<model>')` — a real model, still $0 and no key · then `anthropic()` / `openai()` / `bedrock()` |
+| `InMemoryStore` | `RedisStore` (`agentfootprint/memory`) · `AgentCoreStore` (`agentfootprint/memory`) · Dynamo · Postgres · Pinecone (planned) |
 | `mockEmbedder()` | OpenAI / Cohere / Bedrock embedder factory |
 | `mockMcpClient({ tools })` — in-memory, no SDK | `mcpClient({ transport })` real server |
 

package/ai-instructions/kiro/agentfootprint.md

@@ -47,8 +47,8 @@ Build with `mock()` provider + `InMemoryStore` + `mockEmbedder()` + inline tool
 
 | Mock | Production swap |
 |---|---|
-| `mock({ reply })` · `mock({ replies })` for scripted multi-turn | `anthropic()` / `openai()` / `bedrock()` / `ollama()` |
-| `InMemoryStore` | `RedisStore` (`agentfootprint/memory-redis`) · `AgentCoreStore` (`agentfootprint/memory-agentcore`) · Dynamo · Postgres · Pinecone (planned) |
+| `mock({ reply })` · `mock({ replies })` for scripted multi-turn | `ollama('<model>')` — a real model, still $0 and no key · then `anthropic()` / `openai()` / `bedrock()` |
+| `InMemoryStore` | `RedisStore` (`agentfootprint/memory`) · `AgentCoreStore` (`agentfootprint/memory`) · Dynamo · Postgres · Pinecone (planned) |
 | `mockEmbedder()` | OpenAI / Cohere / Bedrock embedder factory |
 | `mockMcpClient({ tools })` — in-memory, no SDK | `mcpClient({ transport })` real server |
 

package/ai-instructions/windsurfrules

@@ -47,8 +47,8 @@ Build with `mock()` provider + `InMemoryStore` + `mockEmbedder()` + inline tool
 
 | Mock | Production swap |
 |---|---|
-| `mock({ reply })` · `mock({ replies })` for scripted multi-turn | `anthropic()` / `openai()` / `bedrock()` / `ollama()` |
-| `InMemoryStore` | `RedisStore` (`agentfootprint/memory-redis`) · `AgentCoreStore` (`agentfootprint/memory-agentcore`) · Dynamo · Postgres · Pinecone (planned) |
+| `mock({ reply })` · `mock({ replies })` for scripted multi-turn | `ollama('<model>')` — a real model, still $0 and no key · then `anthropic()` / `openai()` / `bedrock()` |
+| `InMemoryStore` | `RedisStore` (`agentfootprint/memory`) · `AgentCoreStore` (`agentfootprint/memory`) · Dynamo · Postgres · Pinecone (planned) |
 | `mockEmbedder()` | OpenAI / Cohere / Bedrock embedder factory |
 | `mockMcpClient({ tools })` — in-memory, no SDK | `mcpClient({ transport })` real server |