@vibesdotdev/docs 0.0.0-stage → 1.0.0-rc.2

package/dist/documents/schemas/document-view.schema.d.ts

@@ -0,0 +1,74 @@
+/**
+ * `document.view` — the agent-vision drawing tool.
+ *
+ * Where `document.read` hands the model a TRANSCRIPTION produced by a separate OCR
+ * model, `document.view` hands the model the RENDERED PIXELS of the sheet and lets it
+ * look for itself. It is how a vision agent (e.g. Grok 4.5) reads a construction /
+ * millwork drawing the way a human estimator does: take in the whole sheet to orient,
+ * then zoom into a region to read dimensions and labels.
+ *
+ * The image is delivered to the agent as a real image block via the loop's
+ * multimodal-tool-result path (`agentImages`), NOT as base64 in the text result.
+ */
+import * as z from 'zod/v4';
+/** A zoom region as fractions of the sheet (0..1, top-left origin). */
+export declare const DocumentViewRegionSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    w: z.ZodNumber;
+    h: z.ZodNumber;
+}, z.core.$strip>;
+export type DocumentViewRegion = z.infer<typeof DocumentViewRegionSchema>;
+export declare const DocumentViewInputSchema: z.ZodObject<{
+    ref: z.ZodObject<{
+        providerId: z.ZodOptional<z.ZodString>;
+        path: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        documentId: z.ZodOptional<z.ZodString>;
+        sourceRefreshUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    page: z.ZodNumber;
+    region: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        w: z.ZodNumber;
+        h: z.ZodNumber;
+    }, z.core.$strip>>;
+    dpi: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type DocumentViewInput = z.infer<typeof DocumentViewInputSchema>;
+/** One rendered image handed to the agent (matches the loop's AgentToolResultImage). */
+export declare const DocumentViewImageSchema: z.ZodObject<{
+    data: z.ZodString;
+    mimeType: z.ZodString;
+    detail: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        high: "high";
+        auto: "auto";
+    }>>;
+    caption: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const DocumentViewOutputSchema: z.ZodObject<{
+    page: z.ZodNumber;
+    region: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        w: z.ZodNumber;
+        h: z.ZodNumber;
+    }, z.core.$strip>>;
+    imageWidth: z.ZodOptional<z.ZodNumber>;
+    imageHeight: z.ZodOptional<z.ZodNumber>;
+    agentImages: z.ZodArray<z.ZodObject<{
+        data: z.ZodString;
+        mimeType: z.ZodString;
+        detail: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            high: "high";
+            auto: "auto";
+        }>>;
+        caption: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    note: z.ZodString;
+}, z.core.$strip>;
+export type DocumentViewOutput = z.infer<typeof DocumentViewOutputSchema>;
+//# sourceMappingURL=document-view.schema.d.ts.map

package/dist/documents/schemas/document-view.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-view.schema.d.ts","sourceRoot":"","sources":["../../../src/documents/schemas/document-view.schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAG5B,uEAAuE;AACvE,eAAO,MAAM,wBAAwB;;;;;iBASnC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;iBAiBlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,wFAAwF;AACxF,eAAO,MAAM,uBAAuB;;;;;;;;;iBAKlC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;iBAcnC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/dist/documents/schemas/document-view.schema.js

