@retinue/agentkit 0.1.0

package/dist/adapters/supabase/storage.js

@@ -0,0 +1,207 @@
+/**
+ * `FileContentStore` over Supabase Storage — the production object-storage adapter (#129).
+ *
+ * This is the first store where Supabase is not simply Postgres. Every other port aliases straight to the
+ * Postgres implementation, and `supabase-conformance.test.ts` asserts that by identity. File bytes are the
+ * exception, and not incidentally: #102 declined to make `blobs` a pointer table, and `0013_files` keeps
+ * only metadata, precisely so that bytes live somewhere built for them.
+ *
+ * **Over `fetch`, not an SDK.** Supabase Storage is a plain REST API with a bearer token, so an SDK would
+ * add a dependency, a client lifecycle and an auth model for four HTTP calls. `fetch` is injected rather
+ * than reached for, so the conformance harness runs the real URL construction and status handling against
+ * an in-process double instead of a live bucket.
+ *
+ * **Two properties that are not obvious from the port:**
+ *
+ * - **The tenant is the path prefix, and a content key may not contain a separator.** `sanitizeMediaRefs` in
+ *   ShareFlow is the cautionary tale this is written against — its workspace-prefix check was *"the ONLY
+ *   thing standing between a forged path and a signed URL to another tenant's private object."* Here the
+ *   key is validated to a character class, so `../` cannot be spelled at all.
+ * - **Listing is offset-paged, because the API is.** Unlike the metadata stores, which use keyset cursors
+ *   deliberately, this one cannot: a concurrent upload can shift a page. That is tolerable only because the
+ *   sole caller is reconciliation, which reports rather than deletes and runs again.
+ */
+import { AgentPlatformError } from "../../core/errors.js";
+/**
+ * What a content key may contain.
+ *
+ * No `/`, so a key cannot leave its tenant's prefix; no `.` runs, so `..` cannot be spelled. The service
+ * mints keys as `f_<uuid>`, which satisfies this — the check is here for the caller that does not.
+ */
+const SAFE_KEY = /^[A-Za-z0-9][A-Za-z0-9._-]{0,190}$/;
+const assertSafeKey = (contentKey) => {
+    if (!SAFE_KEY.test(contentKey) || contentKey.includes(".."))
+        throw new AgentPlatformError({
+            code: "invalid_input",
+            message: `content key ${JSON.stringify(contentKey)} is not a valid object name`,
+            retryable: false,
+        });
+};
+/** Tenant ids come from the host, but a traversal here would cross a tenant boundary, so they are checked too. */
+const assertSafeTenant = (tenantId) => {
+    if (!SAFE_KEY.test(tenantId) || tenantId.includes(".."))
+        throw new AgentPlatformError({
+            code: "invalid_input",
+            message: "tenant id is not a valid object path segment",
+            retryable: false,
+        });
+};
+const objectPath = (tenantId, contentKey) => {
+    assertSafeTenant(tenantId);
+    assertSafeKey(contentKey);
+    return `${tenantId}/${contentKey}`;
+};
+/**
+ * A storage failure: the status, the path, and a truncated body.
+ *
+ * `retryable` follows the status rather than a guess: 5xx and 429 are worth another attempt, a 4xx is the
+ * request being wrong and retrying it just repeats the mistake.
+ *
+ * **The service key is redacted from the body.** Found while testing this file: the body is quoted for
+ * diagnostics, and a service — or a proxy's error page in front of it — that echoes the request would put
+ * the service-role key into an error message, which is to say into logs. Redacting at the one place error
+ * messages are built is the only version of this that stays true as callers are added.
+ */
+const makeStorageError = (serviceKey) => (status, what, detail) => new AgentPlatformError({
+    code: status === 404 ? "not_found" : status === 403 || status === 401 ? "forbidden" : "internal",
+    message: `storage ${what} failed with ${status}: ${detail
+        .replaceAll(serviceKey, "[redacted]")
+        .slice(0, 200)}`,
+    retryable: status >= 500 || status === 429,
+});
+const sha256Hex = async (bytes) => {
+    const digest = await crypto.subtle.digest("SHA-256", bytes);
+    return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
+};
+/** Offset cursors, because the list API takes an offset. Opaque so the shape stays this file's business. */
+const encodeOffset = (offset) => Buffer.from(String(offset), "utf8").toString("base64url");
+const decodeOffset = (cursor) => {
+    const parsed = Number.parseInt(Buffer.from(cursor, "base64url").toString("utf8"), 10);
+    return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : 0;
+};
+export const createSupabaseStorageFileContentStore = (config) => {
+    const base = `${config.url.replace(/\/+$/, "")}/storage/v1`;
+    const headers = { Authorization: `Bearer ${config.serviceKey}` };
+    const storageError = makeStorageError(config.serviceKey);
+    return {
+        async putFile({ tenantId, contentKey, mediaType, bytes, maxBytes }) {
+            const path = objectPath(tenantId, contentKey);
+            // Buffered, not streamed, and the bound is the reason it is acceptable: the checksum is over the whole
+            // object, so the bytes have to be seen anyway, and `maxBytes` caps what can be held. The cap is
+            // re-enforced here rather than trusted from `streamWithCap`, because a second caller can skip a check
+            // that lives above the adapter.
+            const chunks = [];
+            let size = 0;
+            for await (const chunk of bytes) {
+                size += chunk.byteLength;
+                if (size > maxBytes)
+                    throw new AgentPlatformError({
+                        code: "invalid_input",
+                        message: `the file exceeds the ${maxBytes} byte limit`,
+                        retryable: false,
+                    });
+                chunks.push(chunk);
+            }
+            const body = new Uint8Array(size);
+            let offset = 0;
+            for (const chunk of chunks) {
+                body.set(chunk, offset);
+                offset += chunk.byteLength;
+            }
+            const response = await config.fetch(`${base}/object/${config.bucket}/${path}`, {
+                method: "POST",
+                headers: {
+                    ...headers,
+                    "Content-Type": mediaType,
+                    // No upsert. A content key is minted per upload, so a collision is not a retry — it is two files
+                    // pointed at one object, and overwriting would replace the first one's bytes.
+                    "x-upsert": "false",
+                },
+                body,
+            });
+            if (!response.ok)
+                throw storageError(response.status, `upload of ${path}`, await response.text());
+            return { contentKey, byteSize: size, checksum: await sha256Hex(body) };
+        },
+        async readFile({ tenantId, contentKey }) {
+            const path = objectPath(tenantId, contentKey);
+            const response = await config.fetch(`${base}/object/${config.bucket}/${path}`, { headers });
+            // Absent is `null`, per the port: the read path turns that into "contents are missing", which is the
+            // orphan seen from the other direction. Any other failure throws, because an unreachable bucket must
+            // not be reported as a missing file — that would send someone hunting a data-loss bug during an outage.
+            if (response.status === 404 || response.status === 400)
+                return null;
+            if (!response.ok)
+                throw storageError(response.status, `read of ${path}`, await response.text());
+            const buffer = new Uint8Array(await response.arrayBuffer());
+            return (async function* () {
+                yield buffer;
+            })();
+        },
+        async signedUrl({ tenantId, contentKey, expiresInSeconds }) {
+            const path = objectPath(tenantId, contentKey);
+            const response = await config.fetch(`${base}/object/sign/${config.bucket}/${path}`, {
+                method: "POST",
+                headers: { ...headers, "Content-Type": "application/json" },
+                // The expiry as given. Clamping lives in `signedReadUrl`, once, so there is one answer to "how long
+                // does a URL live" rather than a floor here and a ceiling there.
+                body: JSON.stringify({ expiresIn: expiresInSeconds }),
+            });
+            if (response.status === 404)
+                return null;
+            if (!response.ok)
+                throw storageError(response.status, `signing of ${path}`, await response.text());
+            const parsed = JSON.parse(await response.text());
+            const signed = parsed.signedURL ?? parsed.signedUrl;
+            if (signed === undefined)
+                throw storageError(502, `signing of ${path}`, "the response carried no signed URL");
+            // Relative in the API's response. Returned absolute, because a caller cannot use half a URL and would
+            // have to reconstruct the base — which is how the wrong project's URL gets built.
+            return signed.startsWith("http") ? signed : `${base}${signed.startsWith("/") ? "" : "/"}${signed}`;
+        },
+        async deleteFile({ tenantId, contentKey }) {
+            const path = objectPath(tenantId, contentKey);
+            const response = await config.fetch(`${base}/object/${config.bucket}/${path}`, {
+                method: "DELETE",
+                headers,
+            });
+            // Idempotent: a retried sweep must not fail on the object it already removed. The state moves only
+            // after this call returns, so a 404 here is the previous attempt having succeeded.
+            if (response.status === 404 || response.ok)
+                return;
+            throw storageError(response.status, `delete of ${path}`, await response.text());
+        },
+        async listObjects({ tenantId, prefix, limit, cursor }) {
+            assertSafeTenant(tenantId);
+            const offset = cursor === undefined ? 0 : decodeOffset(cursor);
+            const response = await config.fetch(`${base}/object/list/${config.bucket}`, {
+                method: "POST",
+                headers: { ...headers, "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    // The tenant prefix is not optional and not appended to the caller's — it is the caller's prefix
+                    // scoped *inside* the tenant's. A caller passing `../other-tenant/` gets a literal prefix that
+                    // matches nothing, because the key check above means no object is named that.
+                    prefix: `${tenantId}/${prefix ?? ""}`,
+                    limit: limit + 1,
+                    offset,
+                    sortBy: { column: "name", order: "asc" },
+                }),
+            });
+            if (!response.ok)
+                throw storageError(response.status, "list", await response.text());
+            const rows = JSON.parse(await response.text());
+            const items = rows
+                .slice(0, limit)
+                .flatMap((row) => 
+            // A row with no name is a folder placeholder in this API. Skipped rather than surfaced as an
+            // object with an empty key, which reconciliation would then report as an orphan nobody can find.
+            row.name === undefined || row.name === ""
+                ? []
+                : [{ contentKey: row.name, byteSize: row.metadata?.size ?? 0 }]);
+            // Keys come back relative to the prefix the API was given, which is already tenant-scoped, so what
+            // the port returns is the bare content key — the same string `putFile` was handed.
+            return rows.length > limit ? { items, nextCursor: encodeOffset(offset + limit) } : { items };
+        },
+    };
+};
+//# sourceMappingURL=storage.js.map

