@retinue/agentkit 0.1.0

package/dist/documents/vision.d.ts

@@ -0,0 +1,159 @@
+/**
+ * OCR and vision, feeding the same derived-artifact path (#132).
+ *
+ * The point of this file is that a screenshot, a scanned PDF and a Markdown file all end up as the same
+ * `ExtractedDocument`. Downstream — `read_document`, the context section, the blob — sees one representation
+ * regardless of where the text came from, which is what stops "can the model read this?" depending on the
+ * format the user happened to attach.
+ *
+ * Two ports, because the two jobs are genuinely different and conflating them would force one adapter to do
+ * both badly:
+ *
+ * - **`OcrProvider`** transcribes. Given a scan it returns the words that are on the page, with a confidence.
+ *   It does not interpret.
+ * - **`VisionProvider`** describes. Given a screenshot or a chart it says what is shown, which is the only
+ *   useful answer for an image with no text in it.
+ *
+ * **There is no built-in OCR adapter, and there cannot honestly be one.** OCR needs a trained engine —
+ * Tesseract, or a hosted service. The PDF parser in #131 could be written over the raw syntax with `zlib`
+ * because a PDF *contains* its text; a scan does not contain text at all. So `OcrProvider` is a port with a
+ * documented contract and no implementation in this package, and a deployment that needs OCR supplies one.
+ * The alternative — a stub that returns empty text — would make every scan look like a successful extraction
+ * of nothing, which is precisely the failure `no-text-layer` exists to prevent.
+ *
+ * The vision side *is* implemented, over the model registry, because a vision-capable model is already a
+ * dependency this platform has.
+ */
+import type { ExecutionContext } from "../core/context.js";
+import type { RunId } from "../core/ids.js";
+import type { ModelRegistry } from "../models/index.js";
+import type { ProviderFactory } from "../models/provider-factory.js";
+import { DEFAULT_VISION_PROMPT } from "../models/vision.js";
+import type { UsageRecorder } from "../usage/index.js";
+import type { DocumentBlock, DocumentParser, ExtractionFailure, ExtractionLimits } from "./index.js";
+/**
+ * Below this, extraction is flagged rather than presented as certain — AC-5.
+ *
+ * Re-exported from `persistence`, not defined here. Two layers interpret the field and neither may import the
+ * other, so the port that declares `confidence` owns the number that gives it meaning.
+ */
+export declare const LOW_CONFIDENCE_WARNING = "The text was recognised with low confidence and may contain errors. Treat figures and names as uncertain.";
+/** The image types this platform will send to a vision model or an OCR engine. */
+export declare const IMAGE_MEDIA_TYPES: readonly ["image/png", "image/jpeg", "image/webp", "image/gif"];
+export type OcrResult = {
+    readonly blocks: readonly DocumentBlock[];
+    /**
+     * 0–1, the engine's own confidence.
+     *
+     * Required, not optional. An engine that cannot report one should say `0` and let the low-confidence flag
+     * fire, because "no confidence reported" and "high confidence" must never be the same value — the default
+     * would be the optimistic one and nobody would notice.
+     */
+    readonly confidence: number;
+    readonly pageCount?: number;
+    readonly warnings?: readonly string[];
+};
+/**
+ * Transcribes an image or a scanned document.
+ *
+ * Takes the **original bytes and media type**, not page images: rasterising a PDF needs a renderer, and every
+ * real OCR service (Textract, Document AI, Azure Document Intelligence) accepts a PDF directly and does that
+ * itself. Making rasterisation the provider's business is both simpler and what the APIs already assume.
+ */
+export interface OcrProvider {
+    readonly id: string;
+    readonly mediaTypes: readonly string[];
+    recognise(input: {
+        readonly bytes: Uint8Array;
+        readonly mediaType: string;
+        readonly limits: ExtractionLimits;
+    }): Promise<OcrResult | ExtractionFailure>;
+}
+export type VisionResult = {
+    readonly description: string;
+    readonly modelId: string;
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly cachedInputTokens: number;
+};
+/** Describes an image. Separate from OCR: transcribing and interpreting are different jobs. */
+export interface VisionProvider {
+    readonly id: string;
+    readonly mediaTypes: readonly string[];
+    describe(input: {
+        readonly bytes: Uint8Array;
+        readonly mediaType: string;
+        readonly prompt?: string;
+    }): Promise<VisionResult>;
+}
+/**
+ * A `VisionProvider` over the model registry.
+ *
+ * `requiredModalities: ["image"]` is AC-3, and it is enforced by `resolve` throwing rather than by a check
+ * here — see `models/vision.ts`. The refusal surfaces as `capability_unavailable`, which the pipeline records
+ * as a typed failure, so a deployment with no vision model gets "this platform cannot describe images"
+ * instead of a description of an image nobody looked at.
+ */
+export declare const createModelVisionProvider: (deps: {
+    readonly registry: ModelRegistry;
+    readonly providers: ProviderFactory;
+    /** `smart` by default: a description is read by a person and a cheap model's is not worth the tokens. */
+    readonly role?: "fast" | "smart";
+    readonly maxOutputTokens?: number;
+}) => VisionProvider;
+/**
+ * A synthetic run id for a background extraction.
+ *
+ * `UsageEvent.runId` is required, and an extraction is **not a run** — it has no conversation turn and no
+ * agent. Rather than widen the usage ledger with a second identity dimension, the extraction borrows the
+ * field with a namespaced value. Two consequences worth knowing:
+ *
+ * - The ledger stays single, which is what AC-4 asks for: one place to answer "what did this tenant spend".
+ * - `usageDedupeKey` is `(runId, stepId)`, so a retried extraction of the same file records **once**. That is
+ *   not incidental — vision calls are the expensive kind, and a re-enqueued job double-charging a tenant is
+ *   the failure this shape prevents.
+ *
+ * The wart is that `runId` no longer always names a run. Flagged rather than hidden; a separate cost dimension
+ * would be the cleaner answer if the ledger ever needs to distinguish them.
+ */
+export declare const extractionRunId: (fileId: string) => RunId;
+/**
+ * The image parser: OCR when there is text to transcribe, vision to describe, or both.
+ *
+ * Both is the useful default for a screenshot. A screenshot of a dashboard has text *and* a chart, and either
+ * alone loses half of it — the numbers without the layout, or the layout without the numbers.
+ */
+export declare const createImageDocumentParser: (deps: {
+    readonly vision?: VisionProvider;
+    readonly ocr?: OcrProvider;
+    /**
+     * Observed for tests and hosts that want the raw result.
+     *
+     * **Not the billing path.** Billing goes through the returned document's `usage`, because only the pipeline
+     * knows which file a parse belonged to — a callback held by the parser is shared across every file it ever
+     * parses, so correlating one would mean trusting that parses never interleave.
+     */
+    readonly onVisionUsage?: (usage: VisionResult) => void;
+}) => DocumentParser;
+/**
+ * OCR for a document the text parser could not read — a scanned PDF.
+ *
+ * A *fallback* parser rather than a second entry in the dispatch table, because both parsers claim
+ * `application/pdf` and the dispatch table holds one per media type. The pipeline tries the text parser
+ * first and falls back only on `no-text-layer`, which is the reason #131 made that a distinct reason rather
+ * than folding it into `malformed`: the distinction is now load-bearing.
+ */
+export declare const createScannedPdfParser: (deps: {
+    readonly ocr: OcrProvider;
+}) => DocumentParser;
+/** Records a vision call against the usage ledger. Separate so the parser stays free of billing. */
+export declare const recordVisionUsage: (recorder: UsageRecorder, context: ExecutionContext, input: {
+    readonly fileId: string;
+    readonly usage: VisionResult;
+    readonly costMinorUnits: number;
+    readonly currency: string;
+}) => Promise<void>;
+/** Guard for a media type this platform treats as an image. */
+export declare const isImageMediaType: (mediaType: string) => boolean;
+export { DEFAULT_VISION_PROMPT };
+//# sourceMappingURL=vision.d.ts.map

