zigmini 1.0.0-beta.3 → 1.1.0-beta.1

package/host/omo-check/patches/attachments-293/document-content.js

@@ -0,0 +1,234 @@
+// UNRELEASED T5 source appended to pi-ai/dist/types.js by the frozen source patch.
+// Gateway authorization is a required caller-owned boundary, not implemented here.
+import { createHash } from "node:crypto";
+import { z } from "zod";
+
+export class DocumentInputError extends Error {
+    constructor(code) {
+        super(code);
+        this.name = "DocumentInputError";
+        this.code = code;
+    }
+}
+const documentSha = z.string().regex(/^[a-f0-9]{64}$/);
+const documentSourceSchema = z.object({
+    attachmentId: z.string().uuid(), grantId: z.string().uuid(), originalSha256: documentSha,
+}).strict();
+const documentFields = {
+    type: z.literal("document"), mimeType: z.literal("application/pdf"), name: z.string().min(1).max(1024),
+};
+export const documentReferenceSchema = z.object({
+    ...documentFields, source: documentSourceSchema.extend({ kind: z.literal("attachment") }).strict(),
+}).strict();
+export const documentContentSchema = z.object({
+    ...documentFields, data: z.string().min(4).max(13981016)
+        .regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/),
+    provenance: documentSourceSchema,
+}).strict();
+export const documentAttachmentSchema = z.object({
+    id: z.string().uuid(), grantId: z.string().uuid(), name: z.string().min(1).max(1024),
+    format: z.enum(["html", "md", "txt", "pdf"]), bytes: z.number().int().min(1).max(10485760),
+    sha256: documentSha, readMode: z.enum(["text", "native-document", "pages", "ocr"]),
+    pageCount: z.number().int().min(1).max(300).optional(),
+}).strict();
+export function checkedDocument(value) {
+    const parsed = documentContentSchema.safeParse(value);
+    if (!parsed.success) throw new DocumentInputError("attachment_document_invalid");
+    const document = parsed.data;
+    const bytes = Buffer.from(document.data, "base64");
+    if (bytes.length > 10485760 || bytes.toString("base64") !== document.data ||
+        bytes.subarray(0, 5).toString("ascii") !== "%PDF-" ||
+        createHash("sha256").update(bytes).digest("hex") !== document.provenance.originalSha256)
+        throw new DocumentInputError("attachment_document_integrity");
+    return document;
+}
+/** Ingress bytes are checked, then dropped. Durable records contain only sealed grant references. */
+export function normalizeDocumentInput(input, references = false) {
+    if (input.documents === undefined && input.attachments === undefined) return {};
+    if (!input.clientInputId || !Array.isArray(input.documents) ||
+        input.documents.length < 1 || input.documents.length > 4 ||
+        !Array.isArray(input.attachments) || input.attachments.length !== input.documents.length)
+        throw new DocumentInputError("attachment_document_identity");
+    const attachments = input.attachments.map(value => {
+        const result = documentAttachmentSchema.safeParse(value);
+        if (!result.success) throw new DocumentInputError("attachment_metadata_invalid");
+        return result.data;
+    });
+    const seen = new Set();
+    const documents = input.documents.map((value, index) => {
+        const document = references ? documentReferenceSchema.parse(value) : checkedDocument(value);
+        const source = references ? document.source : document.provenance;
+        const metadata = attachments[index];
+        if (seen.has(source.attachmentId) || metadata.id !== source.attachmentId ||
+            metadata.grantId !== source.grantId || metadata.sha256 !== source.originalSha256 ||
+            metadata.name !== document.name || metadata.format !== "pdf" ||
+            (!references && metadata.bytes !== Buffer.from(document.data, "base64").length))
+            throw new DocumentInputError("attachment_document_identity");
+        seen.add(source.attachmentId);
+        return { type: "document", mimeType: "application/pdf", name: document.name,
+            source: { kind: "attachment", attachmentId: source.attachmentId,
+                grantId: source.grantId, originalSha256: source.originalSha256 } };
+    });
+    return { documents, attachments, origin: "owner-attachment" };
+}
+export function documentInputMetadata(input) {
+    return input?.documents?.length
+        ? { origin: "owner-attachment", attachments: input.attachments }
+        : {};
+}
+/** Provider identity and API are both required; a lookalike model name grants no native-file route. */
+export function documentReadMode(model) {
+    if (!model?.input?.includes("image")) return "ocr";
+    if ((model.provider === "openai" && model.api === "openai-responses") ||
+        (model.provider === "anthropic" && model.api === "anthropic-messages")) return "native-document";
+    return "pages";
+}
+export function hasDocuments(messages) {
+    return messages.some(message => Array.isArray(message.content) &&
+        message.content.some(block => block.type === "document" || block.documentSource !== undefined));
+}
+export function documentRequestLimit(model) {
+    // OpenAI documents a 50 MB aggregate file limit. This local wire ceiling is stricter after base64.
+    // Claude first-party documents 128 MB. Subscription transport keeps a conservative 24 MiB ceiling.
+    if (model.provider === "openai" && model.api === "openai-responses") return 50_000_000;
+    if (model.provider === "anthropic" && model.api === "anthropic-messages") return 128_000_000;
+    return 24 * 1024 * 1024;
+}
+export function assertDocumentRequestBudget(payload, model, messages) {
+    if (!hasDocuments(messages)) return;
+    const bytes = Buffer.byteLength(JSON.stringify(payload));
+    if (bytes > documentRequestLimit(model))
+        throw new DocumentInputError("attachment_request_limit");
+}
+const representationBlock = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("text"), text: z.string().max(49152) }).strict(),
+    z.object({ type: z.literal("image"), mimeType: z.enum(["image/png", "image/jpeg"]),
+        data: z.string().max(5592408) }).strict(),
+    documentContentSchema,
+]);
+const representationSchema = z.object({
+    status: z.literal("ready"), originalSha256: documentSha, representationSha256: documentSha,
+    payloadSha256: documentSha,
+    grantRevision: z.number().int().positive(), estimatedTokens: z.number().int().nonnegative(),
+    content: z.array(representationBlock).min(1).max(2000),
+    coverage: z.object({
+        totalPages: z.number().int().min(1).max(300),
+        pages: z.array(z.object({ page: z.number().int().min(1).max(300),
+            representation: z.enum(["native-text", "rendered-image", "ocr-text", "verified-blank"]) }).strict()).max(300),
+    }).strict(),
+    nextCursor: z.string().min(1).optional(),
+}).strict();
+/** Resolve on every request, including replay and provider changes. There is no host-path reader or cache. */
+export async function resolveDocumentMessages(messages, model, boundary) {
+    const result = [];
+    let wireBytes = Buffer.byteLength(JSON.stringify(messages));
+    let inputTokens = Math.ceil(wireBytes / 3);
+    let nativePages = 0;
+    for (const message of messages) {
+        if (!Array.isArray(message.content) || !message.content.some(block => block.type === "document")) {
+            result.push(message);
+            continue;
+        }
+        if (message.role !== "user" || message.origin !== "owner-attachment" || !message.clientInputId)
+            throw new DocumentInputError("attachment_document_origin");
+        const content = [];
+        for (const block of message.content) {
+            if (block.type !== "document") { content.push(block); continue; }
+            const reference = documentReferenceSchema.parse(block);
+            const metadata = message.attachments?.find(item => item.id === reference.source.attachmentId);
+            if (!metadata || metadata.grantId !== reference.source.grantId ||
+                metadata.sha256 !== reference.source.originalSha256)
+                throw new DocumentInputError("attachment_document_identity");
+            let mode = documentReadMode(model);
+            const nativeLimit = model.provider === "anthropic" && model.contextWindow < 1_000_000 ? 100 : 300;
+            if (mode === "native-document" && (nativePages + (metadata.pageCount ?? 300) > nativeLimit ||
+                wireBytes + Math.ceil(metadata.bytes / 3) * 4 + 65536 > documentRequestLimit(model)))
+                mode = "pages";
+            const readRepresentation = async () => {
+                const response = boundary.resolve === undefined ? { status: "attachment_unavailable" } :
+                    await boundary.resolve({ reference, mode, sessionId: boundary.sessionId,
+                        inputId: boundary.inputId, originInputId: message.clientInputId,
+                        model, signal: boundary.signal });
+                if (["attachment_revoked", "attachment_unavailable", "attachment_text_held"].includes(response.status))
+                    return response;
+                const parsed = representationSchema.safeParse(response);
+                if (!parsed.success) throw new DocumentInputError("attachment_representation_invalid");
+                const representation = parsed.data;
+                if (representation.originalSha256 !== reference.source.originalSha256)
+                    throw new DocumentInputError("attachment_document_integrity");
+                const representationDigest = createHash("sha256")
+                    .update(JSON.stringify({ content: representation.content, coverage: representation.coverage,
+                        ...(representation.nextCursor === undefined ? {} : { nextCursor: representation.nextCursor }) })).digest("hex");
+                if (representationDigest !== representation.payloadSha256)
+                    throw new DocumentInputError("attachment_representation_integrity");
+                return representation;
+            };
+            let representation = await readRepresentation();
+            if (representation.status === "ready" && mode === "native-document" &&
+                (wireBytes + Buffer.byteLength(JSON.stringify(representation.content)) + 65536 > documentRequestLimit(model) ||
+                (model.contextWindow > 0 && inputTokens + representation.estimatedTokens + model.maxTokens > model.contextWindow))) {
+                // This is another local representation selection, before any provider dispatch, not a model retry.
+                mode = "pages";
+                representation = await readRepresentation();
+            }
+            if (representation.status === "attachment_revoked" || representation.status === "attachment_unavailable") {
+                content.push({ type: "text", text: JSON.stringify({ type: representation.status,
+                    attachmentId: reference.source.attachmentId, grantId: reference.source.grantId }),
+                    documentSource: reference.source });
+                continue;
+            }
+            if (representation.status === "attachment_text_held") throw new DocumentInputError(representation.status);
+            const pages = representation.coverage.pages;
+            if (pages.length === 0 || new Set(pages.map(page => page.page)).size !== pages.length ||
+                (metadata.pageCount !== undefined && metadata.pageCount !== representation.coverage.totalPages) ||
+                pages.some(page => page.page > representation.coverage.totalPages) ||
+                (pages.length < representation.coverage.totalPages && !representation.nextCursor))
+                throw new DocumentInputError("attachment_coverage_incomplete");
+            // Ready means the complete representation was prepared; coverage is only this bounded delivery.
+            if (mode === "ocr" && pages.some(page => !["ocr-text", "verified-blank"].includes(page.representation)))
+                throw new DocumentInputError("attachment_ocr_incomplete");
+            let images = 0;
+            let documents = 0;
+            let textBytes = 0;
+            const blocks = representation.content.map(part => {
+                if (part.type === "text") textBytes += Buffer.byteLength(part.text);
+                if (part.type === "document") {
+                    documents++;
+                    const document = checkedDocument(part);
+                    if (mode !== "native-document" || document.provenance.grantId !== reference.source.grantId ||
+                        document.provenance.attachmentId !== reference.source.attachmentId ||
+                        document.provenance.originalSha256 !== reference.source.originalSha256)
+                        throw new DocumentInputError("attachment_document_route");
+                }
+                if (part.type === "image") {
+                    images++;
+                    const bytes = Buffer.from(part.data, "base64");
+                    if (mode === "ocr" || bytes.length > 4194304 || bytes.toString("base64") !== part.data ||
+                        (!bytes.subarray(0, 8).equals(Buffer.from([137,80,78,71,13,10,26,10])) &&
+                            !(bytes[0] === 255 && bytes[1] === 216)))
+                        throw new DocumentInputError("attachment_image_invalid");
+                }
+                return { ...part, documentSource: reference.source };
+            });
+            if (images > 2 || (mode === "native-document" ? documents !== 1 : documents !== 0))
+                throw new DocumentInputError("attachment_document_route");
+            if (textBytes > 49152) throw new DocumentInputError("attachment_text_limit");
+            if (mode !== "native-document" &&
+                (images !== pages.filter(page => page.representation === "rendered-image").length ||
+                (!representation.content.some(part => part.type === "text" && part.text.trim() !== "") && pages.some(page => ["native-text", "ocr-text"].includes(page.representation)))))
+                throw new DocumentInputError("attachment_coverage_incomplete");
+            nativePages += mode === "native-document" ? representation.coverage.totalPages : 0;
+            const coverage = { type: "attachment_coverage", source: reference.source,
+                representationSha256: representation.representationSha256, grantRevision: representation.grantRevision,
+                coverage: representation.coverage, nextCursor: representation.nextCursor };
+            content.push({ type: "text", text: JSON.stringify(coverage), documentSource: reference.source }, ...blocks);
+            wireBytes += Buffer.byteLength(JSON.stringify(blocks));
+            inputTokens += representation.estimatedTokens;
+            if (wireBytes + 65536 > documentRequestLimit(model) ||
+                (model.contextWindow > 0 && inputTokens + model.maxTokens > model.contextWindow))
+                throw new DocumentInputError("attachment_request_limit");
+        }
+        result.push({ ...message, content });
+    }
+    return result;
+}