@@ -0,0 +1,66 @@
+/**
+ * `document.view` — the agent-vision drawing tool.
+ *
+ * Where `document.read` hands the model a TRANSCRIPTION produced by a separate OCR
+ * model, `document.view` hands the model the RENDERED PIXELS of the sheet and lets it
+ * look for itself. It is how a vision agent (e.g. Grok 4.5) reads a construction /
+ * millwork drawing the way a human estimator does: take in the whole sheet to orient,
+ * then zoom into a region to read dimensions and labels.
+ *
+ * The image is delivered to the agent as a real image block via the loop's
+ * multimodal-tool-result path (`agentImages`), NOT as base64 in the text result.
+ */
+import * as z from 'zod/v4';
+import { DocumentRefSchema } from "./document-read.schema.js";
+/** A zoom region as fractions of the sheet (0..1, top-left origin). */
+export const DocumentViewRegionSchema = z.object({
+    /** Left edge, 0..1 across the sheet width. */
+    x: z.number().min(0).max(1),
+    /** Top edge, 0..1 down the sheet height. */
+    y: z.number().min(0).max(1),
+    /** Region width, 0..1 of the sheet width. */
+    w: z.number().min(0.01).max(1),
+    /** Region height, 0..1 of the sheet height. */
+    h: z.number().min(0.01).max(1)
+});
+export const DocumentViewInputSchema = z.object({
+    /** Identifies the source document (same ref shape as document.read). */
+    ref: DocumentRefSchema,
+    /** 1-based page/sheet number to render. */
+    page: z.number().int().positive(),
+    /**
+     * Optional zoom region in 0..1 sheet fractions. OMIT to get the whole sheet
+     * (downscaled to orient); SET it to lean in and read a region at high resolution.
+     * Pick the region from what you saw in a prior whole-sheet view.
+     */
+    region: DocumentViewRegionSchema.optional(),
+    /**
+     * Optional render DPI override. Defaults are chosen for you: a modest DPI for the
+     * whole-sheet overview (fast, fits the vision budget) and a high DPI for a zoom
+     * (so small dimension text is legible).
+     */
+    dpi: z.number().int().positive().max(600).optional()
+});
+/** One rendered image handed to the agent (matches the loop's AgentToolResultImage). */
+export const DocumentViewImageSchema = z.object({
+    data: z.string(),
+    mimeType: z.string(),
+    detail: z.enum(['auto', 'low', 'high']).optional(),
+    caption: z.string().optional()
+});
+export const DocumentViewOutputSchema = z.object({
+    page: z.number().int().positive(),
+    /** The region rendered, when a zoom was requested. */
+    region: DocumentViewRegionSchema.optional(),
+    /** Rendered image pixel dimensions, when the renderer reports them. */
+    imageWidth: z.number().optional(),
+    imageHeight: z.number().optional(),
+    /**
+     * The rendered image(s), delivered to a vision model as real image blocks by the
+     * agent loop. Reserved field name — see the loop's AGENT_IMAGES_RESULT_FIELD.
+     */
+    agentImages: z.array(DocumentViewImageSchema),
+    /** A short instruction to the agent on how to proceed (orient → zoom). */
+    note: z.string()
+});
+//# sourceMappingURL=document-view.schema.js.map

package/dist/documents/schemas/document-view.schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-view.schema.js","sourceRoot":"","sources":["../../../src/documents/schemas/document-view.schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAE9D,uEAAuE;AACvE,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC;IAChD,8CAA8C;IAC9C,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAC3B,4CAA4C;IAC5C,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAC3B,6CAA6C;IAC7C,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAC9B,+CAA+C;IAC/C,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;CAC9B,CAAC,CAAC;AAGH,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC/C,wEAAwE;IACxE,GAAG,EAAE,iBAAiB;IACtB,2CAA2C;IAC3C,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;IACjC;;;;OAIG;IACH,MAAM,EAAE,wBAAwB,CAAC,QAAQ,EAAE;IAC3C;;;;OAIG;IACH,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE;CACpD,CAAC,CAAC;AAGH,wFAAwF;AACxF,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC/C,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;IACpB,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC,QAAQ,EAAE;IAClD,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC9B,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC;IAChD,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;IACjC,sDAAsD;IACtD,MAAM,EAAE,wBAAwB,CAAC,QAAQ,EAAE;IAC3C,uEAAuE;IACvE,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACjC,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAClC;;;OAGG;IACH,WAAW,EAAE,CAAC,CAAC,KAAK,CAAC,uBAAuB,CAAC;IAC7C,0EAA0E;IAC1E,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;CAChB,CAAC,CAAC"}

package/dist/documents/schemas/index.d.ts

@@ -0,0 +1,3 @@
+export * from './document-read.schema.ts';
+export * from './page-cache.schema.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/documents/schemas/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/documents/schemas/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC"}

package/dist/documents/schemas/index.js