package/dist/documents/vision.js

@@ -0,0 +1,214 @@
+/**
+ * OCR and vision, feeding the same derived-artifact path (#132).
+ *
+ * The point of this file is that a screenshot, a scanned PDF and a Markdown file all end up as the same
+ * `ExtractedDocument`. Downstream — `read_document`, the context section, the blob — sees one representation
+ * regardless of where the text came from, which is what stops "can the model read this?" depending on the
+ * format the user happened to attach.
+ *
+ * Two ports, because the two jobs are genuinely different and conflating them would force one adapter to do
+ * both badly:
+ *
+ * - **`OcrProvider`** transcribes. Given a scan it returns the words that are on the page, with a confidence.
+ *   It does not interpret.
+ * - **`VisionProvider`** describes. Given a screenshot or a chart it says what is shown, which is the only
+ *   useful answer for an image with no text in it.
+ *
+ * **There is no built-in OCR adapter, and there cannot honestly be one.** OCR needs a trained engine —
+ * Tesseract, or a hosted service. The PDF parser in #131 could be written over the raw syntax with `zlib`
+ * because a PDF *contains* its text; a scan does not contain text at all. So `OcrProvider` is a port with a
+ * documented contract and no implementation in this package, and a deployment that needs OCR supplies one.
+ * The alternative — a stub that returns empty text — would make every scan look like a successful extraction
+ * of nothing, which is precisely the failure `no-text-layer` exists to prevent.
+ *
+ * The vision side *is* implemented, over the model registry, because a vision-capable model is already a
+ * dependency this platform has.
+ */
+import { AgentPlatformError } from "../core/errors.js";
+import { DEFAULT_VISION_PROMPT, describeImage } from "../models/vision.js";
+import { LOW_CONFIDENCE_THRESHOLD as THRESHOLD } from "../persistence/index.js";
+/**
+ * Below this, extraction is flagged rather than presented as certain — AC-5.
+ *
+ * Re-exported from `persistence`, not defined here. Two layers interpret the field and neither may import the
+ * other, so the port that declares `confidence` owns the number that gives it meaning.
+ */
+// `LOW_CONFIDENCE_THRESHOLD` is persistence's, and re-exporting it here gave one name two subpaths (#199).
+export const LOW_CONFIDENCE_WARNING = "The text was recognised with low confidence and may contain errors. Treat figures and names as uncertain.";
+/** The image types this platform will send to a vision model or an OCR engine. */
+export const IMAGE_MEDIA_TYPES = ["image/png", "image/jpeg", "image/webp", "image/gif"];
+/**
+ * A `VisionProvider` over the model registry.
+ *
+ * `requiredModalities: ["image"]` is AC-3, and it is enforced by `resolve` throwing rather than by a check
+ * here — see `models/vision.ts`. The refusal surfaces as `capability_unavailable`, which the pipeline records
+ * as a typed failure, so a deployment with no vision model gets "this platform cannot describe images"
+ * instead of a description of an image nobody looked at.
+ */
+export const createModelVisionProvider = (deps) => ({
+    id: "model-vision",
+    mediaTypes: IMAGE_MEDIA_TYPES,
+    async describe({ bytes, mediaType, prompt }) {
+        // Throws `capability_unavailable` when nothing satisfies it. Deliberately not caught: a fabricated
+        // description is the one outcome worse than no description, and swallowing this is how you get one.
+        const definition = deps.registry.resolve({
+            role: deps.role ?? "smart",
+            requiredModalities: ["image"],
+        });
+        const model = deps.providers.languageModel(definition);
+        const result = await describeImage({
+            model,
+            bytes,
+            mediaType,
+            ...(prompt === undefined ? {} : { prompt }),
+            ...(deps.maxOutputTokens === undefined ? {} : { maxOutputTokens: deps.maxOutputTokens }),
+        });
+        return {
+            description: result.text,
+            modelId: definition.modelId,
+            inputTokens: result.usage.inputTokens,
+            outputTokens: result.usage.outputTokens,
+            cachedInputTokens: result.usage.cachedInputTokens,
+        };
+    },
+});
+/**
+ * A synthetic run id for a background extraction.
+ *
+ * `UsageEvent.runId` is required, and an extraction is **not a run** — it has no conversation turn and no
+ * agent. Rather than widen the usage ledger with a second identity dimension, the extraction borrows the
+ * field with a namespaced value. Two consequences worth knowing:
+ *
+ * - The ledger stays single, which is what AC-4 asks for: one place to answer "what did this tenant spend".
+ * - `usageDedupeKey` is `(runId, stepId)`, so a retried extraction of the same file records **once**. That is
+ *   not incidental — vision calls are the expensive kind, and a re-enqueued job double-charging a tenant is
+ *   the failure this shape prevents.
+ *
+ * The wart is that `runId` no longer always names a run. Flagged rather than hidden; a separate cost dimension
+ * would be the cleaner answer if the ledger ever needs to distinguish them.
+ */
+export const extractionRunId = (fileId) => `extraction:${fileId}`;
+/**
+ * The image parser: OCR when there is text to transcribe, vision to describe, or both.
+ *
+ * Both is the useful default for a screenshot. A screenshot of a dashboard has text *and* a chart, and either
+ * alone loses half of it — the numbers without the layout, or the layout without the numbers.
+ */
+export const createImageDocumentParser = (deps) => ({
+    id: "image",
+    mediaTypes: IMAGE_MEDIA_TYPES,
+    async parse({ bytes, mediaType, limits }) {
+        if (bytes.byteLength > limits.maxBytes)
+            return {
+                reason: "too-large",
+                // AC-6, with the limit named rather than implied.
+                message: `That image is larger than the ${limits.maxBytes} byte limit.`,
+            };
+        const blocks = [];
+        const warnings = [];
+        const usage = [];
+        let confidence;
+        if (deps.ocr !== undefined && deps.ocr.mediaTypes.includes(mediaType)) {
+            const result = await deps.ocr.recognise({ bytes, mediaType, limits });
+            if ("reason" in result) {
+                // An OCR failure is not fatal when vision can still describe the image: a photograph with no text
+                // is exactly that case, and refusing the whole extraction would lose the description too.
+                warnings.push(`Text recognition failed: ${result.message}`);
+            }
+            else {
+                blocks.push(...result.blocks);
+                confidence = result.confidence;
+                warnings.push(...(result.warnings ?? []));
+                // AC-5. The flag is derived from the number rather than left to a reader to compare, so every
+                // consumer treats the same document as uncertain.
+                if (result.confidence < THRESHOLD)
+                    warnings.push(LOW_CONFIDENCE_WARNING);
+            }
+        }
+        if (deps.vision !== undefined && deps.vision.mediaTypes.includes(mediaType)) {
+            const result = await deps.vision.describe({ bytes, mediaType });
+            deps.onVisionUsage?.(result);
+            // Reported whether or not the description came back usable: the tokens were spent either way, and a
+            // call that produced nothing is exactly the one a bill should show.
+            usage.push({
+                kind: "vision",
+                modelId: result.modelId,
+                inputTokens: result.inputTokens,
+                outputTokens: result.outputTokens,
+                cachedInputTokens: result.cachedInputTokens,
+            });
+            if (result.description.trim() !== "")
+                // Labelled, because a description is the model's reading of an image and a transcription is what the
+                // image says. Presenting them identically would let a later answer cite an inference as a quote.
+                blocks.push({ kind: "heading", level: 2, text: "Image description" });
+            blocks.push({ kind: "paragraph", text: result.description.trim() });
+        }
+        if (blocks.length === 0)
+            return {
+                reason: "no-text-layer",
+                message: deps.ocr === undefined && deps.vision === undefined
+                    ? "This platform is not configured to read images."
+                    : "Nothing could be read from that image.",
+            };
+        return {
+            blocks,
+            truncated: false,
+            warnings,
+            ...(confidence === undefined ? {} : { confidence }),
+            ...(usage.length === 0 ? {} : { usage }),
+        };
+    },
+});
+/**
+ * OCR for a document the text parser could not read — a scanned PDF.
+ *
+ * A *fallback* parser rather than a second entry in the dispatch table, because both parsers claim
+ * `application/pdf` and the dispatch table holds one per media type. The pipeline tries the text parser
+ * first and falls back only on `no-text-layer`, which is the reason #131 made that a distinct reason rather
+ * than folding it into `malformed`: the distinction is now load-bearing.
+ */
+export const createScannedPdfParser = (deps) => ({
+    id: "scanned-pdf",
+    mediaTypes: ["application/pdf"],
+    async parse({ bytes, mediaType, limits }) {
+        if (bytes.byteLength > limits.maxBytes)
+            return { reason: "too-large", message: `That document is larger than the ${limits.maxBytes} byte limit.` };
+        const result = await deps.ocr.recognise({ bytes, mediaType, limits });
+        if ("reason" in result)
+            return result;
+        const warnings = [...(result.warnings ?? [])];
+        if (result.confidence < THRESHOLD)
+            warnings.push(LOW_CONFIDENCE_WARNING);
+        if (result.blocks.length === 0)
+            return {
+                reason: "no-text-layer",
+                message: "Text recognition found no readable text in that document.",
+            };
+        return {
+            blocks: result.blocks,
+            ...(result.pageCount === undefined ? {} : { pageCount: result.pageCount }),
+            truncated: false,
+            warnings,
+            confidence: result.confidence,
+        };
+    },
+});
+/** Records a vision call against the usage ledger. Separate so the parser stays free of billing. */
+export const recordVisionUsage = async (recorder, context, input) => {
+    await recorder.record(context, {
+        runId: extractionRunId(input.fileId),
+        // The step, so `usageDedupeKey` makes a retried extraction record once rather than charging twice for
+        // the same image.
+        stepId: "vision",
+        modelId: input.usage.modelId,
+        inputTokens: input.usage.inputTokens,
+        outputTokens: input.usage.outputTokens,
+        cachedInputTokens: input.usage.cachedInputTokens,
+        costMinorUnits: input.costMinorUnits,
+        currency: input.currency,
+    });
+};
+/** Guard for a media type this platform treats as an image. */
+export const isImageMediaType = (mediaType) => IMAGE_MEDIA_TYPES.includes(mediaType.split(";")[0]?.trim().toLowerCase() ?? "");
+export { DEFAULT_VISION_PROMPT };
+//# sourceMappingURL=vision.js.map