package/dist/agents/agent.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Embedded agent facade — `docs/03` + `docs/06` (embedded profile).
+ *
+ * The batteries-included entry point: `createAgent({ manifest }).run({ conversationId, message })`.
+ * It wires the reference in-memory stores, the model registry + provider factory, the tool registry
+ * and the default engine into the durable worker, then runs a turn to completion and returns its
+ * parts. State persists across turns on the same conversation. Swap the in-memory adapters for
+ * Postgres/Supabase and drive the worker from a real queue to get the server profile — same engine,
+ * same contracts.
+ */
+import type { ExecutionContext } from "../core/context.js";
+import type { MessagePart } from "../core/content-parts.js";
+import type { ModelDefinition, ModelRoleAssignments } from "../models/index.js";
+import { type ProviderCredentials } from "../models/provider-factory.js";
+import type { ModelProvider } from "../models/index.js";
+import type { AuthorizationPolicy } from "../authorization/index.js";
+import { type ContextProvider } from "../context/index.js";
+import { type ToolProvider } from "../tools/index.js";
+import { type AgentEngine, type ProcessOutcome } from "../runtime/index.js";
+import { type ResolvedModelInfo } from "./engine.js";
+import type { AgentManifest } from "./index.js";
+import { type AgentManifestInput } from "./define.js";
+export type CreateAgentConfig = {
+    readonly manifest: AgentManifestInput;
+    /** Model catalog; defaults to a small Anthropic catalog (smart/fast). */
+    readonly models?: readonly ModelDefinition[];
+    readonly roleAssignments?: ModelRoleAssignments;
+    readonly providerCredentials?: Partial<Record<ModelProvider, ProviderCredentials>>;
+    readonly tools?: readonly ToolProvider[];
+    /** Context providers (e.g. principal memory, retrieval) whose sections are prepended to the prompt. */
+    readonly contextProviders?: readonly ContextProvider[];
+    /**
+     * Random hex for the untrusted-content delimiter nonce (#145).
+     *
+     * Injected so a test can pin the exact bytes of a rendered prompt; defaults to `node:crypto`. A module that
+     * reaches for randomness directly is one whose output cannot be asserted, and the assertion here is precisely
+     * that a forged delimiter does not survive.
+     */
+    readonly randomHex?: (bytes: number) => string;
+    readonly authorization?: AuthorizationPolicy;
+    readonly tenantId?: string;
+    /** Test/advanced seam: override how a manifest resolves to a model (e.g. a mock model). */
+    readonly resolveModel?: (manifest: AgentManifest, context: ExecutionContext) => ResolvedModelInfo;
+    /** Test/advanced seam: supply the engine directly instead of building the default one. */
+    readonly engine?: AgentEngine;
+    readonly now?: () => number;
+};
+export type RunInput = {
+    readonly conversationId: string;
+    readonly message: string;
+    readonly principalId?: string;
+    readonly roleIds?: readonly string[];
+};
+export type RunResult = {
+    readonly runId: string;
+    readonly outcome: ProcessOutcome;
+    readonly parts: readonly MessagePart[];
+    /** Convenience: the assistant's concatenated text. */
+    readonly text: string;
+};
+export declare const createAgent: (config: CreateAgentConfig) => {
+    manifest: AgentManifest;
+    /** Run one turn to completion and return the assistant's parts. State persists on the conversation. */
+    run(input: RunInput): Promise<RunResult>;
+};
+//# sourceMappingURL=agent.d.ts.map

