@crewhaus/tool-image-generation 0.1.4 → 0.1.6

package/dist/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Catalog R3 — tool-image-generation. M4.1 of the heavy-hitter plan.
+ *
+ * Exposes an `ImageGenerate(prompt, size?, style?)` tool that calls a
+ * remote image-generation API. Today supports OpenAI's image-generation
+ * endpoint (DALL-E 3 family); Replicate / Flux / SD are stubs that the
+ * future provider router fills in.
+ *
+ * Why a remote API rather than a local model: this is a runtime layer,
+ * not an inference layer. Local image generation requires GPU + 5-20GB
+ * model weights — not realistic to ship by default. Operators who want
+ * a self-hosted backend point `provider: "replicate"` at a custom
+ * endpoint (Replicate, Together, or their own hosted Flux/SD).
+ *
+ * Returns: a URL string (when the provider returns one) or a base64
+ * data URI (DALL-E with response_format=b64_json). The model can
+ * include the URL in its reply; vision-capable models can see the
+ * image inline on subsequent turns via WebFetch.
+ *
+ * Pillar 3: this tool is non-destructive (`destructive: false`) — it
+ * doesn't write to the user's host filesystem; it issues a remote HTTP
+ * request. Tool output is classified post-execution by runtime-core's
+ * `tool` origin classifier (the generated image URL is host-untrusted).
+ */
+import { CrewhausError } from "@crewhaus/errors";
+import type { RegisteredTool } from "@crewhaus/tool-catalog";
+export type ImageGenerationProvider = "openai" | "replicate" | "mock";
+export type ImageGenerationConfig = {
+    /** Which provider to route to. Defaults to "openai" when OPENAI_API_KEY is set. */
+    readonly provider?: ImageGenerationProvider;
+    /** Provider-specific model id. Defaults: openai → "dall-e-3", replicate → "stability-ai/sdxl". */
+    readonly model?: string;
+    /** Override the OpenAI base URL (for proxies / Azure OpenAI). */
+    readonly openaiBaseUrl?: string;
+    /** Override fetch implementation for tests. */
+    readonly fetch?: typeof globalThis.fetch;
+};
+export declare class ImageGenerationError extends CrewhausError {
+    readonly name = "ImageGenerationError";
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * Section-14 style config registration. The compiled bundle calls
+ * `registerImageGenerationConfig({ provider, model, ... })` at boot;
+ * the tool's execute() reads from registeredConfig at call time so
+ * env-driven defaults work without re-registering.
+ */
+export declare function registerImageGenerationConfig(config: ImageGenerationConfig): void;
+export declare const imageGenerate: RegisteredTool;

package/dist/index.js

@@ -0,0 +1,137 @@
+/**
+ * Catalog R3 — tool-image-generation. M4.1 of the heavy-hitter plan.
+ *
+ * Exposes an `ImageGenerate(prompt, size?, style?)` tool that calls a
+ * remote image-generation API. Today supports OpenAI's image-generation
+ * endpoint (DALL-E 3 family); Replicate / Flux / SD are stubs that the
+ * future provider router fills in.
+ *
+ * Why a remote API rather than a local model: this is a runtime layer,
+ * not an inference layer. Local image generation requires GPU + 5-20GB
+ * model weights — not realistic to ship by default. Operators who want
+ * a self-hosted backend point `provider: "replicate"` at a custom
+ * endpoint (Replicate, Together, or their own hosted Flux/SD).
+ *
+ * Returns: a URL string (when the provider returns one) or a base64
+ * data URI (DALL-E with response_format=b64_json). The model can
+ * include the URL in its reply; vision-capable models can see the
+ * image inline on subsequent turns via WebFetch.
+ *
+ * Pillar 3: this tool is non-destructive (`destructive: false`) — it
+ * doesn't write to the user's host filesystem; it issues a remote HTTP
+ * request. Tool output is classified post-execution by runtime-core's
+ * `tool` origin classifier (the generated image URL is host-untrusted).
+ */
+import { CrewhausError } from "@crewhaus/errors";
+import { buildTool } from "@crewhaus/tool-builder";
+import { z } from "zod";
+const inputSchema = z.object({
+    prompt: z
+        .string()
+        .min(1)
+        .describe("What to generate. Be specific; vague prompts produce vague images."),
+    size: z
+        .enum(["256x256", "512x512", "1024x1024", "1792x1024", "1024x1792"])
+        .optional()
+        .describe("Output dimensions. Defaults to 1024x1024."),
+    style: z.enum(["vivid", "natural"]).optional().describe("DALL-E 3 style. Defaults to vivid."),
+    responseFormat: z
+        .enum(["url", "b64_json"])
+        .optional()
+        .describe("How to return the image. Default 'url'; b64_json is useful for offline / no-CDN deployments."),
+});
+export class ImageGenerationError extends CrewhausError {
+    name = "ImageGenerationError";
+    constructor(message, cause) {
+        super("tool", message, cause);
+    }
+}
+let registeredConfig;
+/**
+ * Section-14 style config registration. The compiled bundle calls
+ * `registerImageGenerationConfig({ provider, model, ... })` at boot;
+ * the tool's execute() reads from registeredConfig at call time so
+ * env-driven defaults work without re-registering.
+ */
+export function registerImageGenerationConfig(config) {
+    registeredConfig = config;
+}
+export const imageGenerate = buildTool({
+    name: "ImageGenerate",
+    description: "Generate an image from a text prompt via a remote API. Returns a URL or base64 data URI. Use for: visual concepts, mockups, illustrations, social posts. Don't use for: 'edit this existing photo' (different tool needed).",
+    inputSchema,
+    destructive: false,
+    readOnly: false, // not idempotent — each call mints a new image
+    // Pillar 3 sink-side: the prompt is sent to a remote provider; lineage
+    // exfiltration via prompt smuggling is real.
+    scope: "external",
+    // FR-002 — declare the io-capability fact (remote image-gen API call).
+    ioCapability: "network",
+    execute: async (input) => {
+        const cfg = registeredConfig ?? {};
+        const provider = cfg.provider ?? defaultProvider(process.env);
+        const responseFormat = input.responseFormat ?? "url";
+        if (provider === "openai") {
+            return await generateOpenAI(input, cfg, responseFormat);
+        }
+        if (provider === "mock") {
+            return await generateMock(input);
+        }
+        throw new ImageGenerationError(`provider "${provider}" is not yet implemented in tool-image-generation v0`);
+    },
+});
+function defaultProvider(env) {
+    if (env["OPENAI_API_KEY"])
+        return "openai";
+    if (env["CREWHAUS_IMAGE_PROVIDER"] === "mock")
+        return "mock";
+    return "openai"; // surfaces a clear "missing OPENAI_API_KEY" error at call time
+}
+async function generateOpenAI(input, cfg, responseFormat) {
+    const apiKey = process.env["OPENAI_API_KEY"];
+    if (!apiKey) {
+        throw new ImageGenerationError("OPENAI_API_KEY is not set — required for provider=openai. Set the env var or switch to provider=mock for offline testing.");
+    }
+    const baseUrl = cfg.openaiBaseUrl ?? "https://api.openai.com/v1";
+    const model = cfg.model ?? "dall-e-3";
+    const fetchFn = cfg.fetch ?? globalThis.fetch;
+    const body = JSON.stringify({
+        model,
+        prompt: input.prompt,
+        n: 1,
+        size: input.size ?? "1024x1024",
+        response_format: responseFormat,
+        ...(model === "dall-e-3" ? { style: input.style ?? "vivid" } : {}),
+    });
+    const res = await fetchFn(`${baseUrl}/images/generations`, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            "Content-Type": "application/json",
+        },
+        body,
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        throw new ImageGenerationError(`OpenAI image-generation request failed (${res.status} ${res.statusText}): ${text.slice(0, 500)}`);
+    }
+    const json = (await res.json());
+    const first = json.data?.[0];
+    if (!first) {
+        throw new ImageGenerationError("OpenAI response missing data[0] — unexpected format");
+    }
+    if (responseFormat === "url") {
+        if (typeof first.url !== "string") {
+            throw new ImageGenerationError("OpenAI response missing data[0].url");
+        }
+        return `image URL: ${first.url}`;
+    }
+    if (typeof first.b64_json !== "string") {
+        throw new ImageGenerationError("OpenAI response missing data[0].b64_json");
+    }
+    return `image base64 data: data:image/png;base64,${first.b64_json.slice(0, 80)}…[truncated ${first.b64_json.length} bytes total]`;
+}
+async function generateMock(input) {
+    // Deterministic stub — useful for tests + offline development.
+    return `mock image generated for prompt: "${input.prompt}" (no provider configured; set OPENAI_API_KEY or CREWHAUS_IMAGE_PROVIDER)`;
+}

