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

package/host/omo-check/patches/attachments-293/omo-5.1.51-documents.patch

@@ -0,0 +1,831 @@
+--- a/@code-yeongyu/senpi/dist/core/agent-session.d.ts
++++ b/@code-yeongyu/senpi/dist/core/agent-session.d.ts
+@@ -1,1 +1,2 @@
+-/**
++import type { DocumentContent, DocumentReference, DocumentAttachment, DocumentResolver } from "@earendil-works/pi-ai";
++/**
+@@ -556,1 +557,3 @@
+-export interface QueuedInputOptions extends ClientMessageIdentity {
++export interface QueuedInputOptions extends ClientMessageIdentity {
++    documents?: (DocumentContent | DocumentReference)[];
++    attachments?: DocumentAttachment[];
+@@ -569,1 +572,3 @@
+-export interface PromptOptions extends ClientMessageIdentity {
++export interface PromptOptions extends ClientMessageIdentity {
++    documents?: (DocumentContent | DocumentReference)[];
++    attachments?: DocumentAttachment[];
+@@ -1508,1 +1513,2 @@
+-    prompt(text: string, options?: PromptOptions): Promise<void>;
++    setDocumentResolver(resolve: DocumentResolver | undefined): void;
++    prompt(text: string, options?: PromptOptions): Promise<void>;
+--- a/@code-yeongyu/senpi/dist/core/agent-session.js
++++ b/@code-yeongyu/senpi/dist/core/agent-session.js
+@@ -1,1 +1,2 @@
+-/**
++import { normalizeDocumentInput, documentInputMetadata, resolveDocumentMessages } from "@earendil-works/pi-ai";
++/**
+@@ -1482,1 +1483,5 @@
+-            const transformed = this._requestShapeRecovery.apply(previousTransformContext ? await previousTransformContext(messages, signal) : messages);
++            const prepared = this._requestShapeRecovery.apply(previousTransformContext ? await previousTransformContext(messages, signal) : messages);
++            const transformed = await resolveDocumentMessages(prepared, this.model, {
++                resolve: this._documentResolver, sessionId: this.sessionManager.getSessionId(),
++                inputId: messages.findLast(message => message.role === "user")?.clientInputId, signal,
++            });
+@@ -4154,1 +4159,13 @@
+-    async prompt(text, options) {
++    setDocumentResolver(resolve) {
++        this._documentResolver = resolve;
++        this._extensionRunner.resolveDocuments = (messages) => resolveDocumentMessages(messages,
++            this._activeCompactionModel ?? this.model, { resolve: this._documentResolver,
++                sessionId: this.sessionManager.getSessionId(),
++                inputId: this.messages.findLast(message => message.role === "user")?.clientInputId,
++                signal: this._compactionAbortController?.signal });
++    }
++    async prompt(text, options) {
++        if (options?.documents !== undefined) {
++            const normalized = normalizeDocumentInput(options, options.documents.every(document => document.source !== undefined));
++            options = { ...options, ...normalized, expandPromptTemplates: false };
++        }
+@@ -4272,1 +4289,2 @@
+-            ...((options?.expandPromptTemplates ?? true) ? { prepare: true } : {}),
++            documents: options?.documents, attachments: options?.attachments, clientInputId: options?.clientInputId,
++            ...((options?.expandPromptTemplates ?? true) ? { prepare: true } : {}),
+@@ -4280,2 +4298,3 @@
+-            inputId: options.clientMessageId ?? `prompt-${crypto.randomUUID()}`,
+-            revision: 0,
++            inputId: options.clientMessageId ?? `prompt-${crypto.randomUUID()}`,
++            documents: options.documents, attachments: options.attachments, clientInputId: options.clientInputId,
++            revision: 0,
+@@ -4478,1 +4497,1 @@
+-                hasImages: (options?.images?.length ?? 0) > 0,
++                hasImages: (options?.images?.length ?? 0) > 0 || (options?.documents?.length ?? 0) > 0,
+@@ -4712,3 +4731,5 @@
+-            const userMessage = {
+-                role: "user",
+-                content: userContent,
++            userContent.push(...(options?.documents ?? []));
++            const userMessage = {
++                ...documentInputMetadata(options),
++                role: "user",
++                content: userContent,
+@@ -5013,1 +5034,4 @@
+-    async _admitQueuedInput(text, images, behavior, options) {
++    async _admitQueuedInput(text, images, behavior, options) {
++        if (options?.documents !== undefined) {
++            options = { ...options, ...normalizeDocumentInput(options, options.documents.every(document => document.source !== undefined)), expandPromptTemplates: false };
++        }
+@@ -5166,1 +5190,1 @@
+-        await this._pendingInputs.admit({ clientMessageId, text: input.text, ...(input.images ? { images: input.images } : {}), mode: input.mode }, (queuedId) => this._enqueuePreparedInput({ ...sourced, queuedId }));
++        await this._pendingInputs.admit({ clientMessageId, text: input.text, ...(input.images ? { images: input.images } : {}), documents: input.documents, attachments: input.attachments, mode: input.mode }, (queuedId) => this._enqueuePreparedInput({ ...sourced, queuedId }));
+@@ -5183,2 +5207,4 @@
+-            images: input.images,
+-            mode: input.mode,
++            images: input.images,
++            documents: input.documents,
++            attachments: input.attachments,
++            mode: input.mode,
+@@ -5200,4 +5226,6 @@
+-            ...(input.images ?? []),
+-        ];
+-        const message = {
+-            role: "user",
++            ...(input.images ?? []),
++            ...(input.documents ?? []),
++        ];
++        const message = {
++            ...documentInputMetadata(input),
++            role: "user",
+@@ -6015,2 +6043,2 @@
+-            const hasImages = (input.images?.length ?? 0) > 0;
+-            if (this._isExtensionCommandText(input.text))
++            const hasImages = (input.images?.length ?? 0) > 0 || (input.documents?.length ?? 0) > 0;
++            if (!input.documents?.length && this._isExtensionCommandText(input.text))
+@@ -6046,3 +6074,4 @@
+-                role: "custom",
+-                customType: HELD_INPUT_ENTRY,
+-                content: input.images === undefined ? text : [{ type: "text", text }, ...input.images],
++                role: input.documents?.length ? "user" : "custom",
++                ...documentInputMetadata(input), ...clientMessageIdentity(input),
++                customType: HELD_INPUT_ENTRY,
++                content: [{ type: "text", text }, ...(input.images ?? []), ...(input.documents ?? [])],
+@@ -9634,1 +9663,2 @@
+             setThinkingLevel: (level) => this.setThinkingLevel(level),
++            setDocumentResolver: (resolve) => this.setDocumentResolver(resolve),
+--- a/@code-yeongyu/senpi/dist/core/compaction/compaction.js
++++ b/@code-yeongyu/senpi/dist/core/compaction/compaction.js
+@@ -289,3 +289,6 @@
+-        else if (block.type === "image") {
+-            chars += ESTIMATED_IMAGE_CHARS;
+-        }
++        else if (block.type === "image") {
++            chars += ESTIMATED_IMAGE_CHARS;
++        }
++        else if (block.type === "document") {
++            chars += block.data ? block.data.length * 4 : JSON.stringify(block).length + ESTIMATED_IMAGE_CHARS;
++        }
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/anthropic-subscription/cold-seed-images.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/anthropic-subscription/cold-seed-images.js
+@@ -63,1 +63,1 @@
+-            if (!isRecord(entry) || entry.type !== "image")
++            if (!isRecord(entry) || entry.type !== "image" || entry.documentSource !== undefined)
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/anthropic-subscription/stream.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/anthropic-subscription/stream.js
+@@ -1,1 +1,2 @@
+-import { createAssistantMessageDiagnostic, createAssistantMessageEventStream, } from "@earendil-works/pi-ai";
++import { assertDocumentRequestBudget, hasDocuments, DocumentInputError } from "@earendil-works/pi-ai";
++import { createAssistantMessageDiagnostic, createAssistantMessageEventStream, } from "@earendil-works/pi-ai";
+@@ -79,1 +80,4 @@
+-            let oneShotCacheTtl;
++            let oneShotCacheTtl;
++            let documentPromptBlocks;
++            let documentQueryStarted = false;
++            const carriesDocuments = hasDocuments(context.messages);
+@@ -105,1 +109,7 @@
+-                return replacement === undefined ? queryOptions : replacement;
++                const preparedOptions = replacement === undefined ? queryOptions : replacement;
++                if (carriesDocuments) {
++                    documentPromptBlocks = dedupeUltraworkBlocks(buildPromptBlocks(context, resolvedTools.customToolNameToSdk,
++                        toolWatchNote, oneShotCacheTtl === undefined ? {} : { cacheBreakpoint: oneShotCacheTtl })).blocks;
++                    assertDocumentRequestBudget({ options: preparedOptions, prompt: documentPromptBlocks }, model, context.messages);
++                }
++                return preparedOptions;
+@@ -118,1 +128,1 @@
+-            const useResidentSession = options?.streamKind === "main" && providerSettings.resumeMode !== "off" && options.sessionId !== undefined;
++            const useResidentSession = !carriesDocuments && options?.streamKind === "main" && providerSettings.resumeMode !== "off" && options.sessionId !== undefined;
+@@ -154,2 +164,6 @@
+-                    prompt: buildDeferredPromptStream(() => dedupeUltraworkBlocks(buildPromptBlocks(context, resolvedTools.customToolNameToSdk, toolWatchNote, oneShotCacheTtl === undefined ? {} : { cacheBreakpoint: oneShotCacheTtl })).blocks),
+-                    query: getSdkBoundary().query,
++                    prompt: buildDeferredPromptStream(() => documentPromptBlocks ?? dedupeUltraworkBlocks(buildPromptBlocks(context, resolvedTools.customToolNameToSdk, toolWatchNote, oneShotCacheTtl === undefined ? {} : { cacheBreakpoint: oneShotCacheTtl })).blocks),
++                    query: (request) => {
++                        if (carriesDocuments && documentQueryStarted) throw new DocumentInputError("attachment_delivery_uncertain");
++                        documentQueryStarted = true;
++                        return getSdkBoundary().query(request);
++                    },
+@@ -269,1 +283,1 @@
+-            output.errorMessage = withAuthGuidance(error, errorMessage(error), claudeCodeRun);
++            output.errorMessage = (hasDocuments(context.messages) ? "senpi:no-turn-retry:" : "") + withAuthGuidance(error, errorMessage(error), claudeCodeRun);
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/openai-remote-convert.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/openai-remote-convert.js
+@@ -1,1 +1,2 @@
+-import { protectedRemoteInput } from "./task-intent.js";
++import { checkedDocument, DocumentInputError } from "@earendil-works/pi-ai";
++import { protectedRemoteInput } from "./task-intent.js";
+@@ -35,2 +36,8 @@
+-        return {
+-            type: "input_image",
++        if (block.type === "document") {
++            if (block.source) throw new DocumentInputError("attachment_unresolved_reference");
++            const document = checkedDocument({ type: block.type, name: block.name, mimeType: block.mimeType,
++                data: block.data, provenance: block.provenance });
++            return { type: "input_file", filename: document.name, file_data: `data:application/pdf;base64,${document.data}` };
++        }
++        return {
++            type: "input_image",
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/retained-message-safety.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/retained-message-safety.js
+@@ -1,1 +1,2 @@
+-function isRecord(value) {
++import { documentReferenceSchema } from "@earendil-works/pi-ai";
++function isRecord(value) {
+@@ -147,1 +148,4 @@
+-                if (!isFiniteNumber(value.timestamp) || !hasTextOnlyContent(value.content, true))
++                if (!isFiniteNumber(value.timestamp) || !(hasTextOnlyContent(value.content, true) ||
++                    (value.origin === "owner-attachment" && typeof value.clientInputId === "string" &&
++                    Array.isArray(value.content) && value.content.every(block =>
++                        (block.type === "text" && typeof block.text === "string") || documentReferenceSchema.safeParse(block).success))))
+--- a/@code-yeongyu/senpi/dist/core/extensions/runner.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/runner.js
+@@ -386,1 +386,5 @@
+         this.runtime.setThinkingLevel = actions.setThinkingLevel;
++        const pendingDocumentResolver = this.runtime.pendingDocumentResolver;
++        this.runtime.setDocumentResolver = actions.setDocumentResolver;
++        if (pendingDocumentResolver !== undefined)
++            actions.setDocumentResolver(pendingDocumentResolver);
+@@ -1876,1 +1880,2 @@
+-        const transformedMessages = await this.emitContext(messages, excludeExtensionPath, "projection");
++        const projectedMessages = await this.emitContext(messages, excludeExtensionPath, "projection");
++        const transformedMessages = this.resolveDocuments ? await this.resolveDocuments(projectedMessages) : projectedMessages;
+--- a/@code-yeongyu/senpi/dist/core/extensions/loader.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/loader.js
+@@ -199,1 +199,2 @@
+         setThinkingLevel: notInitialized,
++        setDocumentResolver: (resolve) => { runtime.pendingDocumentResolver = resolve; },
+@@ -604,1 +605,10 @@
+         },
++        setDocumentResolver(resolve) {
++            assertActive();
++            if (resolve !== undefined && typeof resolve !== "function")
++                throw new TypeError("document_resolver_invalid");
++            if (runtime.documentResolverOwner !== undefined && runtime.documentResolverOwner !== extension.path)
++                throw new Error("document_resolver_already_registered");
++            runtime.documentResolverOwner = resolve === undefined ? undefined : extension.path;
++            applyRuntimeChange(() => runtime.setDocumentResolver(resolve === undefined ? undefined : ownedBy(extension, resolve)));
++        },
+--- a/@code-yeongyu/senpi/dist/core/extensions/types.d.ts
++++ b/@code-yeongyu/senpi/dist/core/extensions/types.d.ts
+@@ -2222,1 +2222,6 @@
+     setThinkingLevel(level: ThinkingLevel): void;
++    /**
++     * Register this session's grant-bound document resolver. The engine calls it at provider request time.
++     * One extension owns it per session; another extension gets document_resolver_already_registered.
++     */
++    setDocumentResolver(resolve: import("@earendil-works/pi-ai").DocumentResolver | undefined): void;
+--- a/@code-yeongyu/senpi/dist/core/held-inputs.js
++++ b/@code-yeongyu/senpi/dist/core/held-inputs.js
+@@ -1,1 +1,2 @@
+-export const HELD_INPUT_ENTRY = "held-input";
++import { documentReferenceSchema, documentAttachmentSchema } from "@earendil-works/pi-ai";
++export const HELD_INPUT_ENTRY = "held-input";
+@@ -23,1 +24,3 @@
+-        (data.prepare === undefined || data.prepare === true) &&
++        (data.prepare === undefined || data.prepare === true) &&
++        (data.documents === undefined || (Array.isArray(data.documents) && data.documents.every(value => documentReferenceSchema.safeParse(value).success))) &&
++        (data.attachments === undefined || (Array.isArray(data.attachments) && data.attachments.every(value => documentAttachmentSchema.safeParse(value).success))) &&
+--- a/@code-yeongyu/senpi/dist/core/messages.js
++++ b/@code-yeongyu/senpi/dist/core/messages.js
+@@ -222,2 +222,2 @@
+-            if (block.type !== "image")
+-                return;
++            if (block.type !== "image" || block.documentSource !== undefined)
++                return;
+--- a/@code-yeongyu/senpi/dist/core/pending-input-session.js
++++ b/@code-yeongyu/senpi/dist/core/pending-input-session.js
+@@ -193,1 +193,1 @@
+-    return sha256(JSON.stringify([input.mode, input.text, images]));
++    return sha256(JSON.stringify([input.mode, input.text, images, input.documents, input.attachments]));
+--- a/@code-yeongyu/senpi/dist/core/session-manager.d.ts
++++ b/@code-yeongyu/senpi/dist/core/session-manager.d.ts
+@@ -147,1 +147,3 @@
+-export interface CompactionEntry<T = unknown> extends SessionEntryBase {
++export interface CompactionEntry<T = unknown> extends SessionEntryBase {
++    /** Grant references from summarized owner inputs, never inline document bytes. */
++    documentHistory?: UserMessage[];
+--- a/@code-yeongyu/senpi/dist/core/session-manager.js
++++ b/@code-yeongyu/senpi/dist/core/session-manager.js
+@@ -387,1 +387,2 @@
+-        return entry.systemMessage ? [withContextEntryId(entry.id, entry.systemMessage), summary] : [summary];
++        const documents = (entry.documentHistory ?? []).map(message => withContextEntryId(entry.id, message));
++        return entry.systemMessage ? [withContextEntryId(entry.id, entry.systemMessage), summary, ...documents] : [summary, ...documents];
+@@ -1493,2 +1494,16 @@
+-    appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromHook, usage) {
+-        const timestamp = new Date().toISOString();
++    appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromHook, usage) {
++        const branch = this.getBranch();
++        const firstKept = branch.findIndex(entry => entry.id === firstKeptEntryId);
++        const documentHistory = new Map();
++        for (const entry of branch.slice(0, firstKept < 0 ? branch.length : firstKept)) {
++            for (const message of sessionEntryToContextMessages(entry)) {
++                if (message.role !== "user" || message.origin !== "owner-attachment" || !Array.isArray(message.content)) continue;
++                const content = message.content.filter(block => block.type === "document");
++                if (content.length) documentHistory.set(message.clientInputId, {
++                    role: "user", origin: "owner-attachment", clientInputId: message.clientInputId,
++                    clientMessageId: message.clientMessageId, clientTurnId: message.clientTurnId,
++                    attachments: message.attachments, content, timestamp: message.timestamp,
++                });
++            }
++        }
++        const timestamp = new Date().toISOString();
+@@ -1498,2 +1513,3 @@
+-            type: "compaction",
+-            id,
++            type: "compaction",
++            ...(documentHistory.size ? { documentHistory: [...documentHistory.values()] } : {}),
++            id,
+--- a/@code-yeongyu/senpi/dist/modes/rpc/client-admission-record.js
++++ b/@code-yeongyu/senpi/dist/modes/rpc/client-admission-record.js
+@@ -1,2 +1,3 @@
+-import { createHash } from "node:crypto";
+-import { z } from "zod";
++import { documentReferenceSchema, documentAttachmentSchema } from "@earendil-works/pi-ai";
++import { createHash } from "node:crypto";
++import { z } from "zod";
+@@ -30,1 +31,3 @@
+-    mode: z.enum(["steer", "followUp"]),
++    documents: z.array(documentReferenceSchema).max(4).optional(),
++    attachments: z.array(documentAttachmentSchema).max(4).optional(),
++    mode: z.enum(["steer", "followUp"]),
+@@ -62,1 +65,3 @@
+-        clientTurnId: command.clientTurnId,
++        clientTurnId: command.clientTurnId,
++        documents: command.documents,
++        attachments: command.attachments,
+--- a/@code-yeongyu/senpi/dist/modes/rpc/client-input-handler.js
++++ b/@code-yeongyu/senpi/dist/modes/rpc/client-input-handler.js
+@@ -1,2 +1,3 @@
+-import { AgentBusyError } from "../../core/agent-busy-error.js";
+-import { clientMessageIdentity } from "../../core/client-message-identity.js";
++import { normalizeDocumentInput } from "@earendil-works/pi-ai";
++import { AgentBusyError } from "../../core/agent-busy-error.js";
++import { clientMessageIdentity } from "../../core/client-message-identity.js";
+@@ -11,1 +12,1 @@
+-        command = { ...command, ...clientMessageIdentity(command) };
++        command = { ...command, ...clientMessageIdentity(command), ...normalizeDocumentInput(command) };
+@@ -43,1 +44,3 @@
+-                    images: command.images,
++                    images: command.images,
++                    documents: command.documents,
++                    attachments: command.attachments,
+@@ -92,2 +95,4 @@
+-                        enqueueOrder: command.enqueueOrder,
+-                        source: "rpc",
++                        enqueueOrder: command.enqueueOrder,
++                        documents: command.documents,
++                        attachments: command.attachments,
++                        source: "rpc",
+--- a/@code-yeongyu/senpi/dist/modes/rpc/connection-handler.js
++++ b/@code-yeongyu/senpi/dist/modes/rpc/connection-handler.js
+@@ -899,1 +899,2 @@
+-                                "multi_session",
++                                "multi_session",
++                                "document_content_v1",
+--- a/@code-yeongyu/senpi/dist/modes/rpc/host-capabilities.js
++++ b/@code-yeongyu/senpi/dist/modes/rpc/host-capabilities.js
+@@ -23,1 +23,2 @@
+             "snapshot_cursor",
++            "document_content_v1",
+--- a/@code-yeongyu/senpi/dist/modes/rpc/rpc-input-validation.js
++++ b/@code-yeongyu/senpi/dist/modes/rpc/rpc-input-validation.js
+@@ -1,2 +1,3 @@
+-import { isBrowserEngine } from "../../core/browser-engine.js";
+-import { clientMessageIdentitySchema } from "../../core/client-message-identity.js";
++import { normalizeDocumentInput, documentReferenceSchema } from "@earendil-works/pi-ai";
++import { isBrowserEngine } from "../../core/browser-engine.js";
++import { clientMessageIdentitySchema } from "../../core/client-message-identity.js";
+@@ -17,1 +18,1 @@
+-function validContent(content) {
++function validContent(content, allowDocuments = false) {
+@@ -27,1 +28,3 @@
+-                : value.type === "image" && typeof value.data === "string" && typeof value.mimeType === "string";
++                : value.type === "document"
++                    ? allowDocuments && documentReferenceSchema.safeParse(value).success
++                    : value.type === "image" && typeof value.data === "string" && typeof value.mimeType === "string";
+@@ -47,1 +50,8 @@
+-            return ["user", "assistant", "tool"].includes(item.role) && validContent(item.content);
++            if (!["user", "assistant", "tool"].includes(item.role) || !validContent(item.content, item.role === "user")) return false;
++            const documents = Array.isArray(item.content) ? item.content.filter(block => block.type === "document") : [];
++            if (documents.length) {
++                if (item.origin !== "owner-attachment" || !clientMessageIdentitySchema.safeParse(item).success) return false;
++                try { normalizeDocumentInput({ clientInputId: item.clientInputId, documents, attachments: item.attachments }, true); }
++                catch (error) { if (error instanceof Error) return false; throw error; }
++            }
++            return true;
+@@ -76,2 +86,7 @@
+-    const value = command;
+-    if ((value.type === "prompt" || value.type === "steer" || value.type === "follow_up") &&
++    const value = command;
++    if (["prompt", "steer", "follow_up"].includes(value.type) &&
++        (value.documents !== undefined || value.attachments !== undefined)) {
++        try { normalizeDocumentInput(value); }
++        catch (error) { return error instanceof Error ? error.message : "attachment_document_invalid"; }
++    }
++    if ((value.type === "prompt" || value.type === "steer" || value.type === "follow_up") &&
+--- a/@code-yeongyu/senpi/dist/modes/rpc/rpc-session-command-types.d.ts
++++ b/@code-yeongyu/senpi/dist/modes/rpc/rpc-session-command-types.d.ts
+@@ -2,1 +2,1 @@
+-import type { ImageContent } from "@earendil-works/pi-ai";
++import type { ImageContent, DocumentContent, DocumentAttachment } from "@earendil-works/pi-ai";
+@@ -13,1 +13,3 @@
+-    images?: ImageContent[];
++    images?: ImageContent[];
++    documents?: DocumentContent[];
++    attachments?: DocumentAttachment[];
+@@ -63,1 +65,3 @@
+-    images?: ImageContent[];
++    images?: ImageContent[];
++    documents?: DocumentContent[];
++    attachments?: DocumentAttachment[];
+@@ -71,1 +75,3 @@
+-    images?: ImageContent[];
++    images?: ImageContent[];
++    documents?: DocumentContent[];
++    attachments?: DocumentAttachment[];
+--- a/@earendil-works/pi-ai/dist/api/anthropic-messages.js
++++ b/@earendil-works/pi-ai/dist/api/anthropic-messages.js
+@@ -1,1 +1,2 @@
+-import Anthropic from "@anthropic-ai/sdk";
++import { checkedDocument, documentReadMode, DocumentInputError, assertDocumentRequestBudget, hasDocuments } from "../types.js";
++import Anthropic from "@anthropic-ai/sdk";
+@@ -1055,1 +1056,2 @@
+-                    logAnthropicRequestShape(model, body);
++                    assertDocumentRequestBudget({ ...body, stream: true }, model, normalizedContext.messages);
++                    logAnthropicRequestShape(model, body);
+@@ -1123,1 +1125,1 @@
+-                    maxRetries: options?.maxRetries,
++                    maxRetries: hasDocuments(normalizedContext.messages) ? 0 : options?.maxRetries,
+@@ -1492,1 +1494,1 @@
+-            output.errorMessage = withGitHubCopilotFailureNote(formatGitHubCopilotToolLimitError(output, errorMessage), model.provider, error);
++            output.errorMessage = (hasDocuments(normalizedContext.messages) ? "senpi:no-turn-retry:" : "") + withGitHubCopilotFailureNote(formatGitHubCopilotToolLimitError(output, errorMessage), model.provider, error);
+@@ -2158,1 +2160,6 @@
+-                    else if (isVideoMimeType(item.mimeType)) {
++                    else if (item.type === "document") {
++                        if (documentReadMode(model) !== "native-document") throw new DocumentInputError("attachment_document_route");
++                        const document = checkedDocument({ type: item.type, mimeType: item.mimeType, name: item.name, data: item.data, provenance: item.provenance });
++                        return { type: "document", title: document.name, source: { type: "base64", media_type: "application/pdf", data: document.data } };
++                    }
++                    else if (isVideoMimeType(item.mimeType)) {
+--- a/@earendil-works/pi-ai/dist/api/openai-codex-responses.js
++++ b/@earendil-works/pi-ai/dist/api/openai-codex-responses.js
+@@ -1,1 +1,2 @@
+-import { readProviderDiagnostic } from "../provider-diagnostic.js";
++import { assertDocumentRequestBudget, hasDocuments } from "../types.js";
++import { readProviderDiagnostic } from "../provider-diagnostic.js";
+@@ -183,1 +184,2 @@
+-            const bodyJson = JSON.stringify(body);
++            assertDocumentRequestBudget(body, model, normalizedContext.messages);
++            const bodyJson = JSON.stringify(body);
+@@ -186,1 +188,1 @@
+-            const transport = options?.transport || "auto";
++            const transport = hasDocuments(normalizedContext.messages) ? "sse" : options?.transport || "auto";
+@@ -262,1 +264,1 @@
+-            const maxRetries = options?.maxRetries ?? DEFAULT_MAX_RETRIES;
++            const maxRetries = hasDocuments(normalizedContext.messages) ? 0 : options?.maxRetries ?? DEFAULT_MAX_RETRIES;
+@@ -369,1 +371,1 @@
+-            output.errorMessage = formatProviderError(normalizeProviderError(error));
++            output.errorMessage = (hasDocuments(normalizedContext.messages) ? "senpi:no-turn-retry:" : "") + formatProviderError(normalizeProviderError(error));
+--- a/@earendil-works/pi-ai/dist/api/openai-responses-shared.js
++++ b/@earendil-works/pi-ai/dist/api/openai-responses-shared.js
+@@ -1,1 +1,2 @@
+-import { CONTEXT_PROVENANCE_FIELD, contextProvenanceFingerprint, getContextProvenance, } from "../context-provenance.js";
++import { checkedDocument, documentReadMode, DocumentInputError } from "../types.js";
++import { CONTEXT_PROVENANCE_FIELD, contextProvenanceFingerprint, getContextProvenance, } from "../context-provenance.js";
+@@ -273,2 +274,7 @@
+-                    return {
+-                        type: "input_image",
++                    if (item.type === "document") {
++                        if (documentReadMode(model) !== "native-document") throw new DocumentInputError("attachment_document_route");
++                        const document = checkedDocument({ type: item.type, mimeType: item.mimeType, name: item.name, data: item.data, provenance: item.provenance });
++                        return { type: "input_file", filename: document.name, file_data: `data:application/pdf;base64,${document.data}` };
++                    }
++                    return {
++                        type: "input_image",
+--- a/@earendil-works/pi-ai/dist/api/openai-responses.js
++++ b/@earendil-works/pi-ai/dist/api/openai-responses.js
+@@ -1,1 +1,2 @@
+-import OpenAI from "openai";
++import { assertDocumentRequestBudget, hasDocuments } from "../types.js";
++import OpenAI from "openai";
+@@ -203,1 +204,2 @@
+-            const transport = options?.transport ?? "sse";
++            assertDocumentRequestBudget(params, model, normalizedContext.messages);
++            const transport = hasDocuments(normalizedContext.messages) ? "sse" : options?.transport ?? "sse";
+@@ -268,1 +270,1 @@
+-                maxRetries: options?.maxRetries,
++                maxRetries: hasDocuments(normalizedContext.messages) ? 0 : options?.maxRetries,
+@@ -307,1 +309,1 @@
+-            output.errorMessage = withGitHubCopilotFailureNote(formatGitHubCopilotToolLimitError(output, formatOpenAIResponsesError(error, model.provider)), model.provider, error);
++            output.errorMessage = (hasDocuments(normalizedContext.messages) ? "senpi:no-turn-retry:" : "") + withGitHubCopilotFailureNote(formatGitHubCopilotToolLimitError(output, formatOpenAIResponsesError(error, model.provider)), model.provider, error);
+--- a/@earendil-works/pi-ai/dist/types.d.ts
++++ b/@earendil-works/pi-ai/dist/types.d.ts
+@@ -521,4 +521,6 @@
+-    content: string | (TextContent | ImageContent)[];
+-    timestamp: number;
+-}
+-/** A durable Responses configuration change projected into the message stream. */
++    content: string | (TextContent | ImageContent | DocumentContent | DocumentReference)[];
++    origin?: "owner-attachment";
++    attachments?: DocumentAttachment[];
++    timestamp: number;
++}
++/** A durable Responses configuration change projected into the message stream. */
+@@ -1254,1 +1256,93 @@
+-//# sourceMappingURL=types.d.ts.map
++//# sourceMappingURL=types.d.ts.map
++/** 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[]>;
++
+--- a/@earendil-works/pi-ai/dist/types.js
++++ b/@earendil-works/pi-ai/dist/types.js
+@@ -5,1 +5,235 @@
+-//# sourceMappingURL=types.js.map
+
++//# sourceMappingURL=types.js.map
++// 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;
++}
+--- a/@earendil-works/pi-ai/dist/utils/estimate.js
++++ b/@earendil-works/pi-ai/dist/utils/estimate.js
+@@ -24,1 +24,3 @@
+-        chars += block.type === "text" ? block.text.length : ESTIMATED_IMAGE_CHARS;
++        chars += block.type === "text" ? block.text.length : block.type === "document"
++            ? (block.data ? block.data.length * 4 : JSON.stringify(block).length + ESTIMATED_IMAGE_CHARS)
++            : ESTIMATED_IMAGE_CHARS;