@modelprofile.com/flexharness 9.7.0 → 9.9.0

package/dist_ts_document/index.js

@@ -39,6 +39,165 @@ export class DocumentPageLimitError extends Error {
         this.documentIndex = details.documentIndex;
     }
 }
+/*
+ * The image limits below stay within what the providers publish (read 2026-09-28):
+ * - Anthropic, https://platform.claude.com/docs/en/build-with-claude/vision: at most 8000x8000 px per
+ *   image; in a request with more than 20 images at most 2000 px per side; at most 10 MB per image
+ *   (base64) on the Claude API and 5 MB (base64) on Amazon Bedrock and Google Cloud; JPEG, PNG, GIF
+ *   and WebP, of an animation only the first frame.
+ * - OpenAI, https://developers.openai.com/api/docs/guides/images-vision: PNG, JPEG, WebP and
+ *   non-animated GIF; up to 512 MB payload and 1500 images per request; the page names no size per
+ *   image. Images are scaled down on the provider's side.
+ */
+/**
+ * The longest edge, in pixels, of an image sent to the model when a request names none: Anthropic's
+ * 2000 pixels per side for a request with more than 20 images, the tightest of the limits above.
+ */
+export const DEFAULT_MAX_IMAGE_EDGE = 2000;
+/**
+ * The most bytes of one image sent to the model: 5 000 000 characters once base64-encoded, within
+ * Anthropic's 5 MB per image on Amazon Bedrock and Google Cloud, the smallest of the limits above.
+ */
+export const MAX_IMAGE_BYTES = 3_750_000;
+/**
+ * The most pixels (width times height) of one image or TIFF page that is decoded: an A3 page scanned
+ * at 600 dpi has about 70 million. The images come from mail and uploads, so a larger one is refused
+ * from its header, before it is decoded, instead of being given sharp's own limit of about 268 million.
+ */
+export const MAX_IMAGE_PIXELS = 100_000_000;
+/** An image document this component does not read; the model was not called. */
+export class DocumentFormatError extends Error {
+    /** Zero-based position, in the request's documents (the PDFs first, then the images), of the image. */
+    documentIndex;
+    /** The format the image was read as, or null when it could not be read at all. */
+    format;
+    reason;
+    constructor(message, details, options) {
+        super(message, options);
+        this.name = 'DocumentFormatError';
+        this.documentIndex = details.documentIndex;
+        this.format = details.format;
+        this.reason = details.reason;
+    }
+}
+/** The formats sent as they are when they need no scaling and no turning. */
+const AS_IS_MEDIA_TYPES = new Map([
+    ['jpeg', 'image/jpeg'],
+    ['png', 'image/png'],
+    ['webp', 'image/webp'],
+]);
+/** The formats read at all: sharp's names, HEIF only with AV1 compression (AVIF). */
+const READABLE_IMAGE_FORMATS = new Set(['jpeg', 'png', 'webp', 'gif', 'tiff', 'heif']);
+/** The formats whose further pages are frames of an animation, not pages of a document. */
+const ANIMATED_FORMATS = new Set(['gif', 'webp']);
+/** The one load of the optional peer dependency sharp; a failed load is forgotten. */
+let sharpLoad = null;
+function loadSharp() {
+    if (!sharpLoad) {
+        const load = plugins.importSharp().catch((error) => {
+            if (sharpLoad === load) {
+                sharpLoad = null;
+            }
+            throw new Error('Image documents need the optional peer dependency sharp.', { cause: error });
+        });
+        sharpLoad = load;
+    }
+    return sharpLoad;
+}
+/** Refuses a page with more pixels than `MAX_IMAGE_PIXELS`, from what its header says. */
+function checkPixels(metadata, documentIndex, format) {
+    const pixels = (metadata.width ?? 0) * (metadata.height ?? 0);
+    if (pixels > MAX_IMAGE_PIXELS) {
+        throw new DocumentFormatError(`The image has ${metadata.width}x${metadata.height} pixels, more than the ${MAX_IMAGE_PIXELS} read here.`, { documentIndex, format, reason: 'too_many_pixels' });
+    }
+}
+/** What an image document is, read from its header without decoding it. */
+async function readImage(sharp, image, documentIndex) {
+    let metadata;
+    try {
+        metadata = await sharp(image).metadata();
+    }
+    catch (error) {
+        throw new DocumentFormatError('The image could not be read.', { documentIndex, format: null, reason: 'unreadable' }, { cause: error });
+    }
+    const format = metadata.format ?? null;
+    if (format === 'heif' && metadata.compression !== 'av1') {
+        throw new DocumentFormatError('The image is HEIC, which cannot be decoded here; send it as JPEG.', { documentIndex, format, reason: 'heic' });
+    }
+    if (!format || !READABLE_IMAGE_FORMATS.has(format)) {
+        throw new DocumentFormatError(`The image is ${format ?? 'of an unknown format'}; images are read as JPEG, PNG, WebP, GIF, TIFF or AVIF.`, { documentIndex, format, reason: 'unsupported' });
+    }
+    const pages = Math.max(metadata.pages ?? 1, 1);
+    if (ANIMATED_FORMATS.has(format) && pages > 1) {
+        throw new DocumentFormatError(`The image is an animated ${format === 'gif' ? 'GIF' : 'WebP'} of ${pages} frames; its frames are no pages, so it is not read.`, { documentIndex, format, reason: 'animated' });
+    }
+    // sharp reports the top-level images of a HEIF container as its pages (libvips heifload, n-pages);
+    // only a TIFF's pages are pages of a document
+    if (format !== 'tiff' && pages > 1) {
+        throw new DocumentFormatError(`The image is an AVIF holding ${pages} images; which of them is the document is not known, so it is not read.`, { documentIndex, format, reason: 'multiple_images' });
+    }
+    checkPixels(metadata, documentIndex, format);
+    return { metadata, pageCount: format === 'tiff' ? pages : 1 };
+}
+/** One page of an image document, upright, scaled down and encoded; a page that cannot be decoded is refused. */
+async function imagePage(sharp, image, page, format, photo, maxEdge, documentIndex) {
+    const pipeline = () => sharp(image, { page, limitInputPixels: MAX_IMAGE_PIXELS })
+        .autoOrient()
+        .resize({ width: maxEdge, height: maxEdge, fit: 'inside', withoutEnlargement: true });
+    // JPEG has no transparency: a transparent background becomes white, not black
+    const jpeg = async (quality) => ({
+        data: await pipeline().flatten({ background: '#ffffff' }).jpeg({ quality }).toBuffer(),
+        mediaType: 'image/jpeg',
+    });
+    let encoded;
+    try {
+        if (page > 0) {
+            // each TIFF page has its own size; the first was checked with the document
+            checkPixels(await sharp(image, { page }).metadata(), documentIndex, format);
+        }
+        encoded = photo ? await jpeg(90) : { data: await pipeline().png().toBuffer(), mediaType: 'image/png' };
+        // too large: a photo tries a lower quality, any other a JPEG at the higher one first
+        for (const quality of photo ? [75] : [90, 75]) {
+            if (encoded.data.byteLength <= MAX_IMAGE_BYTES) {
+                break;
+            }
+            encoded = await jpeg(quality);
+        }
+    }
+    catch (error) {
+        if (error instanceof DocumentFormatError) {
+            throw error;
+        }
+        throw new DocumentFormatError(pageLabel(page, 'could not be decoded.'), { documentIndex, format, reason: 'unreadable' }, { cause: error });
+    }
+    if (encoded.data.byteLength > MAX_IMAGE_BYTES) {
+        throw new DocumentFormatError(pageLabel(page, `stays larger than ${MAX_IMAGE_BYTES} bytes after scaling to ${maxEdge} pixels.`), { documentIndex, format, reason: 'too_large' });
+    }
+    // a Buffer is a Uint8Array view of a pooled ArrayBuffer; send exactly its bytes
+    return { data: new Uint8Array(encoded.data), mediaType: encoded.mediaType };
+}
+/** "The image …" for a one-page image, "Page n of the image …" for a TIFF page after the first. */
+const pageLabel = (page, predicate) => page === 0 ? `The image ${predicate}` : `Page ${page + 1} of the image ${predicate}`;
+/** An image document's pages as they are sent: as they are where that fits, else upright and scaled down. */
+async function imagePages(sharp, image, metadata, pageCount, maxEdge, documentIndex, abortSignal) {
+    const format = metadata.format;
+    const asIs = AS_IS_MEDIA_TYPES.get(format);
+    if (asIs
+        && pageCount === 1
+        && (metadata.orientation ?? 1) === 1
+        && (metadata.width ?? Infinity) <= maxEdge
+        && (metadata.height ?? Infinity) <= maxEdge
+        && image.byteLength <= MAX_IMAGE_BYTES) {
+        return [{ data: image, mediaType: asIs }];
+    }
+    const photo = format === 'jpeg' || format === 'heif';
+    const pages = [];
+    for (let page = 0; page < pageCount; page++) {
+        abortSignal?.throwIfAborted();
+        pages.push(await imagePage(sharp, image, page, format, photo, maxEdge, documentIndex));
+    }
+    return pages;
+}
 const DEFAULT_OCR_SYSTEM_MESSAGE = 'You are a precise OCR engine. Extract text faithfully and do not summarize.';
 const DEFAULT_OCR_USER_MESSAGE = 'Extract all readable text from this PDF. Preserve page order, line breaks, table structure, and obvious headings. Return only the extracted text.';
 /** The model-based PDF OCR recipe formerly provided by SmartOCR. */
