anbaric 1.40.0 → 1.42.0

package/docs/api/actors-and-agents.md

@@ -3,7 +3,7 @@
 Who performs work, and how AI models plug in. Import from `anbaric`.
 
 ```ts
-import {Code, Human, SystemActor, Agent, OpenAIAgent, RemoteLLMAgenticAction} from "anbaric";
+import {Code, Human, SystemActor, Agent, OpenAIAgent, AnthropicAgent, GeminiAgent, RemoteLLMAgenticAction} from "anbaric";
 import type {Actor, ActorType} from "anbaric";
 ```
 
@@ -155,6 +155,53 @@ const triager = new OpenAIAgent("triager", "support", {
 The optional `fetchFn` lets you inject a custom fetch (useful in tests). Requests
 that fail throw `The OpenAI request failed with status <n>`.
 
+### `AnthropicAgent`
+
+An `Agent` backed by the Anthropic Messages API. The API has no JSON-schema
+response format, so the output schema is offered as a single tool the model is
+forced to call; its arguments are the structured output. System messages are
+lifted out of the conversation into the API's own `system` field.
+
+```ts
+class AnthropicAgent extends Agent
+constructor(id : string, role : string, connection : AnthropicConnection, fetchFn? : FetchFn)
+
+type AnthropicConnection = {
+    apiKey : string,
+    model : string,
+    baseUrl? : string,        // default "https://api.anthropic.com/v1"
+    version? : string,        // anthropic-version header, default "2023-06-01"
+    maxTokens? : number,      // the Messages API requires a budget, default 4096
+}
+```
+
+Failures throw `The Anthropic request failed with status <n>`; a model that
+answers with prose instead of calling the tool throws `The Anthropic response
+carried no structured content`.
+
+### `GeminiAgent`
+
+An `Agent` backed by the Gemini generative language API, asking for JSON against
+the output schema. System messages become `systemInstruction`, assistant turns
+are sent as the `model` role, and the API key travels as a header rather than a
+query parameter.
+
+```ts
+class GeminiAgent extends Agent
+constructor(id : string, role : string, connection : GeminiConnection, fetchFn? : FetchFn)
+
+type GeminiConnection = {
+    apiKey : string,
+    model : string,
+    baseUrl? : string,        // default "https://generativelanguage.googleapis.com/v1beta"
+}
+```
+
+Gemini's `responseSchema` is an OpenAPI subset rather than JSON Schema, so the
+schema you pass is converted: types are upper-cased and keywords it rejects
+(`additionalProperties` among them) are dropped. Failures throw `The Gemini
+request failed with status <n>`.
+
 ---
 
 ### See also

package/docs/api/stores.md

@@ -88,27 +88,27 @@ const key = await secrets.retrieve("stripe-key", actor);
 
 ## `PromptManager`
 
-Versioned prompts - instructions plus optional input and output schemas - owned
-by the calling app.
+Versioned prompts - instructions plus an optional output schema - owned by the
+calling app.
 
 ```ts
 PromptManagerFactory.instance() : PromptManager
 
 // methods:
-save(promptId : string, instructions : string, inputSchema? : JsonSchema, outputSchema? : JsonSchema) : Promise<Prompt>
+save(promptId : string, instructions : string, outputSchema? : JsonSchema) : Promise<Prompt>
 retrieve(promptId : string, version? : number) : Promise<Prompt>
 list() : Promise<Array<Prompt>>
 history(promptId : string) : Promise<Array<Prompt>>
 
 type Prompt = {
     appId : string, promptId : string, version : number, instructions : string,
-    inputSchema? : JsonSchema, outputSchema? : JsonSchema, createdAt : string,
+    outputSchema? : JsonSchema, createdAt : string,
 }
 ```
 
 ```ts
 const prompts = PromptManagerFactory.instance();
-await prompts.save("triage", "Decide the priority.", undefined, { type: "object", properties: { priority: { type: "string" } } });
+await prompts.save("triage", "Decide the priority.", { type: "object", properties: { priority: { type: "string" } } });
 const latest   = await prompts.retrieve("triage");      // highest version
 const specific = await prompts.retrieve("triage", 1);
 const all      = await prompts.list();                  // latest of each prompt

package/docs/api/typescript.md

@@ -8,7 +8,7 @@ almost everything:
 import {
     StateMachine, State, Terminal, Action, Await, Transition,
     Job, PropertyDefinition,
-    Code, Human, SystemActor, Agent, OpenAIAgent, RemoteLLMAgenticAction,
+    Code, Human, SystemActor, Agent, OpenAIAgent, AnthropicAgent, GeminiAgent, RemoteLLMAgenticAction,
     JsonStoreFactory, SecretStoreFactory, SqlStoreFactory, PromptManagerFactory,
     registerEntitlement, hasEntitlement,
 } from "anbaric";
@@ -26,7 +26,7 @@ An Anbaric app is a standard Node.js **ESM** program in TypeScript: set
   `Action`, `Await`, `WaitForInput`, `Transition`, `Job`, `PropertyDefinition`,
   `Actor`.
 - **[Actors and agents](actors-and-agents.md)** — `Code`, `Human`,
-  `SystemActor`, `Agent`, `RemoteLLMAgenticAction`, `OpenAIAgent`.
+  `SystemActor`, `Agent`, `RemoteLLMAgenticAction`, `OpenAIAgent`, `AnthropicAgent`, `GeminiAgent`.
 - **[Stores](stores.md)** — `JsonStore`, `SecretStore`, `SqlStore`,
   `PromptManager` and their factories, plus `JsonSchema`.
 - **[Entitlements](../features/entitlements.md)** — `registerEntitlement`,

package/docs/features/ai-agents.md

@@ -66,28 +66,47 @@ import {PromptManagerFactory} from "anbaric";
 
 const prompts = PromptManagerFactory.instance();
 await prompts.save("triage", "Decide the priority of the support ticket from its subject.",
-    undefined, { type: "object", properties: { priority: { type: "string", enum: ["low", "high"] } } });
+    { type: "object", properties: { priority: { type: "string", enum: ["low", "high"] } } });
 
 const prompt = await prompts.retrieve("triage");
 const triage = new RemoteLLMAgenticAction("Triage the ticket", triager,
     [{ role: "system", content: prompt.instructions }], prompt.outputSchema!);
 ```
 
-## Bring your own model
+## Choose a provider
 
-`OpenAIAgent` targets any OpenAI-compatible endpoint. Configure it with a
-connection object:
+Three agents ship with the library. They take the same `(id, role, connection)`
+shape, produce the same structured output against your schema, and are
+interchangeable in an agentic action - only the connection differs:
 
 ```ts
+import {AnthropicAgent, GeminiAgent, OpenAIAgent} from "anbaric";
+
 new OpenAIAgent("triager", "support", {
     apiKey: process.env.OPENAI_API_KEY!,
     model: "gpt-5.4-mini",
     baseUrl: "https://api.openai.com/v1",   // optional; override for a compatible provider
     organization: "org_...",                 // optional
 });
+
+new AnthropicAgent("triager", "support", {
+    apiKey: process.env.ANTHROPIC_API_KEY!,
+    model: "claude-opus-5",
+    maxTokens: 4096,                         // optional; the Messages API needs a budget
+});
+
+new GeminiAgent("triager", "support", {
+    apiKey: process.env.GEMINI_API_KEY!,
+    model: "gemini-3-pro",
+});
 ```
 
-For a different provider entirely, implement an `Agent.Client` (a class with a
+Each asks its provider for structured output the way that provider supports it -
+OpenAI's JSON-schema response format, a forced tool call on Anthropic, Gemini's
+JSON response schema - so your action only ever sees properties matching the
+schema you gave it.
+
+For a provider none of them covers, implement an `Agent.Client` (a class with a
 `generate(request)` method) and pass it to a plain `Agent`. See the [API
 reference](../api/actors-and-agents.md#agents-and-ai) for the client contract.
 

package/docs/features/prompts.md

@@ -20,15 +20,14 @@ const prompts = PromptManagerFactory.instance();
 await prompts.save(
     "triage",
     "Decide the priority of the support ticket from its subject and body. Escalate anything mentioning an outage.",
-    { type: "object", required: ["subject", "body"], properties: { subject: { type: "string" }, body: { type: "string" } } },
     { type: "object", required: ["priority"], properties: { priority: { type: "string", enum: ["low", "high"] } } },
 );
 ```
 
-A prompt has an **id**, its **instructions**, and optionally an **input
-schema** (the shape of what the model is given) and an **output schema** (what
-it must produce). Edit the instructions and redeploy: the next save stores
-version 2. There's no rollback and no tagging - an app always gets the latest.
+A prompt has an **id**, its **instructions**, and optionally an **output
+schema** - what the model must produce. Edit the instructions and redeploy: the
+next save stores version 2. There's no rollback and no tagging - an app always
+gets the latest.
 
 ## Use the latest where you call the model
 
@@ -56,7 +55,8 @@ const versions = await prompts.history("triage"); // every version, newest first
 ```
 
 The console's **Prompts** page shows the same for every app on the tenant: each
-prompt, its current instructions and schemas, and the full history to browse.
+prompt, its current instructions and output schema, and the full history to
+browse.
 
 ## Everything is scoped to your app
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anbaric",
-  "version": "1.40.0",
+  "version": "1.42.0",
   "description": "Everything needed to write an Anbaric app: state machines, jobs, document and secret stores, local in-memory implementations and the Anbaric Cloud clients",
   "license": "MIT",
   "type": "module",
@@ -24,9 +24,9 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "anbaric-impl-cloud": "^1.40.0",
-    "anbaric-data-store": "^1.40.0",
-    "anbaric-state-machine": "^1.40.0",
-    "anbaric-tsapi": "^1.40.0"
+    "anbaric-impl-cloud": "^1.42.0",
+    "anbaric-data-store": "^1.42.0",
+    "anbaric-state-machine": "^1.42.0",
+    "anbaric-tsapi": "^1.42.0"
   }
 }