@skaile/transform-proxy 0.2.5 → 0.2.6

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 0.2.6
+
+- omp extension: while anon is on, in error or required, images are not sent. The extension sets omp's `images.blockImages` as a runtime override (never persisted), so omp replaces every image in the request, history included, with `Image reading is disabled.`; `/anon off` drops the override. Before, a screenshot from a browser tool made the proxy refuse every later request of the session with 400 `unsupported_content` ("Anthropic image content cannot be transformed"). `/anon status` lists `images: not sent`. An omp without the settings registry gets one warning, and the proxy keeps refusing images.
+
 ## 0.2.5
 
 - omp extension: the status is `🟢A` (on), `🔴A` (off), `🟠A` (error) instead of `A`, `Ⱥ`, `A!`. The crossed A was not legible in common terminal fonts, and omp strips ANSI colour from extension statuses, so the colour comes from an emoji.

package/README.md

@@ -112,9 +112,10 @@ statusLine:
   - Providers on a wire the proxy does not rewrite (Bedrock, Vertex, Gemini, agent bridges, providers without a base URL) are routed too, so the proxy refuses their requests: the setup fails closed. `/anon status` lists them as refused.
   - The session's active model is rebound to the re-routed one, so the next request already uses the new base URL. A rebind that fails is an activation failure: `/anon on` rolls the routes back, saves nothing and stays off. When anon is required, or a later turn's rebind fails while anon is on, the status shows `🟠A`.
 - While anon is on or in error, a `before_provider_request` handler checks every model request: a request whose model does not target the proxy gets its payload replaced with an empty object, so no conversation text leaves, and an error notice names the model. omp has no hook that cancels a provider request, and a throwing handler is only logged, so this replacement is the block.
+- While anon is on or in error, images are not sent: the extension sets omp's `images.blockImages` in omp's in-memory runtime settings layer, and omp replaces every image in the request, history included, with the note `Image reading is disabled.`. The proxy cannot anonymize images and refuses every request that carries one (400 `unsupported_content`), and omp resends the whole history each turn, so a single screenshot would otherwise block the session. `/anon off` drops the override, so your own `images.blockImages` setting applies again; the override is never written to `config.yml`. An omp without this settings API gets a warning instead, and the proxy keeps refusing images.
 - The proxy session follows the root omp session: on `/new`, `/resume`, `/fork` (`session_switch`) and on a root `session_start` with a new session id, every provider is re-routed with the new `x-skaile-transform-session`. The proxy keeps the old session's state in memory until it exits; no request carries that id again. A `session_start` of a headless `print` session (how omp runs subagents) keeps the parent's id, so subagents share its pseudonyms.
 - `/anon off` restores the original base URLs and headers.
-- `/anon status` shows the state, the proxy URL and its source, the pipeline, the session id, and the routed and refused providers.
+- `/anon status` shows the state, the proxy URL and its source, the pipeline, the session id, whether images are blocked, and the routed and refused providers.
 - The enabled flag is saved in `skaile-transform-proxy.json` in omp's agent dir (`~/.omp/agent`; `SKAILE_TRANSFORM_PROXY_OMP_STATE` overrides the path) and re-applied when a session starts.
 - `SKAILE_TRANSFORM_PROXY_MODE=required` (set by a skaile session in required mode) turns routing on at session start and refuses `/anon off`.
 

package/dist/omp/index.d.mts