package/dist/entries/adapters-bullmq.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `@retinue/agentkit/adapters/bullmq` — the durable queue and its dispatchers.
+ *
+ * `bullmq` and `ioredis` are optional peers. Importing this constructs no connection; only
+ * `createBullMqRunQueue` does.
+ */
+export * from "../adapters/bullmq/index.js";
+//# sourceMappingURL=adapters-bullmq.d.ts.map

package/dist/entries/adapters-bullmq.js

@@ -0,0 +1,8 @@
+/**
+ * `@retinue/agentkit/adapters/bullmq` — the durable queue and its dispatchers.
+ *
+ * `bullmq` and `ioredis` are optional peers. Importing this constructs no connection; only
+ * `createBullMqRunQueue` does.
+ */
+export * from "../adapters/bullmq/index.js";
+//# sourceMappingURL=adapters-bullmq.js.map

package/dist/entries/adapters-otel.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `@retinue/agentkit/adapters/otel` — the OpenTelemetry exporter for the telemetry port.
+ *
+ * Its own entry for the reason boundary rule R11 exists: "vendor-neutral instrumentation" is only true if the
+ * vendor's SDK is confined to one place.
+ *
+ * It takes **no peer dependency**, which surprised me while packaging this: the adapter defines the structural
+ * types it needs and the caller passes a real provider, so `@opentelemetry/api` appears only in the tests. It
+ * was briefly declared as an optional peer here — an install requirement for something never imported — and
+ * removed once checked.
+ */
+export * from "../adapters/otel/index.js";
+//# sourceMappingURL=adapters-otel.d.ts.map