@@ -0,0 +1,3 @@
+export * from "./document-read.schema.js";
+export * from "./page-cache.schema.js";
+//# sourceMappingURL=index.js.map

package/dist/documents/schemas/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/documents/schemas/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC"}

package/dist/documents/schemas/page-cache.schema.d.ts

@@ -0,0 +1,29 @@
+/**
+ * documents.page-cache record schema.
+ *
+ * Shape of individual cache records stored by the `documents.page-cache`
+ * storage manifest. One record per (ref × page × renderProfile × promptVersion)
+ * tuple. MCP-safe: no .refine(), .transform(), .pipe(), or .preprocess().
+ */
+import * as z from 'zod/v4';
+export declare const DocumentPageCacheRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    ref: z.ZodObject<{
+        providerId: z.ZodOptional<z.ZodString>;
+        path: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        documentId: z.ZodOptional<z.ZodString>;
+        sourceRefreshUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    page: z.ZodNumber;
+    renderProfile: z.ZodString;
+    promptVersion: z.ZodString;
+    ocrMarkdown: z.ZodString;
+    extractRows: z.ZodOptional<z.ZodArray<z.ZodType<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue, z.core.$ZodTypeInternals<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue>>>>;
+    quality: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue, z.core.$ZodTypeInternals<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue>>>>;
+    ocrModelId: z.ZodOptional<z.ZodString>;
+    sourceHash: z.ZodString;
+    renderedAt: z.ZodString;
+}, z.core.$strip>;
+export type DocumentPageCacheRecord = z.infer<typeof DocumentPageCacheRecordSchema>;
+//# sourceMappingURL=page-cache.schema.d.ts.map

package/dist/documents/schemas/page-cache.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-cache.schema.d.ts","sourceRoot":"","sources":["../../../src/documents/schemas/page-cache.schema.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAI5B,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;iBAgDxC,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC"}

package/dist/documents/schemas/page-cache.schema.js

@@ -0,0 +1,50 @@
+/**
+ * documents.page-cache record schema.
+ *
+ * Shape of individual cache records stored by the `documents.page-cache`
+ * storage manifest. One record per (ref × page × renderProfile × promptVersion)
+ * tuple. MCP-safe: no .refine(), .transform(), .pipe(), or .preprocess().
+ */
+import * as z from 'zod/v4';
+import { JsonValueSchema } from '@vibesdotdev/kernel/schemas/json';
+import { DocumentRefSchema } from "./document-read.schema.js";
+export const DocumentPageCacheRecordSchema = z.object({
+    /** Stable unique identifier for this cache record (cache key). */
+    id: z.string(),
+    /** Reference to the source document — mirrors DocumentReadInput.ref. */
+    ref: DocumentRefSchema,
+    /** 1-based page number this record covers. */
+    page: z.number().int().positive(),
+    /**
+     * Render profile string that was used to produce the page image
+     * (e.g. "overview-96dpi", "tile-300dpi", "high-dpi-600dpi").
+     */
+    renderProfile: z.string(),
+    /**
+     * Prompt version string at the time the record was written. Used as a
+     * cache-invalidation key — a new version bypasses any existing record.
+     */
+    promptVersion: z.string(),
+    /** Full OCR/vision markdown text for this page. */
+    ocrMarkdown: z.string(),
+    /**
+     * Structured rows extracted from this page, when the original request
+     * included a JSON-schema. Null/undefined for plain markdown reads.
+     */
+    extractRows: z.array(JsonValueSchema).optional(),
+    /**
+     * Quality metadata returned by the OCR/extract model
+     * (confidence scores, bounding-box coverage, etc.).
+     */
+    quality: z.record(z.string(), JsonValueSchema).optional(),
+    /** Model id used for OCR/vision on this record. */
+    ocrModelId: z.string().optional(),
+    /**
+     * Hash of the rendered page bytes — used to detect source document changes
+     * even when the ref and page number are identical.
+     */
+    sourceHash: z.string(),
+    /** ISO-8601 timestamp at which this record was last written. */
+    renderedAt: z.string()
+});
+//# sourceMappingURL=page-cache.schema.js.map