package/dist/agents/agent.js

@@ -0,0 +1,209 @@
+/**
+ * Embedded agent facade — `docs/03` + `docs/06` (embedded profile).
+ *
+ * The batteries-included entry point: `createAgent({ manifest }).run({ conversationId, message })`.
+ * It wires the reference in-memory stores, the model registry + provider factory, the tool registry
+ * and the default engine into the durable worker, then runs a turn to completion and returns its
+ * parts. State persists across turns on the same conversation. Swap the in-memory adapters for
+ * Postgres/Supabase and drive the worker from a real queue to get the server profile — same engine,
+ * same contracts.
+ */
+import { AgentPlatformError } from "../core/errors.js";
+import { asId } from "../core/ids.js";
+import { createModelRegistry, computeModelCostMinorUnits } from "../models/index.js";
+// From the module rather than the barrel: `models/index.ts` no longer re-exports the factory, because doing so
+// made every root import load six provider SDKs (#196).
+import { createProviderFactory, } from "../models/provider-factory.js";
+import { gatherSections } from "../context/index.js";
+import { randomBytes } from "node:crypto";
+import { makeNonce, renderContextBlock } from "../security/prompt-safety.js";
+import { createToolRegistry } from "../tools/index.js";
+import { createDurableWorker } from "../runtime/index.js";
+import { createMemoryCheckpointStore, createMemoryRunEventLog, createMemoryRunStore, } from "../adapters/memory/runtime.js";
+import { createMemoryConversationStore } from "../adapters/memory/index.js";
+import { createMemoryEventBus } from "../runtime/index.js";
+import { createMemoryMessageStore } from "../adapters/memory/message-store.js";
+import { createDefaultEngine } from "./engine.js";
+import { DEFAULT_MODEL_CATALOG, DEFAULT_ROLE_ASSIGNMENTS, defineAgent, } from "./define.js";
+/** Permissive policy used by the embedded facade when a caller wires tools but no authorization. */
+const allowAllAuthorization = () => ({
+    async can() {
+        return { allow: true };
+    },
+    async filterTools(_ctx, tools) {
+        return tools;
+    },
+    async scope(context) {
+        return { tenantId: context.tenantId, roleIds: context.roleIds };
+    },
+});
+const textOf = (parts) => parts.filter((p) => p.type === "text").map((p) => p.text).join("");
+/** The default nonce source. Real randomness, so a delimiter cannot be predicted across runs. */
+const defaultRandomHex = (bytes) => randomBytes(bytes).toString("hex");
+export const createAgent = (config) => {
+    const manifest = defineAgent(config.manifest);
+    const tenantId = asId(config.tenantId ?? "default");
+    const now = config.now ?? Date.now;
+    const conversations = createMemoryConversationStore();
+    const runs = createMemoryRunStore();
+    const checkpoints = createMemoryCheckpointStore();
+    const eventLog = createMemoryRunEventLog();
+    const bus = createMemoryEventBus();
+    const messages = createMemoryMessageStore();
+    const registry = createModelRegistry({
+        models: config.models ?? DEFAULT_MODEL_CATALOG,
+        roles: config.roleAssignments ?? DEFAULT_ROLE_ASSIGNMENTS,
+    });
+    const providerFactory = createProviderFactory({ credentials: config.providerCredentials ?? {} });
+    const authorization = config.authorization ?? allowAllAuthorization();
+    const toolRegistry = createToolRegistry({ providers: config.tools ?? [], authorization });
+    const resolveModel = config.resolveModel ??
+        ((m) => {
+            const def = registry.resolve(m.modelPolicy);
+            return {
+                model: providerFactory.languageModel(def),
+                modelId: def.modelId,
+                currency: def.pricing.currency,
+                price: (u) => computeModelCostMinorUnits(def.pricing, { inputTokens: u.inputTokens, outputTokens: u.outputTokens, cachedInputTokens: u.cachedInputTokens }),
+            };
+        });
+    const contextProviders = config.contextProviders ?? [];
+    const engine = config.engine ?? createDefaultEngine({
+        async loadManifest() {
+            return manifest; // single-manifest embedded agent
+        },
+        resolveModel,
+        ...(contextProviders.length > 0
+            ? {
+                /**
+                 * The system prompt, with external content quarantined (#145, AC-4).
+                 *
+                 * The previous version was `sections.map(s => "## " + s.title + "\n" + s.body)`. That is the one place
+                 * a model most readily treats text as instruction, and a section body can be a fetched page, an MCP
+                 * result or an extracted document. `contextProviders` is the *intended extension point* for exactly
+                 * that content, and nothing in the type system warned the next person who wired one.
+                 *
+                 * `renderContextBlock` groups untrusted sections after the trusted ones under a standing preamble and
+                 * encloses each in a nonce-delimited block with delimiter forgery neutralised. A fresh nonce per
+                 * assembly, so content cannot learn the delimiter from a previous turn.
+                 */
+                systemPrompt: async (m, context) => {
+                    const sections = await gatherSections(context, contextProviders);
+                    if (sections.length === 0)
+                        return m.instructions;
+                    const ctxText = renderContextBlock(sections, makeNonce(config.randomHex ?? defaultRandomHex));
+                    return `${m.instructions}\n\n# Context\n${ctxText}`;
+                },
+            }
+            : {}),
+        async loadHistory(context) {
+            /**
+             * The non-null assertion is gone — #198. It was the only thing standing between a conversation-less run
+             * and a query keyed on `undefined`, which Postgres would have accepted as a literal and returned nothing
+             * for. A refusal that names the capability is the whole point of making the field optional.
+             */
+            if (context.conversationId === undefined)
+                throw new AgentPlatformError({
+                    code: "invalid_input",
+                    message: "history needs a conversation, and this context has none. The embedded runtime is conversation-based; " +
+                        "for a run without one, use the composed runtime with history turned off.",
+                    retryable: false,
+                });
+            const page = await messages.listByConversation({ tenantId: context.tenantId, conversationId: context.conversationId, limit: 1_000 });
+            return page.items.map((m) => ({
+                role: m.role === "assistant" ? "assistant" : "user",
+                // Text only here, deliberately: the embedded facade has no file store to resolve an attachment
+                // through, and inventing one would be the modality bridge going around file authorization — the
+                // failure #185 exists to avoid, reintroduced by the convenience path.
+                content: textOf(m.parts),
+            }));
+        },
+        ...(config.tools && config.tools.length > 0
+            ? {
+                buildTools: async (context) => {
+                    const resolvedTools = [];
+                    const gathered = (await Promise.all((config.tools ?? []).map((p) => p.listTools(context)))).flat();
+                    const permitted = new Set((await authorization.filterTools(context, gathered.map((t) => t.descriptor))).map((d) => d.name));
+                    for (const t of gathered) {
+                        if (!permitted.has(t.descriptor.name))
+                            continue;
+                        resolvedTools.push({
+                            name: t.descriptor.name,
+                            description: t.descriptor.description,
+                            inputSchema: t.descriptor.inputSchema,
+                            execute: async (input) => {
+                                const result = await toolRegistry.execute(context, { name: t.descriptor.name, input });
+                                if (!result.ok)
+                                    throw new AgentPlatformError(result.error);
+                                return result.data;
+                            },
+                        });
+                    }
+                    return resolvedTools;
+                },
+            }
+            : {}),
+    });
+    // Per-run execution context, so the worker's buildContext returns the right principal/conversation.
+    const contextByRun = new Map();
+    const worker = createDurableWorker({
+        runs,
+        checkpoints,
+        publisher: bus.publisher,
+        eventLog,
+        engine,
+        workerId: "embedded",
+        now,
+        buildContext: (run) => contextByRun.get(run.id),
+    });
+    let seq = 0;
+    return {
+        manifest,
+        /** Run one turn to completion and return the assistant's parts. State persists on the conversation. */
+        async run(input) {
+            const conversationId = asId(input.conversationId);
+            const principalId = asId(input.principalId ?? "user");
+            const runId = asId(`run-${(seq += 1)}`);
+            const context = {
+                tenantId,
+                principalId,
+                roleIds: (input.roleIds ?? []).map((r) => asId(r)),
+                locale: "en",
+                timezone: "UTC",
+                requestId: asId(`req-${seq}`),
+                conversationId,
+                runId,
+            };
+            contextByRun.set(runId, context);
+            if (!(await conversations.findById({ tenantId, id: conversationId }))) {
+                await conversations.create({ tenantId, id: conversationId, title: input.message.slice(0, 80) || "Conversation" });
+            }
+            await messages.append({ tenantId, message: userMessage(conversationId, `${runId}:user`, input.message) });
+            await runs.create({ tenantId, id: runId, conversationId, agentId: asId(manifest.id), agentVersion: manifest.version });
+            const result = await worker.process({ tenantId, runId });
+            const checkpoint = await checkpoints.latest({ tenantId, runId });
+            const parts = checkpoint?.parts ?? [];
+            // Persist the assistant turn so the next run's history includes it.
+            if (parts.length > 0) {
+                await messages.append({ tenantId, message: assistantMessage(conversationId, `${runId}:assistant`, parts) });
+            }
+            contextByRun.delete(runId);
+            return { runId, outcome: result.outcome, parts, text: textOf(parts) };
+        },
+    };
+};
+const userMessage = (conversationId, id, text) => ({
+    id: asId(id),
+    conversationId,
+    role: "user",
+    parts: [{ id: asId(`${id}:0`), type: "text", schemaVersion: 1, createdAt: new Date(0).toISOString(), text }],
+    createdAt: new Date(0).toISOString(),
+});
+const assistantMessage = (conversationId, id, parts) => ({
+    id: asId(id),
+    conversationId,
+    role: "assistant",
+    parts,
+    createdAt: new Date(0).toISOString(),
+});
+//# sourceMappingURL=agent.js.map