package/host/omo-check/patches/attachments-293/document-content.types.txt

@@ -0,0 +1,91 @@
+/** UNRELEASED declarations appended to pi-ai/dist/types.d.ts, in its type scope. */
+export interface DocumentProvenance {
+    readonly attachmentId: string;
+    readonly grantId: string;
+    readonly originalSha256: string;
+}
+export interface DocumentContent {
+    readonly type: "document";
+    readonly mimeType: "application/pdf";
+    readonly name: string;
+    readonly data: string;
+    readonly provenance: DocumentProvenance;
+}
+export interface DocumentReference {
+    readonly type: "document";
+    readonly mimeType: "application/pdf";
+    readonly name: string;
+    readonly source: DocumentProvenance & { readonly kind: "attachment" };
+}
+export interface DocumentAttachment {
+    readonly id: string;
+    readonly grantId: string;
+    readonly name: string;
+    readonly format: "html" | "md" | "txt" | "pdf";
+    readonly bytes: number;
+    readonly sha256: string;
+    readonly readMode: "text" | "native-document" | "pages" | "ocr";
+    readonly pageCount?: number;
+}
+export interface DocumentCoverage {
+    readonly totalPages: number;
+    readonly pages: readonly {
+        readonly page: number;
+        readonly representation: "native-text" | "rendered-image" | "ocr-text" | "verified-blank";
+    }[];
+}
+export interface DocumentRepresentation {
+    readonly status: "ready";
+    readonly originalSha256: string;
+    readonly representationSha256: string;
+    /** Delivery content/coverage/cursor digest; separate from the reader's full representation digest. */
+    readonly payloadSha256: string;
+    readonly grantRevision: number;
+    readonly estimatedTokens: number;
+    readonly content: readonly (TextContent | ImageContent | DocumentContent)[];
+    readonly coverage: DocumentCoverage;
+    readonly nextCursor?: string;
+}
+/** The caller MUST authorize against the current managed binding and grant before releasing bytes. */
+export type DocumentResolver = (request: {
+    readonly reference: DocumentReference;
+    readonly mode: "native-document" | "pages" | "ocr";
+    readonly sessionId: string;
+    readonly inputId: string | undefined;
+    readonly originInputId: string;
+    readonly model: Model<Api>;
+    readonly signal: AbortSignal | undefined;
+}) => Promise<DocumentRepresentation | {
+    readonly status: "attachment_revoked" | "attachment_unavailable" | "attachment_text_held";
+}>;
+export declare class DocumentInputError extends Error {
+    readonly code: string;
+    constructor(code: string);
+}
+export declare const documentReferenceSchema: import("zod").ZodType<DocumentReference>;
+export declare const documentContentSchema: import("zod").ZodType<DocumentContent>;
+export declare const documentAttachmentSchema: import("zod").ZodType<DocumentAttachment>;
+export declare function checkedDocument(value: unknown): DocumentContent;
+export declare function normalizeDocumentInput(input: {
+    readonly clientInputId?: string;
+    readonly documents?: readonly unknown[];
+    readonly attachments?: readonly unknown[];
+}, references?: boolean): {
+    readonly documents?: DocumentReference[];
+    readonly attachments?: DocumentAttachment[];
+    readonly origin?: "owner-attachment";
+};
+export declare function documentInputMetadata(input?: {
+    readonly documents?: readonly unknown[];
+    readonly attachments?: readonly DocumentAttachment[];
+}): { readonly origin?: "owner-attachment"; readonly attachments?: readonly DocumentAttachment[] };
+export declare function documentReadMode(model: Model<Api>): "native-document" | "pages" | "ocr";
+export declare function hasDocuments(messages: readonly Message[]): boolean;
+export declare function documentRequestLimit(model: Model<Api>): number;
+export declare function assertDocumentRequestBudget(payload: unknown, model: Model<Api>, messages: readonly Message[]): void;
+export declare function resolveDocumentMessages(messages: readonly Message[], model: Model<Api>, boundary: {
+    readonly resolve?: DocumentResolver;
+    readonly sessionId: string;
+    readonly inputId?: string;
+    readonly signal?: AbortSignal;
+}): Promise<Message[]>;