@@ -59,6 +59,10 @@ interface OmpSessionActions {
   setModel(model: OmpModel): Promise<boolean>;
 }
 interface OmpExtensionApi extends OmpSessionActions {
+  /** omp's package exports; `settings` is the scope its setting handles read and override. */
+  readonly pi?: {
+    readonly settings?: unknown;
+  };
   registerCommand(name: string, options: {
     description?: string;
     getArgumentCompletions?: (argumentPrefix: string) => OmpAutocompleteItem[] | null;
@@ -84,6 +88,14 @@ interface ProxyChildProcess {
   on(event: 'exit', listener: (code: number | null, signal: NodeJS.Signals | null) => void): unknown;
   on(event: 'error', listener: (err: Error) => void): unknown;
 }
+/**
+ * Image sending of the host. The proxy cannot anonymize images and refuses every request that
+ * carries one; omp resends the whole history each turn, so one screenshot would block the session.
+ */
+interface ImageSending {
+  /** `true` stops images from reaching the provider, `false` restores the user's setting. Resolves `false` when the host offers no way to do it; that answer is final. */
+  setBlocked(blocked: boolean): Promise<boolean>;
+}
 interface AnonControllerDeps {
   readonly env: Readonly<Record<string, string | undefined>>;
   readonly home: string;
@@ -95,6 +107,8 @@ interface AnonControllerDeps {
   readonly cliPath?: string;
   /** How long the child may take to print `listening <url>`. Default: 60 s (transform modules may load ML models). */
   readonly listenTimeoutMs?: number;
+  /** Blocked while anon is wanted (on, error or required), released by `/anon off`. Default: none. */
+  readonly images?: ImageSending;
 }
 interface AnonController {
   readonly required: boolean;
@@ -133,4 +147,6 @@ export declare function defaultStatePath(env: Readonly<Record<string, string | u
 /** Registers the `/anon` command and the event handlers on one session's extension API. */
 export declare function registerAnonExtension(pi: OmpExtensionApi, controller: AnonController): void;
 export default function anonExtension(pi: OmpExtensionApi): void;
-export type { AnonController, AnonControllerDeps, OmpAutocompleteItem, OmpContext, OmpEventName, OmpExtensionApi, OmpModel, OmpModelRegistry, OmpNotifyType, OmpProviderOverride, OmpSessionActions, OmpUi, ProxyChildProcess, ProxySpawnOptions };
+/** Blocks images through a runtime override of omp's `images.blockImages`, which strips them from every request, history included. */
+export declare function ompImageSending(pi: OmpExtensionApi, load?: () => Promise<unknown>): ImageSending;
+export type { AnonController, AnonControllerDeps, ImageSending, OmpAutocompleteItem, OmpContext, OmpEventName, OmpExtensionApi, OmpModel, OmpModelRegistry, OmpNotifyType, OmpProviderOverride, OmpSessionActions, OmpUi, ProxyChildProcess, ProxySpawnOptions };

package/dist/omp/index.mjs

@@ -62,6 +62,10 @@ function createAnonController(deps) {
 	const registries = /* @__PURE__ */ new WeakMap();
 	let wanted = required;
 	let enabled = false;
+	/** Whether this controller holds the image block; only then does it release it. */
+	let imagesBlocked = false;
+	/** The host answered that it cannot block images; asked once, warned once. */
+	let imagesUnsupported = false;
 	let endpoint;
 	let starting;
 	let sessionId;
@@ -265,6 +269,24 @@ function createAnonController(deps) {
 	function stateLabel() {
 		return enabled ? "on" : wanted ? "error" : "off";
 	}
+	/** Follows `wanted`: images are blocked while model requests must go through the proxy. */
+	async function syncImages(ctx) {
+		const images = deps.images;
+		if (images === void 0 || imagesUnsupported || imagesBlocked === wanted) return;
+		let done;
+		try {
+			done = await images.setBlocked(wanted);
+		} catch (err) {
+			ctx.ui.notify(`anon: could not ${wanted ? "stop" : "restore"} image sending: ${errorMessage(err)}`, "warning");
+			return;
+		}
+		if (done) {
+			imagesBlocked = wanted;
+			return;
+		}
+		imagesUnsupported = true;
+		if (wanted) ctx.ui.notify("anon: this omp cannot stop image sending; the proxy refuses every request that carries an image", "warning");
+	}
 	/**
 	* Compact status for omp's main status line. omp strips ANSI colour from extension statuses and
 	* paints them in its accent colour, so the colour comes from an emoji: green on, red off, orange error.
@@ -282,6 +304,7 @@ function createAnonController(deps) {
 			lines.push(`pipeline: ${endpoint.pipeline ?? "the proxy default"}`);
 		}
 		if (sessionId !== void 0) lines.push(`session: ${sessionId}`);
+		if (imagesBlocked) lines.push("images: not sent (omp images.blockImages)");
 		const routed = [...state.routed.keys()].sort();
 		const refused = routed.flatMap((provider) => {
 			const reason = refusalReason(apis.get(provider), state.originals.get(provider));
@@ -308,6 +331,7 @@ function createAnonController(deps) {
 				ctx.ui.notify(refusalHint(), "error");
 			}
 		}
+		await syncImages(ctx);
 		showStatus(ctx);
 	}
 	return {
@@ -350,6 +374,7 @@ function createAnonController(deps) {
 					break;
 				default: ctx.ui.notify(USAGE, "error");
 			}
+			await syncImages(ctx);
 			showStatus(ctx);
 		},
 		completions(prefix) {
@@ -545,6 +570,7 @@ function originOf(url) {
 // src/omp/index.ts
 /** omp re-imports the extension per session; the controller (proxy child, recorded originals) is process-wide. */
 const CONTROLLER_KEY = Symbol.for("@skaile/transform-proxy/omp");
+const BLOCK_IMAGES = "images.blockImages";
 /** Registers the `/anon` command and the event handlers on one session's extension API. */
 function registerAnonExtension(pi, controller) {
 	pi.registerCommand("anon", {
@@ -562,9 +588,35 @@ function anonExtension(pi) {
 	const scope = globalThis;
 	registerAnonExtension(pi, scope[CONTROLLER_KEY] ??= createAnonController({
 		env: process.env,
-		home: homedir()
+		home: homedir(),
+		images: ompImageSending(pi)
 	}));
 }
+/** Blocks images through a runtime override of omp's `images.blockImages`, which strips them from every request, history included. */
+function ompImageSending(pi, load = loadOmpSettingsRegistry) {
+	let handle;
+	return { async setBlocked(blocked) {
+		const settings = pi.pi?.settings;
+		if (settings === void 0) return false;
+		handle ??= load().then(blockImagesHandle, () => void 0);
+		const resolved = await handle;
+		if (resolved === void 0) return false;
+		if (blocked) resolved.override(settings, true);
+		else resolved.clearOverride(settings);
+		return true;
+	} };
+}
+function loadOmpSettingsRegistry() {
+	return import("@oh-my-pi/pi-coding-agent/config/registry");
+}
+function blockImagesHandle(registry) {
+	if (typeof registry !== "object" || registry === null || !("lookup" in registry) || typeof registry.lookup !== "function") return void 0;
+	const handle = registry.lookup(BLOCK_IMAGES);
+	if (typeof handle !== "object" || handle === null) return void 0;
+	if (!("override" in handle) || typeof handle.override !== "function") return void 0;
+	if (!("clearOverride" in handle) || typeof handle.clearOverride !== "function") return void 0;
+	return handle;
+}
 function on(pi, event, run) {
 	pi.on(event, (_event, ctx) => guarded(ctx, () => run(ctx)));
 }
@@ -575,4 +627,4 @@ async function guarded(ctx, run) {
 		ctx.ui.notify(`anon: ${errorMessage(err)}`, "error");
 	}
 }
-export { createAnonController, anonExtension as default, defaultStatePath, registerAnonExtension };
+export { createAnonController, anonExtension as default, defaultStatePath, ompImageSending, registerAnonExtension };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skaile/transform-proxy",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "type": "module",
   "description": "Same-protocol passthrough proxy that runs model requests and replies through a chain of text transforms (Anthropic Messages, OpenAI chat, OpenAI responses)",
   "license": "MIT",