package/dist/agents/define.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Declaring an agent — the half of `agent.ts` that needs no provider (#196).
+ *
+ * `defineAgent`, the execution defaults and the starter catalog are **declarations**: data describing what an
+ * agent is. They stay reachable from the package root because nothing about writing one requires a model SDK.
+ *
+ * `createAgent` — the embedded facade that builds a provider factory from credentials — stayed in `agent.ts` and
+ * moved behind the `providers` entry. That convenience is the one thing here that costs six optional peers, and
+ * the cost belongs in the import path rather than being paid by everyone who imports the root.
+ */
+import type { ModelDefinition, ModelRoleAssignments } from "../models/index.js";
+import type { AgentManifest } from "./index.js";
+/** The subset a caller must supply; everything else gets a sensible default. */
+export type AgentManifestInput = Pick<AgentManifest, "id" | "name" | "instructions" | "modelPolicy"> & Partial<AgentManifest>;
+export declare const DEFAULT_EXECUTION_LIMITS: AgentManifest["limits"];
+/** Fill a partial manifest with defaults so the common case is a few fields. */
+export declare const defineAgent: (input: AgentManifestInput) => AgentManifest;
+/** A small default catalog so `modelPolicy: { role: "smart" }` resolves out of the box. */
+export declare const DEFAULT_MODEL_CATALOG: readonly ModelDefinition[];
+export declare const DEFAULT_ROLE_ASSIGNMENTS: ModelRoleAssignments;
+//# sourceMappingURL=define.d.ts.map

package/dist/agents/define.js

@@ -0,0 +1,63 @@
+/**
+ * Declaring an agent — the half of `agent.ts` that needs no provider (#196).
+ *
+ * `defineAgent`, the execution defaults and the starter catalog are **declarations**: data describing what an
+ * agent is. They stay reachable from the package root because nothing about writing one requires a model SDK.
+ *
+ * `createAgent` — the embedded facade that builds a provider factory from credentials — stayed in `agent.ts` and
+ * moved behind the `providers` entry. That convenience is the one thing here that costs six optional peers, and
+ * the cost belongs in the import path rather than being paid by everyone who imports the root.
+ */
+export const DEFAULT_EXECUTION_LIMITS = {
+    maxSteps: 8,
+    maxToolCalls: 16,
+    wallClockTimeoutMs: 120_000,
+    maxInputTokens: 100_000,
+    maxOutputTokens: 4_096,
+    costCeilingMinorUnits: 100_000,
+    maxRetries: 5,
+    retryBackoffMs: 500,
+    maxInlineToolOutputBytes: 8_192,
+};
+/** Fill a partial manifest with defaults so the common case is a few fields. */
+export const defineAgent = (input) => ({
+    version: 1,
+    description: "",
+    responseFormat: { kind: "text" },
+    toolPolicy: { preloaded: [], categories: [], excluded: [] },
+    skillPolicy: { assigned: [], allowTenantSkills: false },
+    authorizationPolicyId: "default",
+    contextProviderIds: [],
+    limits: DEFAULT_EXECUTION_LIMITS,
+    ...input,
+});
+/** A small default catalog so `modelPolicy: { role: "smart" }` resolves out of the box. */
+export const DEFAULT_MODEL_CATALOG = [
+    {
+        provider: "anthropic",
+        modelId: "claude-sonnet-5",
+        label: "Claude Sonnet 5",
+        lifecycle: "generally-available",
+        inputModalities: ["text", "image"],
+        capabilities: { tools: true, structuredOutput: true, reasoning: true, nativeSearch: false },
+        limits: { contextTokens: 200_000, maxOutputTokens: 8_192 },
+        pricing: { currency: "USD", inputPerMillion: 3_000, outputPerMillion: 15_000 },
+        dataResidency: ["us"],
+    },
+    {
+        provider: "anthropic",
+        modelId: "claude-haiku-4-5-20251001",
+        label: "Claude Haiku 4.5",
+        lifecycle: "generally-available",
+        inputModalities: ["text", "image"],
+        capabilities: { tools: true, structuredOutput: true, reasoning: false, nativeSearch: false },
+        limits: { contextTokens: 200_000, maxOutputTokens: 8_192 },
+        pricing: { currency: "USD", inputPerMillion: 800, outputPerMillion: 4_000 },
+        dataResidency: ["us"],
+    },
+];
+export const DEFAULT_ROLE_ASSIGNMENTS = {
+    smart: ["claude-sonnet-5"],
+    fast: ["claude-haiku-4-5-20251001"],
+};
+//# sourceMappingURL=define.js.map