package/dist/documents/schemas/page-cache.schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-cache.schema.js","sourceRoot":"","sources":["../../../src/documents/schemas/page-cache.schema.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACnE,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAE9D,MAAM,CAAC,MAAM,6BAA6B,GAAG,CAAC,CAAC,MAAM,CAAC;IACrD,kEAAkE;IAClE,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IAEd,wEAAwE;IACxE,GAAG,EAAE,iBAAiB;IAEtB,8CAA8C;IAC9C,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;IAEjC;;;OAGG;IACH,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE;IAEzB;;;OAGG;IACH,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE;IAEzB,mDAAmD;IACnD,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;IAEvB;;;OAGG;IACH,WAAW,EAAE,CAAC,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,QAAQ,EAAE;IAEhD;;;OAGG;IACH,OAAO,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,eAAe,CAAC,CAAC,QAAQ,EAAE;IAEzD,mDAAmD;IACnD,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAEjC;;;OAGG;IACH,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;IAEtB,gEAAgE;IAChE,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;CACtB,CAAC,CAAC"}

package/dist/documents/storage/index.d.ts

@@ -0,0 +1,3 @@
+export { documentPageCacheDescriptor } from './page-cache.descriptor.ts';
+export type { StorageManifestDescriptor } from '@vibesdotdev/storage';
+//# sourceMappingURL=index.d.ts.map

package/dist/documents/storage/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/documents/storage/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,4BAA4B,CAAC;AACzE,YAAY,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/documents/storage/index.js

@@ -0,0 +1,2 @@
+export { documentPageCacheDescriptor } from "./page-cache.descriptor.js";
+//# sourceMappingURL=index.js.map

package/dist/documents/storage/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/documents/storage/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,4BAA4B,CAAC"}

package/dist/documents/storage/page-cache.descriptor.d.ts

@@ -0,0 +1,17 @@
+/**
+ * documents.page-cache storage manifest descriptor.
+ *
+ * Declares the persisted shape, allowed adapters, and per-scope selection
+ * hints for the document page cache. The cache stores one record per
+ * (ref × page × renderProfile × promptVersion) tuple.
+ *
+ * Implementation lives in `document-read.impl.ts`; the runtime resolver
+ * picks the adapter at query time:
+ *   - consumer → storage.localdb / storage.json
+ *   - cloud    → storage.cloud-api against platform-web
+ *     `/api/documents/page-cache` (vibesCrudCollection; ownerApp: platform).
+ */
+import type { StorageManifestDescriptor } from '@vibesdotdev/storage';
+export declare const documentPageCacheDescriptor: StorageManifestDescriptor;
+export default documentPageCacheDescriptor;
+//# sourceMappingURL=page-cache.descriptor.d.ts.map

package/dist/documents/storage/page-cache.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-cache.descriptor.d.ts","sourceRoot":"","sources":["../../../src/documents/storage/page-cache.descriptor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AAGtE,eAAO,MAAM,2BAA2B,EAAE,yBA6BzC,CAAC;AAEF,eAAe,2BAA2B,CAAC"}

package/dist/documents/storage/page-cache.descriptor.js

@@ -0,0 +1,45 @@
+/**
+ * documents.page-cache storage manifest descriptor.
+ *
+ * Declares the persisted shape, allowed adapters, and per-scope selection
+ * hints for the document page cache. The cache stores one record per
+ * (ref × page × renderProfile × promptVersion) tuple.
+ *
+ * Implementation lives in `document-read.impl.ts`; the runtime resolver
+ * picks the adapter at query time:
+ *   - consumer → storage.localdb / storage.json
+ *   - cloud    → storage.cloud-api against platform-web
+ *     `/api/documents/page-cache` (vibesCrudCollection; ownerApp: platform).
+ */
+import { DocumentPageCacheRecordSchema } from "../schemas/page-cache.schema.js";
+export const documentPageCacheDescriptor = {
+    kind: 'storage/manifest',
+    id: 'documents.page-cache',
+    name: 'Document Page Cache',
+    description: 'Cached OCR/vision markdown per document page. Keyed by (ref × page × renderProfile × promptVersion).',
+    namespace: 'documents.page-cache',
+    schema: DocumentPageCacheRecordSchema,
+    dataType: 'records',
+    idField: 'id',
+    collectionField: 'records',
+    allowedAdapters: ['storage.json', 'storage.localdb', 'storage.cloud-api', 'storage.memory'],
+    defaultAdapter: 'storage.json',
+    adapterConfig: {
+        'storage.json': {
+            filename: 'documents-page-cache.json'
+        },
+        'storage.cloud-api': {
+            ownerApp: 'platform',
+            endpoint: '/api/documents/page-cache'
+        }
+    },
+    scope: 'project',
+    sensitiveFields: [],
+    version: 1,
+    customTables: false,
+    internal: false,
+    enabled: true,
+    tags: ['documents', 'cache', 'ocr']
+};
+export default documentPageCacheDescriptor;
+//# sourceMappingURL=page-cache.descriptor.js.map

