@zenera/neo 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Andrey Ryabov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,178 @@
+# @zenera/neo
+
+**A multi-agent runtime for Node.js: agents, models, tools, skills, memory and
+an append-only trajectory.**
+
+[![npm](https://img.shields.io/npm/v/@zenera/neo.svg)](https://www.npmjs.com/package/@zenera/neo)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+[![Node](https://img.shields.io/badge/node-%E2%89%A524-brightgreen.svg)](https://nodejs.org)
+
+> Part of [ZeneraNeo](https://github.com/andreyryabov/ZeneraNeo). This is an
+> open-source side project for experimentation and chore work — **not** the
+> official Zenera AI Platform. It carries no support or stability promises.
+
+## Install
+
+Node.js 24+, ESM only. Runtime dependencies are `yaml` and `zod` and nothing
+else; the four vendor SDKs are **optional peer dependencies**, not loaded until
+a client for that vendor is first built, so an OpenAI-only application never
+pays for the others.
+
+```sh
+npm i @zenera/neo openai
+npm i @zenera/neo @anthropic-ai/sdk
+npm i @zenera/neo @google/genai
+npm i @zenera/neo @openrouter/sdk
+```
+
+## Use
+
+There are two ways in, and they meet in the middle: declare the agents in code,
+or load them from a folder.
+
+### In code
+
+An agent is an instruction, a model, some tools, and who it may hand work to.
+That is the whole list — there is no orchestration layer underneath.
+
+```ts
+import { AgentRunner, createModel, tool } from '@zenera/neo';
+
+const getWeather = tool<{ city: string }>({
+    name: 'get_weather',
+    description: 'Current weather for a city.',
+    parameters: {
+        type: 'object',
+        properties: { city: { type: 'string' } },
+        required: ['city'],
+        additionalProperties: false,
+    },
+    execute: ({ city }) => ({ city, tempC: 21, sky: 'clear' }),
+});
+
+const runner = new AgentRunner({ model: createModel('openai:gpt-5.4-mini') });
+
+const planner = runner.agent({
+    name: 'planner',
+    description: 'Turns a request into a concrete day-by-day plan.',
+    instructions: 'Answer with a plan. Check the weather before you commit to a day.',
+    tools: [getWeather],
+});
+
+const result = await runner.run(planner, 'Two days in Rome, outdoors where possible.');
+console.log(result.output);
+```
+
+`run()` returns a handle: `await` it for the answer, or iterate it for the
+stream — token deltas plus a checkpoint for every model call, tool call,
+handoff, fork and join.
+
+```ts
+for await (const ev of runner.run(planner, 'Two days in Rome.')) {
+    if (ev.type === 'text_delta') process.stdout.write(ev.delta);
+}
+```
+
+A second agent and a handoff is one more `runner.agent({ … })` plus
+`handoffs: [planner]` on the first. Skills, memory scopes and payload stores are
+declared once on the runner and referenced by id from each agent allowed to use
+them.
+
+### From a folder
+
+An agentic project is a folder — prompts, agent wiring, skills and tool
+selections are Markdown and YAML files, not code buried inside an application.
+Load one and run it:
+
+```ts
+import { loadProject } from '@zenera/neo';
+
+const project = await loadProject('./my-project', { tools: [lookupPolicy] });
+
+for await (const ev of project.run('Water damage, policy NM-448127.')) {
+    // stream events: thinking, text, tool calls, handoffs, usage
+}
+```
+
+The whole system is an `agents.yaml`:
+
+```yaml
+default: intake
+model: anthropic:claude-sonnet-4-5
+skills: agents/skills
+
+agents:
+    - name: intake
+      description: Takes the first message and routes the case.
+      system: agents/prompts/intake.md
+      tools: [policy_lookup]
+      handoffs: [adjuster]
+
+    - name: adjuster
+      description: Weighs the written policy against the case and explains the outcome.
+      system: agents/prompts/adjuster.md
+      model: openai:gpt-5.4
+      tools: [workspace:*, sandbox:*]
+      skills:
+          discovery: index # the model loads what the case needs
+          preload: [house_style] # always on, from turn one
+```
+
+It is validated strictly at load: an unknown tool, a handoff to nobody, a
+missing prompt file — each fails immediately, naming the offending key, instead
+of surfacing three turns into a run as a confused model.
+
+## What it gives you
+
+- **Agents** — an instruction, a model, tools, skills, plus handoffs and fork.
+  There is no hidden orchestration layer.
+- **Models** — OpenAI, Anthropic, Google/Vertex and OpenRouter behind one
+  interface, each through its own SDK, plus any OpenAI-compatible endpoint.
+  Named providers and model aliases resolve from config or from the host.
+- **Tools** — plain typed functions, selectable per agent by name, group or
+  wildcard. Workspace file tools and a Podman sandbox ship with the library.
+- **Skills** — instruction bundles discovered and loaded on demand instead of
+  permanently occupying the prompt, optionally owning their own tools.
+- **Memory** — pluggable `MemoryStore`s, with scopes deciding what is private to
+  an agent and what is shared.
+- **Trajectory** — an append-only log of everything that happened. Provider
+  messages are a projection of it, and compaction _covers_ nodes rather than
+  deleting them, so the audit trail survives context pressure.
+- **Inspection** — `renderReportHtml` turns any run into one self-contained HTML
+  file: the graph, every request, every token.
+
+## Entry points
+
+| Specifier                     | Contents                                  |
+| ----------------------------- | ----------------------------------------- |
+| `@zenera/neo`                 | agents, models, tools, kernel, inspection |
+| `@zenera/neo/project`         | loading a project folder                  |
+| `@zenera/neo/skill-providers` | skill discovery and loading               |
+| `@zenera/neo/memory-stores`   | `MemoryStore` implementations             |
+| `@zenera/neo/payload-stores`  | payload persistence                       |
+
+## Documentation
+
+[DESIGN.md](https://github.com/andreyryabov/ZeneraNeo/blob/main/DESIGN.md) ·
+[docs/projects.md](https://github.com/andreyryabov/ZeneraNeo/blob/main/docs/projects.md) ·
+[docs/agents-yaml.md](https://github.com/andreyryabov/ZeneraNeo/blob/main/docs/agents-yaml.md)
+· and
+[`examples/`](https://github.com/andreyryabov/ZeneraNeo/tree/main/examples) for
+eight worked demos, from a single agent to a project loaded entirely from a
+folder.
+
+## The rest of the family
+
+| Package                                                                                         | What it is                                                    |
+| ----------------------------------------------------------------------------------------------- | ------------------------------------------------------------- |
+| [`@zenera/cli`](https://github.com/andreyryabov/ZeneraNeo/blob/main/packages/cli/README.md)     | `zen` — this runtime on the command line, with a TUI          |
+| [`@zenera/faker`](https://github.com/andreyryabov/ZeneraNeo/blob/main/packages/faker/README.md) | `zen faker` — a mock API from an openapi/swagger document     |
+| [`@zenera/rag`](https://github.com/andreyryabov/ZeneraNeo/blob/main/packages/rag/README.md)     | `zen rag` — an API description as a searchable graph, + tools |
+
+`@zenera/rag` also exports tools you can hand straight to `loadProject`, so an
+agent can search an API it has never read.
+
+## License
+
+Early days and moving fast — issues, questions and pull requests are welcome.
+[MIT](LICENSE).

package/dist/agent.d.ts

@@ -0,0 +1,66 @@
+import type { MemoryBinding, ResolvedBinding } from './memory.ts';
+import type { Model } from './model.ts';
+import type { Instructions } from './prompt.ts';
+import type { SkillBinding } from './skills.ts';
+import { type AnyTool } from './types.ts';
+export interface ForkOptions {
+    /** agents a branch may run; defaults to any registered agent */
+    agents?: string[];
+    maxBranches?: number;
+}
+export interface AgentOptions<TCtx = unknown> {
+    name: string;
+    description?: string;
+    /**
+     * A string, a function of the run's immutable config, or an ordered list of
+     * both plus files. Composed into one prompt — and the files it names are
+     * recorded on the `system_prompt` node, so the trajectory says which
+     * document to edit.
+     */
+    instructions?: Instructions<TCtx>;
+    model?: Model;
+    tools?: AnyTool<TCtx>[];
+    /** agents this one may hand the conversation over to (by name or instance) */
+    handoffs?: (string | Agent<TCtx>)[];
+    /** long-lived memory spaces this agent may read and/or write */
+    memory?: MemoryBinding<TCtx>[];
+    /** on-demand instruction bundles */
+    skills?: SkillBinding;
+    /** opt-in to parallel sub-agents */
+    fork?: ForkOptions;
+}
+/**
+ * Note what is *not* here any more: `maxTurns`. A run ends on a final answer,
+ * an abort or an unrecoverable error — never because a counter ran out.
+ */
+export declare class Agent<TCtx = unknown> {
+    readonly name: string;
+    readonly description?: string;
+    readonly instructions?: Instructions<TCtx>;
+    readonly model?: Model;
+    readonly tools: AnyTool<TCtx>[];
+    readonly handoffs: string[];
+    readonly memory: MemoryBinding<TCtx>[];
+    readonly skills?: SkillBinding;
+    readonly fork?: ForkOptions;
+    constructor(opts: AgentOptions<TCtx>);
+    /**
+     * Memory bindings with their scope resolved against the run context. The
+     * resolved value is what gets recorded in the trajectory, so a resumed run
+     * cannot drift into another user's space.
+     */
+    memoryBindings(ctx: TCtx): ResolvedBinding[];
+}
+export declare class AgentRegistry<TCtx = unknown> {
+    readonly agents: Map<string, Agent<TCtx>>;
+    /** Registers agents; chainable. */
+    add(...agents: Agent<TCtx>[]): this;
+    /** Creates + registers + returns an agent in one call. */
+    agent(opts: AgentOptions<TCtx>): Agent<TCtx>;
+    find(name: string): Agent<TCtx> | undefined;
+    get(name: string): Agent<TCtx>;
+    names(): string[];
+}
+export declare function handoffTool<TCtx>(target: string, description?: string): AnyTool<TCtx>;
+export declare function handoffTarget(toolName: string): string | undefined;
+//# sourceMappingURL=agent.d.ts.map

package/dist/agent.js

@@ -0,0 +1,97 @@
+import { HANDOFF_PREFIX } from "./types.js";
+/**
+ * Note what is *not* here any more: `maxTurns`. A run ends on a final answer,
+ * an abort or an unrecoverable error — never because a counter ran out.
+ */
+export class Agent {
+    name;
+    description;
+    instructions;
+    model;
+    tools;
+    handoffs;
+    memory;
+    skills;
+    fork;
+    constructor(opts) {
+        this.name = opts.name;
+        this.description = opts.description;
+        this.instructions = opts.instructions;
+        this.model = opts.model;
+        this.tools = opts.tools ?? [];
+        this.handoffs = (opts.handoffs ?? []).map((h) => (typeof h === 'string' ? h : h.name));
+        this.memory = opts.memory ?? [];
+        this.skills = opts.skills;
+        this.fork = opts.fork;
+    }
+    /**
+     * Memory bindings with their scope resolved against the run context. The
+     * resolved value is what gets recorded in the trajectory, so a resumed run
+     * cannot drift into another user's space.
+     */
+    memoryBindings(ctx) {
+        return this.memory.map((b) => ({
+            store: b.store,
+            scope: typeof b.scope === 'function' ? b.scope(ctx) : (b.scope ?? `agent:${this.name}`),
+            access: b.access,
+            autoRecall: b.autoRecall,
+        }));
+    }
+}
+// ---------------------------------------------------------------------------
+// Registry
+// ---------------------------------------------------------------------------
+export class AgentRegistry {
+    agents = new Map();
+    /** Registers agents; chainable. */
+    add(...agents) {
+        for (const a of agents) {
+            if (this.agents.has(a.name)) {
+                throw new Error(`duplicate agent name: ${a.name}`);
+            }
+            this.agents.set(a.name, a);
+        }
+        return this;
+    }
+    /** Creates + registers + returns an agent in one call. */
+    agent(opts) {
+        const a = new Agent(opts);
+        this.add(a);
+        return a;
+    }
+    find(name) {
+        return this.agents.get(name);
+    }
+    get(name) {
+        const a = this.agents.get(name);
+        if (!a) {
+            throw new Error(`unknown agent: ${name} (known: ${[...this.agents.keys()].join(', ')})`);
+        }
+        return a;
+    }
+    names() {
+        return [...this.agents.keys()];
+    }
+}
+// Hand-offs are modelled as ordinary tools named `transfer_to_<agent>`, so the
+// model picks the next agent with the same mechanism it uses for everything
+// else. The kernel recognises them purely by this prefix.
+export function handoffTool(target, description) {
+    return {
+        name: `${HANDOFF_PREFIX}${target}`,
+        description: description ?? `Hand the conversation over to the "${target}" agent.`,
+        parameters: {
+            type: 'object',
+            properties: { reason: { type: 'string', description: 'Why the hand-off is needed.' } },
+            required: [],
+            additionalProperties: false,
+        },
+        // The switch itself happens in the kernel; this body only produces the
+        // tool message that acknowledges the call to the model.
+        execute: () => `transferred to ${target}`,
+    };
+}
+export function handoffTarget(toolName) {
+    return toolName.startsWith(HANDOFF_PREFIX) ? toolName.slice(HANDOFF_PREFIX.length) : undefined;
+}
+//# sourceMappingURL=agent.js.map

package/dist/architecture.d.ts

@@ -0,0 +1,74 @@
+import type { AgentRegistry } from './agent.ts';
+import type { Model } from './model.ts';
+import type { Services } from './services.ts';
+import type { SkillBinding } from './skills.ts';
+export interface ArchTool {
+    name: string;
+    description?: string;
+    /** the skill that unlocks it; absent for tools the agent always carries */
+    skill?: string;
+}
+export interface ArchSkill {
+    name: string;
+    description?: string;
+    version?: string;
+    /** loaded before the first model call, so it is never in the rendered index */
+    preload?: boolean;
+    /** tools this skill unlocks, by name */
+    toolNames?: string[];
+}
+export interface ArchMemory {
+    store: string;
+    /** `(per run)` when the binding resolves its scope from the run context */
+    scope: string;
+    access: 'read' | 'read-write';
+    autoRecall?: boolean;
+}
+export interface ArchAgent {
+    name: string;
+    description?: string;
+    /** model id, from the agent or inherited from the runner */
+    model?: string;
+    /** true when the id above came from the runner rather than the agent */
+    inheritedModel?: boolean;
+    tools: ArchTool[];
+    /** agent names this one may transfer to */
+    handoffs: string[];
+    skills?: {
+        provider: string;
+        discovery: SkillBinding['discovery'];
+        /** empty when the provider is not registered with the services */
+        catalog: ArchSkill[];
+        /** the binding names a provider the services do not know */
+        unresolved?: boolean;
+    };
+    memory: ArchMemory[];
+    fork?: {
+        agents?: string[];
+        maxBranches?: number;
+    };
+}
+export interface Architecture {
+    /**
+     * `declared` comes from the registry and is complete. `observed` is
+     * reconstructed from a trajectory and only contains what a run touched —
+     * the fallback when nobody handed the report a runner.
+     */
+    source: 'declared' | 'observed';
+    agents: ArchAgent[];
+}
+export interface DescribeOptions<TCtx = unknown> {
+    /** needed to enumerate skill catalogs */
+    services?: Services;
+    /** the runner's fallback model, for agents that do not pin one */
+    defaultModel?: Model;
+    /** resolves context-dependent memory scopes; omitted leaves them symbolic */
+    context?: TCtx;
+}
+/**
+ * Projects a registry into a snapshot. Async only because a skill catalog is
+ * an index a provider has to be asked for — everything else is already in
+ * memory.
+ */
+export declare function describeArchitecture<TCtx = unknown>(registry: AgentRegistry<TCtx>, opts?: DescribeOptions<TCtx>): Promise<Architecture>;
+//# sourceMappingURL=architecture.d.ts.map

package/dist/architecture.js

@@ -0,0 +1,105 @@
+import { HANDOFF_PREFIX } from "./types.js";
+/**
+ * Projects a registry into a snapshot. Async only because a skill catalog is
+ * an index a provider has to be asked for — everything else is already in
+ * memory.
+ */
+export async function describeArchitecture(registry, opts = {}) {
+    const agents = [];
+    for (const agent of registry.agents.values()) {
+        agents.push(await describeAgent(agent, opts));
+    }
+    return { source: 'declared', agents };
+}
+async function describeAgent(agent, opts) {
+    const skills = await describeSkills(agent, opts.services);
+    const own = new Set(agent.tools.map((t) => t.name));
+    const tools = agent.tools
+        // A hand-off is already an edge between two agents; listing its
+        // synthetic `transfer_to_*` tool as well would draw it twice.
+        .filter((t) => !t.name.startsWith(HANDOFF_PREFIX))
+        .map((t) => ({ name: t.name, description: t.description }));
+    for (const skill of skills?.catalog ?? []) {
+        for (const name of skill.toolNames ?? []) {
+            if (own.has(name)) {
+                continue;
+            }
+            own.add(name);
+            tools.push({
+                name,
+                description: opts.services?.skillProvider(skills.provider).tool(name)?.description,
+                skill: skill.name,
+            });
+        }
+    }
+    const model = agent.model?.id ?? opts.defaultModel?.id;
+    return {
+        name: agent.name,
+        description: agent.description,
+        model,
+        inheritedModel: model !== undefined && !agent.model ? true : undefined,
+        tools,
+        handoffs: [...agent.handoffs],
+        skills,
+        memory: describeMemory(agent, opts.context),
+        fork: agent.fork
+            ? { agents: agent.fork.agents, maxBranches: agent.fork.maxBranches }
+            : undefined,
+    };
+}
+async function describeSkills(agent, services) {
+    const binding = agent.skills;
+    if (!binding) {
+        return undefined;
+    }
+    const head = { provider: binding.provider, discovery: binding.discovery };
+    if (!services?.hasSkills(binding.provider)) {
+        return { ...head, catalog: [], unresolved: true };
+    }
+    const preload = new Set(binding.preload ?? []);
+    const keep = allowFilter(binding);
+    const summaries = (await services.skillProvider(binding.provider).list()).filter(keep);
+    return {
+        ...head,
+        catalog: summaries.map((s) => ({
+            name: s.name,
+            description: s.description,
+            version: s.version,
+            preload: preload.has(s.name) ? true : undefined,
+            toolNames: s.toolNames,
+        })),
+    };
+}
+function allowFilter(binding) {
+    const allow = binding.allow;
+    if (!allow) {
+        return () => true;
+    }
+    if (typeof allow === 'function') {
+        return allow;
+    }
+    const set = new Set(allow);
+    return (s) => set.has(s.name);
+}
+/**
+ * With a context in hand this is exactly what the run will record. Without
+ * one, a scope function is left symbolic rather than called: it would be
+ * handed `undefined` and either throw or invent a space no run ever uses.
+ */
+function describeMemory(agent, context) {
+    if (context !== undefined) {
+        return agent.memoryBindings(context).map((b) => ({
+            store: b.store,
+            scope: b.scope,
+            access: b.access,
+            autoRecall: b.autoRecall ? true : undefined,
+        }));
+    }
+    return agent.memory.map((b) => ({
+        store: b.store,
+        scope: typeof b.scope === 'function' ? '(per run)' : (b.scope ?? `agent:${agent.name}`),
+        access: b.access,
+        autoRecall: b.autoRecall ? true : undefined,
+    }));
+}
+//# sourceMappingURL=architecture.js.map

package/dist/embedding.d.ts

@@ -0,0 +1,60 @@
+import type { TokenUsage } from './types.ts';
+/**
+ * Which side of a retrieval this text is.
+ *
+ * The only asymmetry worth a place in the contract: the current generation of
+ * embedding models is trained so that a question and the passage answering it
+ * are encoded *differently*, and mixing the two up costs recall silently rather
+ * than loudly. Google spells it `taskType`, OpenRouter `inputType`, and OpenAI
+ * has no such knob at all — which is exactly why it belongs on the request
+ * rather than on any one adapter.
+ */
+export type EmbeddingTaskType = 'query' | 'document';
+export interface EmbeddingRequest {
+    /** the texts to encode, in the order the vectors come back */
+    input: string[];
+    taskType?: EmbeddingTaskType;
+    /** truncate to this width, where the model supports it */
+    dimensions?: number;
+    /**
+     * Scale each vector to unit length. On by default — see `vectors` below.
+     * Turn it off to see what the model actually returned.
+     */
+    normalize?: boolean;
+    signal?: AbortSignal;
+}
+export interface EmbeddingResponse {
+    /**
+     * One vector per input, in the same order, and of unit length unless the
+     * request asked otherwise.
+     *
+     * Normalising here rather than leaving it to the caller is the one place
+     * this contract does more than translate. Whether a model returns unit
+     * vectors is a property of the *model*, not the vendor, and it changes
+     * between generations: `gemini-embedding-2` is unit at every width,
+     * `gemini-embedding-001` comes back at |v| ≈ 0.58 when truncated to 768 of
+     * its 3072, and `text-embedding-005` at ≈ 0.67 for 256 of its 768 — because
+     * truncation is a raw slice and only some models rescale afterwards.
+     *
+     * Cosine similarity divides the magnitude out and so cannot see any of
+     * that; a dot-product index, which is what pgvector and most vector stores
+     * default to, can see nothing else. So a caller that did not normalise
+     * would not get an error, it would get quietly worse results — and it
+     * cannot know which model it was handed.
+     */
+    vectors: number[][];
+    /** the width actually returned, which a truncating request may have chosen */
+    dimensions: number;
+    /** input tokens only; some providers report nothing at all */
+    usage?: TokenUsage;
+}
+export interface Embedder {
+    readonly id: string;
+    embed(req: EmbeddingRequest): Promise<EmbeddingResponse>;
+}
+/**
+ * The one way an adapter finishes, so the unit-length guarantee holds for every
+ * provider without three copies of the same loop.
+ */
+export declare function embeddingResponse(vectors: number[][], req: EmbeddingRequest, usage?: TokenUsage): EmbeddingResponse;
+//# sourceMappingURL=embedding.d.ts.map

package/dist/embedding.js

@@ -0,0 +1,21 @@
+/**
+ * The one way an adapter finishes, so the unit-length guarantee holds for every
+ * provider without three copies of the same loop.
+ */
+export function embeddingResponse(vectors, req, usage) {
+    return {
+        vectors: req.normalize === false ? vectors : vectors.map(unit),
+        dimensions: vectors[0]?.length ?? 0,
+        usage,
+    };
+}
+function unit(vector) {
+    let sum = 0;
+    for (const x of vector) {
+        sum += x * x;
+    }
+    const length = Math.sqrt(sum);
+    // A zero vector has no direction to preserve, and dividing would make it NaN.
+    return length === 0 ? vector : vector.map((x) => x / length);
+}
+//# sourceMappingURL=embedding.js.map

package/dist/embeddings/gemini.d.ts

@@ -0,0 +1,24 @@
+import type { GoogleGenAI } from '@google/genai';
+import { type Embedder, type EmbeddingRequest, type EmbeddingResponse } from '../embedding.ts';
+/** Provider-specific knobs. */
+export interface GeminiEmbedderOptions {
+    /** default width; a request may override it */
+    dimensions?: number;
+    /** a document's title, which the retrieval task type takes into account */
+    title?: string;
+    /**
+     * Texts this model accepts per request. One is the default because that is
+     * what every `gemini-embedding-*` model takes — `embedContent` is a
+     * single-document endpoint there, and the batch path is a separate,
+     * job-based API. The older `text-embedding-*` models accept far more and
+     * can say so.
+     */
+    maxBatch?: number;
+}
+export declare class GeminiEmbedder implements Embedder {
+    #private;
+    readonly id: string;
+    constructor(id: string, client: GoogleGenAI, options?: GeminiEmbedderOptions);
+    embed(req: EmbeddingRequest): Promise<EmbeddingResponse>;
+}
+//# sourceMappingURL=gemini.d.ts.map