package/dist/entries/adapters-otel.js

@@ -0,0 +1,13 @@
+/**
+ * `@retinue/agentkit/adapters/otel` — the OpenTelemetry exporter for the telemetry port.
+ *
+ * Its own entry for the reason boundary rule R11 exists: "vendor-neutral instrumentation" is only true if the
+ * vendor's SDK is confined to one place.
+ *
+ * It takes **no peer dependency**, which surprised me while packaging this: the adapter defines the structural
+ * types it needs and the caller passes a real provider, so `@opentelemetry/api` appears only in the tests. It
+ * was briefly declared as an optional peer here — an install requirement for something never imported — and
+ * removed once checked.
+ */
+export * from "../adapters/otel/index.js";
+//# sourceMappingURL=adapters-otel.js.map

package/dist/entries/adapters-postgres.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `@retinue/agentkit/adapters/postgres` — the Postgres and Supabase adapters, and the migrations.
+ *
+ * Its own entry because `pg` is an optional peer. Supabase ships here rather than separately: it *is* these
+ * adapters over a connection with row-level security enabled, so splitting them would suggest a second
+ * implementation exists.
+ */
+export * from "../adapters/postgres/index.js";
+export * from "../adapters/supabase/index.js";
+//# sourceMappingURL=adapters-postgres.d.ts.map