package/package.json

@@ -1,20 +1,23 @@
 {
   "name": "@crewhaus/tool-image-generation",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "type": "module",
   "description": "M4.1 — image-generation tool (DALL-E 3, Replicate, future Flux/SD). Calls remote API; no host writes; non-destructive.",
-  "main": "src/index.ts",
-  "types": "src/index.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "exports": {
-    ".": "./src/index.ts"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
   },
   "scripts": {
     "test": "bun test src"
   },
   "dependencies": {
-    "@crewhaus/errors": "0.1.4",
-    "@crewhaus/tool-builder": "0.1.4",
-    "@crewhaus/tool-catalog": "0.1.4",
+    "@crewhaus/errors": "0.1.6",
+    "@crewhaus/tool-builder": "0.1.6",
+    "@crewhaus/tool-catalog": "0.1.6",
     "zod": "^3.23.8"
   },
   "license": "Apache-2.0",
@@ -35,5 +38,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "files": ["src", "README.md", "LICENSE", "NOTICE"]
+  "files": ["dist", "README.md", "LICENSE", "NOTICE"]
 }

package/src/index.test.ts

@@ -1,169 +0,0 @@
-/**
- * Tests for tool-image-generation. The mock provider gives us
- * deterministic test coverage; the openai provider is exercised via
- * an injected fetch.
- */
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { ImageGenerationError, imageGenerate, registerImageGenerationConfig } from "./index";
-
-let savedEnv: NodeJS.ProcessEnv;
-
-beforeEach(() => {
-  savedEnv = { ...process.env };
-  process.env["OPENAI_API_KEY"] = undefined;
-  registerImageGenerationConfig({});
-});
-
-afterEach(() => {
-  process.env = savedEnv;
-  registerImageGenerationConfig({});
-});
-
-describe("imageGenerate — schema + flags", () => {
-  test("is non-destructive", () => {
-    expect(imageGenerate.destructive).toBe(false);
-  });
-
-  test("name is 'ImageGenerate'", () => {
-    expect(imageGenerate.name).toBe("ImageGenerate");
-  });
-
-  test("schema requires non-empty prompt", () => {
-    expect(() => imageGenerate.inputSchema.parse({ prompt: "" })).toThrow();
-    expect(() => imageGenerate.inputSchema.parse({ prompt: "ok" })).not.toThrow();
-  });
-
-  test("schema rejects unknown size", () => {
-    expect(() => imageGenerate.inputSchema.parse({ prompt: "x", size: "999x999" })).toThrow();
-  });
-});
-
-describe("imageGenerate — mock provider", () => {
-  test("returns a deterministic stub", async () => {
-    registerImageGenerationConfig({ provider: "mock" });
-    const out = await imageGenerate.execute({ prompt: "a lobster on a beach" });
-    expect(out).toContain("mock image generated");
-    expect(out).toContain("a lobster on a beach");
-  });
-});
-
-describe("imageGenerate — openai provider", () => {
-  test("throws ImageGenerationError when OPENAI_API_KEY is unset", async () => {
-    registerImageGenerationConfig({ provider: "openai" });
-    await expect(imageGenerate.execute({ prompt: "x" })).rejects.toThrow(ImageGenerationError);
-  });
-
-  test("calls the openai endpoint with the configured model", async () => {
-    process.env["OPENAI_API_KEY"] = "sk-test";
-    let capturedUrl = "";
-    let capturedBody = "";
-    const mockFetch: typeof globalThis.fetch = async (input, init) => {
-      capturedUrl = String(input);
-      capturedBody = String(init?.body ?? "");
-      return new Response(JSON.stringify({ data: [{ url: "https://example.com/img.png" }] }), {
-        status: 200,
-        headers: { "content-type": "application/json" },
-      });
-    };
-    registerImageGenerationConfig({ provider: "openai", fetch: mockFetch });
-
-    const out = await imageGenerate.execute({ prompt: "lobster" });
-    expect(out).toContain("https://example.com/img.png");
-    expect(capturedUrl).toBe("https://api.openai.com/v1/images/generations");
-    const body = JSON.parse(capturedBody) as { model: string; prompt: string; size: string };
-    expect(body.model).toBe("dall-e-3");
-    expect(body.prompt).toBe("lobster");
-    expect(body.size).toBe("1024x1024");
-  });
-
-  test("honors size + style overrides", async () => {
-    process.env["OPENAI_API_KEY"] = "sk-test";
-    let capturedBody = "";
-    const mockFetch: typeof globalThis.fetch = async (_input, init) => {
-      capturedBody = String(init?.body ?? "");
-      return new Response(JSON.stringify({ data: [{ url: "https://example.com/x.png" }] }), {
-        status: 200,
-      });
-    };
-    registerImageGenerationConfig({ provider: "openai", fetch: mockFetch });
-    await imageGenerate.execute({ prompt: "x", size: "1792x1024", style: "natural" });
-    const body = JSON.parse(capturedBody) as { size: string; style: string };
-    expect(body.size).toBe("1792x1024");
-    expect(body.style).toBe("natural");
-  });
-
-  test("surfaces upstream errors", async () => {
-    process.env["OPENAI_API_KEY"] = "sk-test";
-    const mockFetch: typeof globalThis.fetch = async () =>
-      new Response("rate limited", { status: 429, statusText: "Too Many Requests" });
-    registerImageGenerationConfig({ provider: "openai", fetch: mockFetch });
-    await expect(imageGenerate.execute({ prompt: "x" })).rejects.toThrow(ImageGenerationError);
-  });
-
-  test("error body read failure is swallowed by .catch(() => '')", async () => {
-    process.env["OPENAI_API_KEY"] = "sk-test";
-    // A non-ok response whose .text() itself rejects exercises the
-    // `.catch(() => "")` fallback on the error path (line ~145).
-    const badResponse = {
-      ok: false,
-      status: 500,
-      statusText: "Internal Server Error",
-      text: async () => {
-        throw new Error("stream already consumed");
-      },
-    } as unknown as Response;
-    const mockFetch: typeof globalThis.fetch = async () => badResponse;
-    registerImageGenerationConfig({ provider: "openai", fetch: mockFetch });
-    await expect(imageGenerate.execute({ prompt: "x" })).rejects.toThrow(
-      /OpenAI image-generation request failed \(500/,
-    );
-  });
-
-  test("b64_json response format returns a data URI preview", async () => {
-    process.env["OPENAI_API_KEY"] = "sk-test";
-    const longB64 = "A".repeat(500);
-    const mockFetch: typeof globalThis.fetch = async () =>
-      new Response(JSON.stringify({ data: [{ b64_json: longB64 }] }), { status: 200 });
-    registerImageGenerationConfig({ provider: "openai", fetch: mockFetch });
-    const out = await imageGenerate.execute({ prompt: "x", responseFormat: "b64_json" });
-    expect(out).toContain("data:image/png;base64,");
-    expect(out).toContain("[truncated 500 bytes total]");
-  });
-});
-
-describe("imageGenerate — defaultProvider env routing (no explicit provider)", () => {
-  test("OPENAI_API_KEY present → routes to openai (uses injected fetch)", async () => {
-    // No `provider` in config forces execute() through defaultProvider(env).
-    process.env["OPENAI_API_KEY"] = "sk-test";
-    process.env["CREWHAUS_IMAGE_PROVIDER"] = undefined;
-    let called = false;
-    const mockFetch: typeof globalThis.fetch = async () => {
-      called = true;
-      return new Response(JSON.stringify({ data: [{ url: "https://example.com/auto.png" }] }), {
-        status: 200,
-      });
-    };
-    registerImageGenerationConfig({ fetch: mockFetch });
-    const out = await imageGenerate.execute({ prompt: "auto-routed" });
-    expect(called).toBe(true);
-    expect(out).toContain("https://example.com/auto.png");
-  });
-
-  test("no API key but CREWHAUS_IMAGE_PROVIDER=mock → routes to mock", async () => {
-    process.env["OPENAI_API_KEY"] = undefined;
-    process.env["CREWHAUS_IMAGE_PROVIDER"] = "mock";
-    registerImageGenerationConfig({});
-    const out = await imageGenerate.execute({ prompt: "offline lobster" });
-    expect(out).toContain("mock image generated");
-    expect(out).toContain("offline lobster");
-  });
-
-  test("neither env var set → falls through to openai, surfacing missing-key error", async () => {
-    process.env["OPENAI_API_KEY"] = undefined;
-    process.env["CREWHAUS_IMAGE_PROVIDER"] = undefined;
-    registerImageGenerationConfig({});
-    // defaultProvider returns "openai" (the documented fall-through); execute
-    // then throws the clear missing-key error from generateOpenAI.
-    await expect(imageGenerate.execute({ prompt: "x" })).rejects.toThrow(ImageGenerationError);
-  });
-});

package/src/index.ts

@@ -1,174 +0,0 @@
-/**
- * Catalog R3 — tool-image-generation. M4.1 of the heavy-hitter plan.
- *
- * Exposes an `ImageGenerate(prompt, size?, style?)` tool that calls a
- * remote image-generation API. Today supports OpenAI's image-generation
- * endpoint (DALL-E 3 family); Replicate / Flux / SD are stubs that the
- * future provider router fills in.
- *
- * Why a remote API rather than a local model: this is a runtime layer,
- * not an inference layer. Local image generation requires GPU + 5-20GB
- * model weights — not realistic to ship by default. Operators who want
- * a self-hosted backend point `provider: "replicate"` at a custom
- * endpoint (Replicate, Together, or their own hosted Flux/SD).
- *
- * Returns: a URL string (when the provider returns one) or a base64
- * data URI (DALL-E with response_format=b64_json). The model can
- * include the URL in its reply; vision-capable models can see the
- * image inline on subsequent turns via WebFetch.
- *
- * Pillar 3: this tool is non-destructive (`destructive: false`) — it
- * doesn't write to the user's host filesystem; it issues a remote HTTP
- * request. Tool output is classified post-execution by runtime-core's
- * `tool` origin classifier (the generated image URL is host-untrusted).
- */
-import { CrewhausError } from "@crewhaus/errors";
-import { buildTool } from "@crewhaus/tool-builder";
-import type { RegisteredTool } from "@crewhaus/tool-catalog";
-import { z } from "zod";
-
-export type ImageGenerationProvider = "openai" | "replicate" | "mock";
-
-export type ImageGenerationConfig = {
-  /** Which provider to route to. Defaults to "openai" when OPENAI_API_KEY is set. */
-  readonly provider?: ImageGenerationProvider;
-  /** Provider-specific model id. Defaults: openai → "dall-e-3", replicate → "stability-ai/sdxl". */
-  readonly model?: string;
-  /** Override the OpenAI base URL (for proxies / Azure OpenAI). */
-  readonly openaiBaseUrl?: string;
-  /** Override fetch implementation for tests. */
-  readonly fetch?: typeof globalThis.fetch;
-};
-
-const inputSchema = z.object({
-  prompt: z
-    .string()
-    .min(1)
-    .describe("What to generate. Be specific; vague prompts produce vague images."),
-  size: z
-    .enum(["256x256", "512x512", "1024x1024", "1792x1024", "1024x1792"])
-    .optional()
-    .describe("Output dimensions. Defaults to 1024x1024."),
-  style: z.enum(["vivid", "natural"]).optional().describe("DALL-E 3 style. Defaults to vivid."),
-  responseFormat: z
-    .enum(["url", "b64_json"])
-    .optional()
-    .describe(
-      "How to return the image. Default 'url'; b64_json is useful for offline / no-CDN deployments.",
-    ),
-});
-
-export class ImageGenerationError extends CrewhausError {
-  override readonly name = "ImageGenerationError";
-  constructor(message: string, cause?: unknown) {
-    super("tool", message, cause);
-  }
-}
-
-let registeredConfig: ImageGenerationConfig | undefined;
-
-/**
- * Section-14 style config registration. The compiled bundle calls
- * `registerImageGenerationConfig({ provider, model, ... })` at boot;
- * the tool's execute() reads from registeredConfig at call time so
- * env-driven defaults work without re-registering.
- */
-export function registerImageGenerationConfig(config: ImageGenerationConfig): void {
-  registeredConfig = config;
-}
-
-export const imageGenerate: RegisteredTool = buildTool({
-  name: "ImageGenerate",
-  description:
-    "Generate an image from a text prompt via a remote API. Returns a URL or base64 data URI. Use for: visual concepts, mockups, illustrations, social posts. Don't use for: 'edit this existing photo' (different tool needed).",
-  inputSchema,
-  destructive: false,
-  readOnly: false, // not idempotent — each call mints a new image
-  // Pillar 3 sink-side: the prompt is sent to a remote provider; lineage
-  // exfiltration via prompt smuggling is real.
-  scope: "external",
-  // FR-002 — declare the io-capability fact (remote image-gen API call).
-  ioCapability: "network",
-  execute: async (input) => {
-    const cfg = registeredConfig ?? {};
-    const provider = cfg.provider ?? defaultProvider(process.env);
-    const responseFormat = input.responseFormat ?? "url";
-    if (provider === "openai") {
-      return await generateOpenAI(input, cfg, responseFormat);
-    }
-    if (provider === "mock") {
-      return await generateMock(input);
-    }
-    throw new ImageGenerationError(
-      `provider "${provider}" is not yet implemented in tool-image-generation v0`,
-    );
-  },
-});
-
-function defaultProvider(env: NodeJS.ProcessEnv): ImageGenerationProvider {
-  if (env["OPENAI_API_KEY"]) return "openai";
-  if (env["CREWHAUS_IMAGE_PROVIDER"] === "mock") return "mock";
-  return "openai"; // surfaces a clear "missing OPENAI_API_KEY" error at call time
-}
-
-async function generateOpenAI(
-  input: z.infer<typeof inputSchema>,
-  cfg: ImageGenerationConfig,
-  responseFormat: "url" | "b64_json",
-): Promise<string> {
-  const apiKey = process.env["OPENAI_API_KEY"];
-  if (!apiKey) {
-    throw new ImageGenerationError(
-      "OPENAI_API_KEY is not set — required for provider=openai. Set the env var or switch to provider=mock for offline testing.",
-    );
-  }
-  const baseUrl = cfg.openaiBaseUrl ?? "https://api.openai.com/v1";
-  const model = cfg.model ?? "dall-e-3";
-  const fetchFn = cfg.fetch ?? globalThis.fetch;
-  const body = JSON.stringify({
-    model,
-    prompt: input.prompt,
-    n: 1,
-    size: input.size ?? "1024x1024",
-    response_format: responseFormat,
-    ...(model === "dall-e-3" ? { style: input.style ?? "vivid" } : {}),
-  });
-  const res = await fetchFn(`${baseUrl}/images/generations`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${apiKey}`,
-      "Content-Type": "application/json",
-    },
-    body,
-  });
-  if (!res.ok) {
-    const text = await res.text().catch(() => "");
-    throw new ImageGenerationError(
-      `OpenAI image-generation request failed (${res.status} ${res.statusText}): ${text.slice(0, 500)}`,
-    );
-  }
-  const json = (await res.json()) as {
-    data?: ReadonlyArray<{ url?: string; b64_json?: string }>;
-  };
-  const first = json.data?.[0];
-  if (!first) {
-    throw new ImageGenerationError("OpenAI response missing data[0] — unexpected format");
-  }
-  if (responseFormat === "url") {
-    if (typeof first.url !== "string") {
-      throw new ImageGenerationError("OpenAI response missing data[0].url");
-    }
-    return `image URL: ${first.url}`;
-  }
-  if (typeof first.b64_json !== "string") {
-    throw new ImageGenerationError("OpenAI response missing data[0].b64_json");
-  }
-  return `image base64 data: data:image/png;base64,${first.b64_json.slice(0, 80)}…[truncated ${
-    first.b64_json.length
-  } bytes total]`;
-}
-
-async function generateMock(input: z.infer<typeof inputSchema>): Promise<string> {
-  // Deterministic stub — useful for tests + offline development.
-  return `mock image generated for prompt: "${input.prompt}" (no provider configured; set OPENAI_API_KEY or CREWHAUS_IMAGE_PROVIDER)`;
-}