@@ -68,41 +227,64 @@ export async function analyzeDocumentsWithUsage(options) {
     if (maxPages !== undefined && (!Number.isSafeInteger(maxPages) || maxPages < 1)) {
         throw new RangeError('maxPages must be a positive whole number.');
     }
+    const maxImageEdge = options.maxImageEdge ?? DEFAULT_MAX_IMAGE_EDGE;
+    if (!Number.isSafeInteger(maxImageEdge) || maxImageEdge < 1) {
+        throw new RangeError('maxImageEdge must be a positive whole number.');
+    }
     const abortSignal = options.abortSignal;
     abortSignal?.throwIfAborted();
-    const imagePages = [];
-    for (const [index, doc] of options.pdfDocuments.entries()) {
+    const pdfDocuments = options.pdfDocuments ?? [];
+    const imageDocuments = options.imageDocuments ?? [];
+    const documentCount = pdfDocuments.length + imageDocuments.length;
+    const limitDetails = (index, renderedPages, limit) => ({
+        renderedPages,
+        maxPages: limit,
+        documentCount,
+        documentIndex: index,
+        allDocumentsRendered: index === documentCount - 1,
+    });
+    const modelPages = [];
+    // every rendered page counts against maxPages, also a PDF page that renders empty and is not sent
+    let countedPages = 0;
+    for (const [index, doc] of pdfDocuments.entries()) {
         const pdf = await ensureSmartpdf();
         abortSignal?.throwIfAborted();
-        const limitDetails = (renderedPages, limit) => ({
-            renderedPages,
-            maxPages: limit,
-            documentCount: options.pdfDocuments.length,
-            documentIndex: index,
-            allDocumentsRendered: index === options.pdfDocuments.length - 1,
-        });
         // SmartPDF limits one document, so each render gets the pages the request has left. It takes
         // no limit of zero: when the earlier documents used up the request's pages, the smallest limit
         // lets the document's page count be known, and a document of one page renders and is refused below.
-        const renderMaxPages = maxPages === undefined ? undefined : Math.max(maxPages - imagePages.length, 1);
+        const renderMaxPages = maxPages === undefined ? undefined : Math.max(maxPages - countedPages, 1);
         let pages;
         try {
             pages = await pdf.convertPDFToPngBytes(doc, { signal: abortSignal, maxPages: renderMaxPages });
         }
         catch (error) {
             if (maxPages !== undefined && error instanceof plugins.smartpdf.SmartPdfPageLimitError) {
-                throw new DocumentPageLimitError(limitDetails(imagePages.length + error.pageCount, maxPages), { cause: error });
+                throw new DocumentPageLimitError(limitDetails(index, countedPages + error.pageCount, maxPages), { cause: error });
             }
             throw error;
         }
         abortSignal?.throwIfAborted();
-        imagePages.push(...pages);
-        if (maxPages !== undefined && imagePages.length > maxPages) {
-            throw new DocumentPageLimitError(limitDetails(imagePages.length, maxPages));
+        countedPages += pages.length;
+        modelPages.push(...pages.filter((page) => page && page.length > 0).map((page) => ({ data: page, mediaType: 'image/png' })));
+        if (maxPages !== undefined && countedPages > maxPages) {
+            throw new DocumentPageLimitError(limitDetails(index, countedPages, maxPages));
         }
     }
-    // Filter out empty buffers
-    const validPages = imagePages.filter(page => page && page.length > 0);
+    if (imageDocuments.length) {
+        const sharp = await loadSharp();
+        for (const [imageIndex, image] of imageDocuments.entries()) {
+            abortSignal?.throwIfAborted();
+            const index = pdfDocuments.length + imageIndex;
+            const { metadata, pageCount } = await readImage(sharp, image, index);
+            // an image's pages are known from its header, so an image over the limit is not decoded
+            if (maxPages !== undefined && countedPages + pageCount > maxPages) {
+                throw new DocumentPageLimitError(limitDetails(index, countedPages + pageCount, maxPages));
+            }
+            countedPages += pageCount;
+            modelPages.push(...await imagePages(sharp, image, metadata, pageCount, maxImageEdge, index, abortSignal));
+        }
+        abortSignal?.throwIfAborted();
+    }
     const onUsage = options.onUsage;
     const modelCalls = onUsage ? new plugins.AgentModelCallUsageRecorder(options.model, onUsage) : null;
     // Each attempt, retries included, is one model call: it starts in the middleware, which also
@@ -130,10 +312,10 @@ export async function analyzeDocumentsWithUsage(options) {
             role: 'user',
             content: [
                 { type: 'text', text: options.userMessage },
-                ...validPages.map(page => ({
+                ...modelPages.map(page => ({
                     type: 'file',
-                    data: page,
-                    mediaType: 'image/png',
+                    data: page.data,
+                    mediaType: page.mediaType,
                 })),
             ],
         },
@@ -172,7 +354,7 @@ export async function analyzeDocumentsWithUsage(options) {
             cacheReadTokens: usage.inputTokenDetails.cacheReadTokens ?? 0,
             cacheWriteTokens: usage.inputTokenDetails.cacheWriteTokens ?? 0,
         },
-        pageCount: validPages.length,
+        pageCount: modelPages.length,
     };
 }
 export async function stopSmartpdf() {
@@ -193,4 +375,4 @@ export async function stopSmartpdf() {
     }
     await instance.stop();
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../ts_document/index.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../ts_document/index.ts"],"names":[],"mappings":"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"}

package/dist_ts_document/plugins.d.ts

@@ -5,3 +5,38 @@ export { generateText, wrapLanguageModel, smartpdf, AgentModelCallUsageRecorder
 export type { ModelMessage } from 'ai';
 export type { TSmartAiLanguageModel, TSmartAiProviderOptions } from '@modelprofile.com/flexharness-models';
 export type { TAgentModelCallUsageReporter } from '@modelprofile.com/flexharness-agent';
+/** What sharp reads from an image's header (`sharp.Metadata`, the fields used here). */
+export interface IImageMetadata {
+    format?: string;
+    compression?: string;
+    pages?: number;
+    orientation?: number;
+    width?: number;
+    height?: number;
+}
+/** A sharp pipeline, the operations used here. */
+export interface IImagePipeline {
+    metadata(): Promise<IImageMetadata>;
+    autoOrient(): IImagePipeline;
+    resize(options: {
+        width: number;
+        height: number;
+        fit: 'inside';
+        withoutEnlargement: boolean;
+    }): IImagePipeline;
+    flatten(options: {
+        background: string;
+    }): IImagePipeline;
+    jpeg(options: {
+        quality: number;
+    }): IImagePipeline;
+    png(): IImagePipeline;
+    toBuffer(): Promise<Uint8Array>;
+}
+/** Opens an image (a page of it) as a pipeline, as `sharp(input, options)` does. */
+export type TImageReader = (input: Uint8Array, options?: {
+    page?: number;
+    limitInputPixels?: number;
+}) => IImagePipeline;
+/** Loads sharp and hands out its reader. */
+export declare const importSharp: () => Promise<TImageReader>;

package/dist_ts_document/plugins.js

@@ -2,4 +2,9 @@ import { generateText, wrapLanguageModel } from 'ai';
 import * as smartpdf from '@push.rocks/smartpdf';
 import { AgentModelCallUsageRecorder } from '@modelprofile.com/flexharness-agent';
 export { generateText, wrapLanguageModel, smartpdf, AgentModelCallUsageRecorder };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX2RvY3VtZW50L3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxpQkFBaUIsRUFBRSxNQUFNLElBQUksQ0FBQztBQUNyRCxPQUFPLEtBQUssUUFBUSxNQUFNLHNCQUFzQixDQUFDO0FBQ2pELE9BQU8sRUFBRSwyQkFBMkIsRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBQ2xGLE9BQU8sRUFBRSxZQUFZLEVBQUUsaUJBQWlCLEVBQUUsUUFBUSxFQUFFLDJCQUEyQixFQUFFLENBQUMifQ==
+/** Loads sharp and hands out its reader. */
+export const importSharp = async () => {
+    const sharp = (await import('sharp')).default;
+    return (input, options) => sharp(input, options);
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX2RvY3VtZW50L3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxpQkFBaUIsRUFBRSxNQUFNLElBQUksQ0FBQztBQUNyRCxPQUFPLEtBQUssUUFBUSxNQUFNLHNCQUFzQixDQUFDO0FBQ2pELE9BQU8sRUFBRSwyQkFBMkIsRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBQ2xGLE9BQU8sRUFBRSxZQUFZLEVBQUUsaUJBQWlCLEVBQUUsUUFBUSxFQUFFLDJCQUEyQixFQUFFLENBQUM7QUFrQ2xGLDRDQUE0QztBQUM1QyxNQUFNLENBQUMsTUFBTSxXQUFXLEdBQUcsS0FBSyxJQUEyQixFQUFFO0lBQzNELE1BQU0sS0FBSyxHQUFHLENBQUMsTUFBTSxNQUFNLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUM7SUFDOUMsT0FBTyxDQUFDLEtBQUssRUFBRSxPQUFPLEVBQUUsRUFBRSxDQUFDLEtBQUssQ0FBQyxLQUFLLEVBQUUsT0FBTyxDQUFDLENBQUM7QUFDbkQsQ0FBQyxDQUFDIn0=

package/package.json

@@ -2,7 +2,7 @@
   "author": "Task Venture Capital GmbH",
   "license": "MIT",
   "name": "@modelprofile.com/flexharness",
-  "version": "9.7.0",
+  "version": "9.9.0",
   "type": "module",
   "description": "Managed agent sessions with tools, MCP, chat, OCR, documents and browser control through focused subpath imports.",
   "main": "./dist_ts/index.js",
@@ -62,8 +62,8 @@
     }
   },
   "dependencies": {
-    "@modelprofile.com/flexharness-agent": "9.7.0",
-    "@modelprofile.com/flexharness-models": "9.7.0",
+    "@modelprofile.com/flexharness-agent": "9.9.0",
+    "@modelprofile.com/flexharness-models": "9.9.0",
     "@push.rocks/smartrequest": "^5.0.1",
     "ai": "^7.0.107",
     "zod": "^4.4.1"
@@ -71,6 +71,7 @@
   "peerDependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@push.rocks/smartpdf": "^6.0.0",
+    "sharp": "^0.35.3",
     "puppeteer": "^24.42.0",
     "ink": "^6.8.0",
     "ink-text-input": "^6.0.0",
@@ -85,6 +86,9 @@
     "@push.rocks/smartpdf": {
       "optional": true
     },
+    "sharp": {
+      "optional": true
+    },
     "puppeteer": {
       "optional": true
     },

package/readme.md

@@ -62,7 +62,7 @@ or provider SDKs.
 | `/chat/cli` | Ink/React terminal chat | `ink ink-text-input react`; TypeScript: `@types/react` |
 | `/chat/web` | Lit `flexchat-window`, `flexchat-message`, `flexchat-input` | `lit` |
 | `/kvm` | Browser control, terminal framing and OCR observation | `puppeteer` |
-| `/documents` | PDF processing and `extractTextFromPdf` | `@push.rocks/smartpdf` |
+| `/documents` | PDF and image documents, `extractTextFromPdf` | `@push.rocks/smartpdf`; for image documents `sharp` |
 | `/mcp` | MCP clients and AI SDK tool conversion | `@modelcontextprotocol/sdk` |
 | `/migration` | Existing versioned harness migrations | None |
 

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@modelprofile.com/flexharness',
-  version: '9.7.0',
+  version: '9.9.0',
   description: 'The FlexHarness toolbox source repository and shared dependency catalog.'
 }

package/ts/classes.flexharness.ts

@@ -87,6 +87,7 @@ import type {
   IFlexSchedulePromptOptions,
   IFlexScopeSnapshot,
   IFlexSession,
+  IFlexSessionPermissionPolicyContext,
   IFlexSessionActivity,
   IFlexSessionGeneration,
   IFlexSessionGenerationCohortEntry,
@@ -155,6 +156,7 @@ import {
 } from './utils.prompt.js';
 import {
   maxSubagentNameBytes,
+  normalizeAllowedTools,
   normalizeAgentSessionPolicy,
   normalizeBuiltInTools,
   normalizeSlashCommands,
@@ -399,6 +401,9 @@ interface IActiveRun {
   reservedAssistantMessage?: IFlexMessage;
   modelResolution?: IFlexResolvedModel;
   subagents: ReadonlyMap<string, Readonly<IFlexSubagentDefinition>>;
+  allowedTools?: readonly string[];
+  agentAllowedTools?: readonly string[];
+  permissionPolicy?: IFlexResolvedSessionConfiguration<unknown>['permissionPolicy'];
   delegatedRunAdmissionOwner?: IDelegatedRunAdmissionOwner;
   delegatedRunAdmissionClose?: Promise<void>;
   completion: Promise<IFlexPromptResult>;
@@ -517,6 +522,8 @@ interface IActiveSlashCommandListing {
 interface IResolvedSessionConfiguration<TScope> {
   subagents: ReadonlyMap<string, Readonly<IFlexSubagentDefinition>>;
   slashCommands: ReadonlyMap<string, TRegisteredSlashCommand<TScope>>;
+  allowedTools?: readonly string[];
+  permissionPolicy?: IFlexResolvedSessionConfiguration<TScope>['permissionPolicy'];
 }
 
 interface ISessionConfigurationOwner<TScope> {
@@ -2046,11 +2053,16 @@ export class FlexHarness<TScope = unknown> {
           || Array.isArray(configuration)
           || ![Object.prototype, null].includes(Object.getPrototypeOf(configuration))
           || Reflect.ownKeys(configuration).some((name) =>
-            typeof name !== 'string' || !['subagents', 'slashCommands'].includes(name))
+            typeof name !== 'string' || !['subagents', 'slashCommands', 'allowedTools', 'permissionPolicy'].includes(name))
         ) throw new FlexHarnessValidationError('Resolved session configuration is invalid.');
+        if (configuration.permissionPolicy !== undefined && typeof configuration.permissionPolicy !== 'function') {
+          throw new FlexHarnessValidationError('Resolved session permissionPolicy must be a function.');
+        }
         return Object.freeze({
           subagents: normalizeSubagents(configuration.subagents),
           slashCommands: normalizeSlashCommands(configuration.slashCommands),
+          allowedTools: normalizeAllowedTools(configuration.allowedTools),
+          permissionPolicy: configuration.permissionPolicy,
         });
       }).catch((error: unknown) => {
         if (this.sessionConfigurations.get(key)?.completion === completion) {
@@ -5182,13 +5194,22 @@ export class FlexHarness<TScope = unknown> {
     signal: AbortSignal,
   ): Promise<plugins.IAgentGenerationLease> {
     signal.throwIfAborted();
-    run.subagents = (await this.resolveSessionConfiguration(
+    const configuration = await this.resolveSessionConfiguration(
       run.scopeId,
       run.scope as TScope,
       run.state,
       run.stored,
       signal,
-    )).subagents;
+    );
+    run.subagents = configuration.subagents;
+    run.allowedTools = configuration.allowedTools;
+    run.permissionPolicy = configuration.permissionPolicy as IActiveRun['permissionPolicy'];
+    const agent = run.stored.session.agent;
+    if (agent !== undefined) {
+      const definition = configuration.subagents.get(agent);
+      if (!definition) throw new FlexHarnessValidationError(`Subagent "${agent}" is disabled.`);
+      run.agentAllowedTools = definition.allowedTools;
+    }
     await this.prepareRunReversion(run, signal);
     run.phase = 'running';
     const queued = run.stored.outstandingPromptsById.get(run.queueId);
@@ -5299,9 +5320,16 @@ export class FlexHarness<TScope = unknown> {
         const providedTools = toolHandle?.tools;
         const combinedTools: Record<string, unknown> = { ...(providedTools ?? {}) };
         Object.assign(combinedTools, this.createBuiltInTools(run));
-        tools = Object.keys(combinedTools).length > 0
+        const globalNames = run.allowedTools === undefined ? undefined : new Set(run.allowedTools);
+        const agentNames = run.agentAllowedTools === undefined ? undefined : new Set(run.agentAllowedTools);
+        const admittedTools = globalNames === undefined && agentNames === undefined
+          ? combinedTools
+          : Object.fromEntries(Object.entries(combinedTools).filter(([name]) =>
+              (globalNames === undefined || globalNames.has(name))
+              && (agentNames === undefined || agentNames.has(name))));
+        tools = Object.keys(admittedTools).length > 0
           ? wrapToolSet(
-              combinedTools as TFlexAgentToolSet,
+              admittedTools as TFlexAgentToolSet,
               this.toolOutputLimits,
               (toolError) => this.projectExternalError(run, toolError, 'toolExecution'),
             )
@@ -7758,8 +7786,10 @@ export class FlexHarness<TScope = unknown> {
     if (state.activeRuns.get(run.sessionId) !== run || run.callbacksClosed) {
       throw new FlexHarnessPermissionStateError(`Run "${run.runId}" no longer accepts permission requests.`);
     }
-    if (input.rememberKey && run.stored.rememberedPermissionKeys.has(input.rememberKey)) return;
-    const request: IFlexPermissionRequest = {
+    if (!run.permissionPolicy && input.rememberKey && run.stored.rememberedPermissionKeys.has(input.rememberKey)) {
+      return;
+    }
+    const candidate: IFlexPermissionRequest = {
       permissionId: plugins.crypto.randomUUID(),
       scopeId: run.scopeId,
       sessionId: run.sessionId,
@@ -7776,6 +7806,33 @@ export class FlexHarness<TScope = unknown> {
           : { metadata: normalizeJsonValue(input.metadata, this.toolOutputLimits) }),
       createdAt: new Date().toISOString(),
     };
+    const policyDecision = run.permissionPolicy
+      ? await this.decideSessionPermissionPolicy(state, run, candidate)
+      : 'inherit';
+    if (policyDecision === 'allow' || policyDecision === 'deny') {
+      this.emitEvent(run.scopeId, run.stored.session, {
+        type: 'permission.resolved',
+        runId: run.runId,
+        request: publicSnapshot(candidate),
+        decision: policyDecision === 'allow' ? 'once' : 'reject',
+        origin: 'policy',
+      });
+      if (policyDecision === 'deny') {
+        const rejection = this.trustInternalError(
+          new FlexHarnessPermissionRejectedError(candidate.permissionId),
+        );
+        this.abortRunInternally(run, rejection);
+        throw rejection;
+      }
+      return;
+    }
+    if (policyDecision === 'inherit'
+      && input.rememberKey && run.stored.rememberedPermissionKeys.has(input.rememberKey)) return;
+    const request: IFlexPermissionRequest = { ...candidate };
+    if (policyDecision === 'ask') {
+      delete request.rememberKey;
+      request.requiresExplicitResponse = true;
+    }
     let resolvePermission!: () => void;
     let rejectPermission!: (error: unknown) => void;
     const promise = new Promise<void>((resolve, reject) => {
@@ -7823,6 +7880,70 @@ export class FlexHarness<TScope = unknown> {
     return promise;
   }
 
+  private async decideSessionPermissionPolicy(
+    state: IStorageState,
+    run: IActiveRun,
+    request: IFlexPermissionRequest,
+  ): Promise<'inherit' | 'allow' | 'ask' | 'deny'> {
+    const policy = run.permissionPolicy!;
+    const signal = run.controller.signal;
+    const context: Readonly<IFlexSessionPermissionPolicyContext<unknown>> = Object.freeze({
+      scopeId: run.scopeId,
+      scope: run.scope,
+      storageKey: state.storageKey,
+      sessionId: run.sessionId,
+      ...requireSessionGeneration(run.stored.session),
+      runId: run.runId,
+      configurationRef: run.stored.session.configurationRef!,
+      ...(run.stored.session.agent === undefined ? {} : { agent: run.stored.session.agent }),
+      request: publicSnapshot(request),
+      signal,
+    });
+    let onAbort!: () => void;
+    const aborted = new Promise<never>((_resolve, reject) => {
+      onAbort = () => reject(signal.reason ?? this.trustInternalError(new FlexHarnessAbortError()));
+    });
+    signal.addEventListener('abort', onAbort, { once: true });
+    if (signal.aborted) onAbort();
+    let decision: unknown;
+    try {
+      decision = await Promise.race([
+        Promise.resolve().then(() => {
+          signal.throwIfAborted();
+          return policy(context);
+        }),
+        aborted,
+      ]);
+      if (!['inherit', 'allow', 'ask', 'deny'].includes(decision as string)) {
+        throw new FlexHarnessValidationError('Session permissionPolicy returned an invalid decision.');
+      }
+    } catch (error) {
+      if (signal.aborted) throw signal.reason;
+      const projected = this.projectExternalError(run, error, 'permissionPolicy');
+      this.abortRunInternally(run, projected);
+      throw projected;
+    } finally {
+      signal.removeEventListener('abort', onAbort);
+    }
+    signal.throwIfAborted();
+    const generation = requireSessionGeneration(run.stored.session);
+    if (
+      state.lifecycle !== 'active'
+      || state.activeRuns.get(run.sessionId) !== run
+      || state.sessions.get(run.sessionId) !== run.stored
+      || run.callbacksClosed
+      || generation.sessionGenerationId !== request.sessionGenerationId
+      || generation.sessionGenerationSequence !== request.sessionGenerationSequence
+    ) {
+      const ownershipError = this.trustInternalError(new FlexHarnessAbortError(
+        'Permission policy lost its exact run ownership.',
+      ));
+      this.abortRunInternally(run, ownershipError);
+      throw ownershipError;
+    }
+    return decision as 'inherit' | 'allow' | 'ask' | 'deny';
+  }
+
   private async applyPermissionResponse(
     state: IStorageState,
     pending: IPendingPermission,