package/dist/documents/storage/page-cache.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-cache.descriptor.js","sourceRoot":"","sources":["../../../src/documents/storage/page-cache.descriptor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AAEhF,MAAM,CAAC,MAAM,2BAA2B,GAA8B;IACrE,IAAI,EAAE,kBAAkB;IACxB,EAAE,EAAE,sBAAsB;IAC1B,IAAI,EAAE,qBAAqB;IAC3B,WAAW,EACV,sGAAsG;IACvG,SAAS,EAAE,sBAAsB;IACjC,MAAM,EAAE,6BAA6B;IACrC,QAAQ,EAAE,SAAS;IACnB,OAAO,EAAE,IAAI;IACb,eAAe,EAAE,SAAS;IAC1B,eAAe,EAAE,CAAC,cAAc,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,gBAAgB,CAAC;IAC3F,cAAc,EAAE,cAAc;IAC9B,aAAa,EAAE;QACd,cAAc,EAAE;YACf,QAAQ,EAAE,2BAA2B;SACrC;QACD,mBAAmB,EAAE;YACpB,QAAQ,EAAE,UAAU;YACpB,QAAQ,EAAE,2BAA2B;SACrC;KACD;IACD,KAAK,EAAE,SAAS;IAChB,eAAe,EAAE,EAAE;IACnB,OAAO,EAAE,CAAC;IACV,YAAY,EAAE,KAAK;IACnB,QAAQ,EAAE,KAAK;IACf,OAAO,EAAE,IAAI;IACb,IAAI,EAAE,CAAC,WAAW,EAAE,OAAO,EAAE,KAAK,CAAC;CACnC,CAAC;AAEF,eAAe,2BAA2B,CAAC"}

package/dist/documents/tools/descriptors.d.ts