package/dist/entries/adapters-postgres.js

@@ -0,0 +1,10 @@
+/**
+ * `@retinue/agentkit/adapters/postgres` — the Postgres and Supabase adapters, and the migrations.
+ *
+ * Its own entry because `pg` is an optional peer. Supabase ships here rather than separately: it *is* these
+ * adapters over a connection with row-level security enabled, so splitting them would suggest a second
+ * implementation exists.
+ */
+export * from "../adapters/postgres/index.js";
+export * from "../adapters/supabase/index.js";
+//# sourceMappingURL=adapters-postgres.js.map

package/dist/entries/adapters-redis.d.ts

@@ -0,0 +1,3 @@
+/** `@retinue/agentkit/adapters/redis` — realtime fan-out and distributed locks. `ioredis` is an optional peer. */
+export * from "../adapters/redis/index.js";
+//# sourceMappingURL=adapters-redis.d.ts.map

package/dist/entries/adapters-redis.js

@@ -0,0 +1,3 @@
+/** `@retinue/agentkit/adapters/redis` — realtime fan-out and distributed locks. `ioredis` is an optional peer. */
+export * from "../adapters/redis/index.js";
+//# sourceMappingURL=adapters-redis.js.map

package/dist/entries/context.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `@retinue/agentkit/context` — what goes into the prompt, and what comes back out of it.
+ *
+ * Assembly and budgeting, skills, per-principal memory, and citations. Grouped because they are one decision
+ * from the host's side: everything here competes for the same window.
+ */
+export * from "../context/index.js";
+export * from "../skills/index.js";
+export * from "../principal-memory/index.js";
+export * from "../citations/index.js";
+/**
+ * Prompt safety is context, not security review.
+ *
+ * `encloseUntrusted`, `makeNonce` and `renderContextBlock` are how third-party text is rendered *into* a prompt
+ * — the same subject as assembly and budgeting, and reached at the same moment. They sit in `src/security/`
+ * beside the executable security acceptances, which is a directory grouped by concern rather than by consumer;
+ * this is the consumer view, so they are here and the acceptances are at `./observability`.
+ */
+export * from "../security/prompt-safety.js";
+//# sourceMappingURL=context.d.ts.map