@@ -0,0 +1,248 @@
+/**
+ * Document agent-tool descriptors.
+ *
+ * Declares the `document.read` tool via `createRuntimeAsset`. The impl
+ * (cache-first orchestration, render delegation, vision-OCR) lives in
+ * `document-read.impl.ts` and is loaded lazily by the plugin.
+ */
+export declare const DOCUMENT_TOOL_IDS: readonly ["document.read", "document.view"];
+export type DocumentToolId = (typeof DOCUMENT_TOOL_IDS)[number];
+export declare function isDocumentToolId(value: string): value is DocumentToolId;
+export declare const documentReadToolDescriptor: {
+    id: string;
+    name: string;
+    description: string;
+    mcpDescription: string;
+    subcategory: string;
+    safety: string;
+    requiresApproval: boolean;
+    schemas: {
+        input: import("zod").ZodObject<{
+            ref: import("zod").ZodObject<{
+                providerId: import("zod").ZodOptional<import("zod").ZodString>;
+                path: import("zod").ZodOptional<import("zod").ZodString>;
+                url: import("zod").ZodOptional<import("zod").ZodString>;
+                documentId: import("zod").ZodOptional<import("zod").ZodString>;
+                sourceRefreshUrl: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>;
+            pages: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+            question: import("zod").ZodOptional<import("zod").ZodString>;
+            schema: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            schemaId: import("zod").ZodOptional<import("zod").ZodString>;
+            vocabulary: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            rowContainerKeys: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            instructions: import("zod").ZodOptional<import("zod").ZodString>;
+            modelName: import("zod").ZodOptional<import("zod").ZodString>;
+            visionFocusHint: import("zod").ZodOptional<import("zod").ZodString>;
+            promptVersion: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+        output: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"markdown">;
+            pages: import("zod").ZodArray<import("zod").ZodObject<{
+                index: import("zod").ZodNumber;
+                title: import("zod").ZodOptional<import("zod").ZodString>;
+                text: import("zod").ZodString;
+                cacheHit: import("zod").ZodBoolean;
+                status: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    error: "error";
+                    ready: "ready";
+                    processing: "processing";
+                }>>;
+                cacheKey: import("zod").ZodOptional<import("zod").ZodString>;
+                jobId: import("zod").ZodOptional<import("zod").ZodString>;
+                message: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"structured">;
+            rows: import("zod").ZodArray<import("zod").ZodType<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue, import("zod/v4/core").$ZodTypeInternals<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue>>>;
+            diagnostics: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodType<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue, import("zod/v4/core").$ZodTypeInternals<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue>>>>;
+        }, import("zod/v4/core").$strip>], "kind">;
+    };
+    usageGuidance: {
+        when: string;
+        commonPatterns: string[];
+    };
+    kind: "tools/tool";
+    hardware: readonly ["consumer", "cloud"];
+    purpose: readonly ["agent", "direct", "worker"];
+    category: string;
+    tags: string[];
+};
+export declare const documentViewToolDescriptor: {
+    id: string;
+    name: string;
+    description: string;
+    mcpDescription: string;
+    subcategory: string;
+    safety: string;
+    requiresApproval: boolean;
+    schemas: {
+        input: import("zod").ZodObject<{
+            ref: import("zod").ZodObject<{
+                providerId: import("zod").ZodOptional<import("zod").ZodString>;
+                path: import("zod").ZodOptional<import("zod").ZodString>;
+                url: import("zod").ZodOptional<import("zod").ZodString>;
+                documentId: import("zod").ZodOptional<import("zod").ZodString>;
+                sourceRefreshUrl: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>;
+            page: import("zod").ZodNumber;
+            region: import("zod").ZodOptional<import("zod").ZodObject<{
+                x: import("zod").ZodNumber;
+                y: import("zod").ZodNumber;
+                w: import("zod").ZodNumber;
+                h: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>>;
+            dpi: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        output: import("zod").ZodObject<{
+            page: import("zod").ZodNumber;
+            region: import("zod").ZodOptional<import("zod").ZodObject<{
+                x: import("zod").ZodNumber;
+                y: import("zod").ZodNumber;
+                w: import("zod").ZodNumber;
+                h: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>>;
+            imageWidth: import("zod").ZodOptional<import("zod").ZodNumber>;
+            imageHeight: import("zod").ZodOptional<import("zod").ZodNumber>;
+            agentImages: import("zod").ZodArray<import("zod").ZodObject<{
+                data: import("zod").ZodString;
+                mimeType: import("zod").ZodString;
+                detail: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    low: "low";
+                    high: "high";
+                    auto: "auto";
+                }>>;
+                caption: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>>;
+            note: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    };
+    usageGuidance: {
+        when: string;
+        commonPatterns: string[];
+    };
+    kind: "tools/tool";
+    hardware: readonly ["consumer", "cloud"];
+    purpose: readonly ["agent", "direct", "worker"];
+    category: string;
+    tags: string[];
+};
+export declare const documentToolDescriptors: readonly [{
+    id: string;
+    name: string;
+    description: string;
+    mcpDescription: string;
+    subcategory: string;
+    safety: string;
+    requiresApproval: boolean;
+    schemas: {
+        input: import("zod").ZodObject<{
+            ref: import("zod").ZodObject<{
+                providerId: import("zod").ZodOptional<import("zod").ZodString>;
+                path: import("zod").ZodOptional<import("zod").ZodString>;
+                url: import("zod").ZodOptional<import("zod").ZodString>;
+                documentId: import("zod").ZodOptional<import("zod").ZodString>;
+                sourceRefreshUrl: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>;
+            pages: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+            question: import("zod").ZodOptional<import("zod").ZodString>;
+            schema: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            schemaId: import("zod").ZodOptional<import("zod").ZodString>;
+            vocabulary: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            rowContainerKeys: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            instructions: import("zod").ZodOptional<import("zod").ZodString>;
+            modelName: import("zod").ZodOptional<import("zod").ZodString>;
+            visionFocusHint: import("zod").ZodOptional<import("zod").ZodString>;
+            promptVersion: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+        output: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"markdown">;
+            pages: import("zod").ZodArray<import("zod").ZodObject<{
+                index: import("zod").ZodNumber;
+                title: import("zod").ZodOptional<import("zod").ZodString>;
+                text: import("zod").ZodString;
+                cacheHit: import("zod").ZodBoolean;
+                status: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    error: "error";
+                    ready: "ready";
+                    processing: "processing";
+                }>>;
+                cacheKey: import("zod").ZodOptional<import("zod").ZodString>;
+                jobId: import("zod").ZodOptional<import("zod").ZodString>;
+                message: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"structured">;
+            rows: import("zod").ZodArray<import("zod").ZodType<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue, import("zod/v4/core").$ZodTypeInternals<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue>>>;
+            diagnostics: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodType<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue, import("zod/v4/core").$ZodTypeInternals<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue>>>>;
+        }, import("zod/v4/core").$strip>], "kind">;
+    };
+    usageGuidance: {
+        when: string;
+        commonPatterns: string[];
+    };
+    kind: "tools/tool";
+    hardware: readonly ["consumer", "cloud"];
+    purpose: readonly ["agent", "direct", "worker"];
+    category: string;
+    tags: string[];
+}, {
+    id: string;
+    name: string;
+    description: string;
+    mcpDescription: string;
+    subcategory: string;
+    safety: string;
+    requiresApproval: boolean;
+    schemas: {
+        input: import("zod").ZodObject<{
+            ref: import("zod").ZodObject<{
+                providerId: import("zod").ZodOptional<import("zod").ZodString>;
+                path: import("zod").ZodOptional<import("zod").ZodString>;
+                url: import("zod").ZodOptional<import("zod").ZodString>;
+                documentId: import("zod").ZodOptional<import("zod").ZodString>;
+                sourceRefreshUrl: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>;
+            page: import("zod").ZodNumber;
+            region: import("zod").ZodOptional<import("zod").ZodObject<{
+                x: import("zod").ZodNumber;
+                y: import("zod").ZodNumber;
+                w: import("zod").ZodNumber;
+                h: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>>;
+            dpi: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        output: import("zod").ZodObject<{
+            page: import("zod").ZodNumber;
+            region: import("zod").ZodOptional<import("zod").ZodObject<{
+                x: import("zod").ZodNumber;
+                y: import("zod").ZodNumber;
+                w: import("zod").ZodNumber;
+                h: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>>;
+            imageWidth: import("zod").ZodOptional<import("zod").ZodNumber>;
+            imageHeight: import("zod").ZodOptional<import("zod").ZodNumber>;
+            agentImages: import("zod").ZodArray<import("zod").ZodObject<{
+                data: import("zod").ZodString;
+                mimeType: import("zod").ZodString;
+                detail: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    low: "low";
+                    high: "high";
+                    auto: "auto";
+                }>>;
+                caption: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>>;
+            note: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    };
+    usageGuidance: {
+        when: string;
+        commonPatterns: string[];
+    };
+    kind: "tools/tool";
+    hardware: readonly ["consumer", "cloud"];
+    purpose: readonly ["agent", "direct", "worker"];
+    category: string;
+    tags: string[];
+}];
+//# sourceMappingURL=descriptors.d.ts.map

package/dist/documents/tools/descriptors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptors.d.ts","sourceRoot":"","sources":["../../../src/documents/tools/descriptors.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,eAAO,MAAM,iBAAiB,6CAA8C,CAAC;AAE7E,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEhE,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,cAAc,CAEvE;AAUD,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BrC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BrC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAoE,CAAC"}