package/dist/entries/context.js

@@ -0,0 +1,20 @@
+/**
+ * `@retinue/agentkit/context` — what goes into the prompt, and what comes back out of it.
+ *
+ * Assembly and budgeting, skills, per-principal memory, and citations. Grouped because they are one decision
+ * from the host's side: everything here competes for the same window.
+ */
+export * from "../context/index.js";
+export * from "../skills/index.js";
+export * from "../principal-memory/index.js";
+export * from "../citations/index.js";
+/**
+ * Prompt safety is context, not security review.
+ *
+ * `encloseUntrusted`, `makeNonce` and `renderContextBlock` are how third-party text is rendered *into* a prompt
+ * — the same subject as assembly and budgeting, and reached at the same moment. They sit in `src/security/`
+ * beside the executable security acceptances, which is a directory grouped by concern rather than by consumer;
+ * this is the consumer view, so they are here and the acceptances are at `./observability`.
+ */
+export * from "../security/prompt-safety.js";
+//# sourceMappingURL=context.js.map

package/dist/entries/flows.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `@retinue/agentkit/flows` — durable workflows, and teams as a kind of step.
+ *
+ * REQ-038 (#187) and REQ-037 (#186), which are one subpath because they are one mechanism: a team compiles to a
+ * flow, so there is one interpreter, one durability story and one budget.
+ *
+ * No optional peer. The interpreter is a pure function and the runner takes ports, so the only thing a consumer
+ * needs beyond the runtime is a store — either the in-memory one at `./persistence` or Postgres at
+ * `./adapters/postgres`.
+ */
+export * from "../flows/index.js";
+export * from "../flows/interpreter.js";
+export * from "../flows/runner.js";
+export * from "../teams/index.js";
+//# sourceMappingURL=flows.d.ts.map

package/dist/entries/flows.js

@@ -0,0 +1,15 @@
+/**
+ * `@retinue/agentkit/flows` — durable workflows, and teams as a kind of step.
+ *
+ * REQ-038 (#187) and REQ-037 (#186), which are one subpath because they are one mechanism: a team compiles to a
+ * flow, so there is one interpreter, one durability story and one budget.
+ *
+ * No optional peer. The interpreter is a pure function and the runner takes ports, so the only thing a consumer
+ * needs beyond the runtime is a store — either the in-memory one at `./persistence` or Postgres at
+ * `./adapters/postgres`.
+ */
+export * from "../flows/index.js";
+export * from "../flows/interpreter.js";
+export * from "../flows/runner.js";
+export * from "../teams/index.js";
+//# sourceMappingURL=flows.js.map

package/dist/entries/hitl.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `@retinue/agentkit/hitl` — approvals, questions, and who may do what.
+ *
+ * The approval service and gate, the question service, and the authorization policy. Authorization is here
+ * rather than on its own because every consumer of one is a consumer of the other: an approval answers *may this
+ * happen*, and authorization answers *may this caller ask*.
+ */
+export * from "../hitl/index.js";
+export * from "../authorization/index.js";
+//# sourceMappingURL=hitl.d.ts.map

package/dist/entries/hitl.js

@@ -0,0 +1,10 @@
+/**
+ * `@retinue/agentkit/hitl` — approvals, questions, and who may do what.
+ *
+ * The approval service and gate, the question service, and the authorization policy. Authorization is here
+ * rather than on its own because every consumer of one is a consumer of the other: an approval answers *may this
+ * happen*, and authorization answers *may this caller ask*.
+ */
+export * from "../hitl/index.js";
+export * from "../authorization/index.js";
+//# sourceMappingURL=hitl.js.map

package/dist/entries/knowledge.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `@retinue/agentkit/knowledge` — indexed material, documents, files and artifacts.
+ *
+ * Retrieval, chunking and embeddings; the extraction pipeline; attachments and their read tools; artifacts and
+ * the export formats. One subpath because a deployment that has any of these has all of them: an attachment
+ * becomes a document becomes chunks becomes a retrieval hit.
+ */
+export * from "../knowledge/index.js";
+export * from "../documents/index.js";
+export * from "../files/index.js";
+export * from "../files/context.js";
+export * from "../files/read-tool.js";
+export * from "../files/turn-parts.js";
+export * from "../artifacts/index.js";
+export * from "../export/index.js";
+export * from "../export/pdf.js";
+export * from "../export/markdown.js";
+//# sourceMappingURL=knowledge.d.ts.map

package/dist/entries/knowledge.js

@@ -0,0 +1,19 @@
+/**
+ * `@retinue/agentkit/knowledge` — indexed material, documents, files and artifacts.
+ *
+ * Retrieval, chunking and embeddings; the extraction pipeline; attachments and their read tools; artifacts and
+ * the export formats. One subpath because a deployment that has any of these has all of them: an attachment
+ * becomes a document becomes chunks becomes a retrieval hit.
+ */
+export * from "../knowledge/index.js";
+export * from "../documents/index.js";
+export * from "../files/index.js";
+export * from "../files/context.js";
+export * from "../files/read-tool.js";
+// #185: resolving a stored attachment into a turn part, through the mediated read path.
+export * from "../files/turn-parts.js";
+export * from "../artifacts/index.js";
+export * from "../export/index.js";
+export * from "../export/pdf.js";
+export * from "../export/markdown.js";
+//# sourceMappingURL=knowledge.js.map

package/dist/entries/mcp.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `@retinue/agentkit/mcp` — importing another server's tools.
+ *
+ * The client, the provider, the effect classifier and the egress policy. Its own subpath rather than part of
+ * `./tools` because the trust story is different: a first-party tool is code in your repository, and an imported
+ * one is a contract with a process you do not control — which is why an unclassified remote tool becomes
+ * `external-write` rather than `read`.
+ */
+export * from "../mcp/index.js";
+//# sourceMappingURL=mcp.d.ts.map

package/dist/entries/mcp.js

@@ -0,0 +1,10 @@
+/**
+ * `@retinue/agentkit/mcp` — importing another server's tools.
+ *
+ * The client, the provider, the effect classifier and the egress policy. Its own subpath rather than part of
+ * `./tools` because the trust story is different: a first-party tool is code in your repository, and an imported
+ * one is a contract with a process you do not control — which is why an unclassified remote tool becomes
+ * `external-write` rather than `read`.
+ */
+export * from "../mcp/index.js";
+//# sourceMappingURL=mcp.js.map

package/dist/entries/observability.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `@retinue/agentkit/observability` — telemetry, retention, the security review and the harnesses.
+ *
+ * Platform operations rather than application code: spans and metrics, the retention windows and deletion path,
+ * the security review as executable acceptances, the load and evaluation harnesses. A consumer building an
+ * assistant needs none of it; a team running one needs all of it.
+ */
+export * from "../telemetry/index.js";
+export * from "../retention/index.js";
+export * from "../security/checklist.js";
+export * from "../security/findings.js";
+export * from "../evaluation/index.js";
+export * from "../loadtest/index.js";
+//# sourceMappingURL=observability.d.ts.map

package/dist/entries/observability.js

@@ -0,0 +1,16 @@
+/**
+ * `@retinue/agentkit/observability` — telemetry, retention, the security review and the harnesses.
+ *
+ * Platform operations rather than application code: spans and metrics, the retention windows and deletion path,
+ * the security review as executable acceptances, the load and evaluation harnesses. A consumer building an
+ * assistant needs none of it; a team running one needs all of it.
+ */
+export * from "../telemetry/index.js";
+export * from "../retention/index.js";
+// The security *review* — the executable acceptances and their revisit dates — but not `prompt-safety.ts`,
+// which is context rendering and lives at `./context`. One name, one subpath (#199).
+export * from "../security/checklist.js";
+export * from "../security/findings.js";
+export * from "../evaluation/index.js";
+export * from "../loadtest/index.js";
+//# sourceMappingURL=observability.js.map