ima2-gen 3.14.0 → 3.15.0

package/lib/providers/adapters/googleExecution.js

@@ -29,36 +29,26 @@ function prepareGoogleClassic(ctx, request) {
     const { model, size } = request.options;
     // Classic captures scalars once; each attempt reads live refs, signal and credentials.
     return { execute: async () => {
-            try {
-                const value = provider === "agy"
-                    ? await generateViaAgy(prompt, { references: request.references, signal: request.signal, requestId })
-                    : await generateViaGeminiApi(prompt, requireRuntimeContext(ctx), {
-                        model, size, signal: request.signal,
-                        ...(requestId !== undefined ? { requestId } : {}),
-                        references: request.references,
-                    });
-                return { kind: "single", value };
-            }
-            catch (error) {
-                throw error;
-            } // Preserve native identity; caller owns normalization.
+            const value = provider === "agy"
+                ? await generateViaAgy(prompt, { references: request.references, signal: request.signal, requestId })
+                : await generateViaGeminiApi(prompt, requireRuntimeContext(ctx), {
+                    model, size, signal: request.signal,
+                    ...(requestId !== undefined ? { requestId } : {}),
+                    references: request.references,
+                });
+            return { kind: "single", value };
         } };
 }
 async function runGoogleImage(ctx, request, input) {
-    try {
-        const { provider, signal, requestId, options } = request;
-        if (provider === "agy") {
-            return await generateViaAgy(input.prompt, { references: input.references, signal, requestId });
-        }
-        return await generateViaGeminiApi(input.prompt, request.surface === "node" ? requireRuntimeContext(ctx) : ctx, {
-            model: options.model, size: options.size, signal,
-            ...(requestId !== undefined ? { requestId } : {}),
-            references: input.references,
-        });
-    }
-    catch (error) {
-        throw error;
+    const { provider, signal, requestId, options } = request;
+    if (provider === "agy") {
+        return await generateViaAgy(input.prompt, { references: input.references, signal, requestId });
     }
+    return await generateViaGeminiApi(input.prompt, request.surface === "node" ? requireRuntimeContext(ctx) : ctx, {
+        model: options.model, size: options.size, signal,
+        ...(requestId !== undefined ? { requestId } : {}),
+        references: input.references,
+    });
 }
 function googleSequence(result) {
     // Preserve the dense one-image projection; the caller owns the final persistence sweep.
@@ -68,30 +58,15 @@ function googleSequence(result) {
     };
 }
 export async function prepareGoogleExecution(ctx, request, _progress) {
-    try {
-        switch (request.surface) {
-            case "classic": return prepareGoogleClassic(ctx, request);
-            case "node":
-            case "edit": return { execute: async () => {
-                    try {
-                        return { kind: "single", value: await runGoogleImage(ctx, request, googleInput(request)) };
-                    }
-                    catch (error) {
-                        throw error;
-                    } // Caller owns retries, cancellation and cleanup.
-                } };
-            case "multimode": return { execute: async () => {
-                    try {
-                        const result = await runGoogleImage(ctx, request, googleInput(request));
-                        return { kind: "sequence", value: googleSequence(result) };
-                    }
-                    catch (error) {
-                        throw error;
-                    }
-                } };
-        }
-    }
-    catch (error) {
-        throw error;
+    switch (request.surface) {
+        case "classic": return prepareGoogleClassic(ctx, request);
+        case "node":
+        case "edit": return { execute: async () => {
+                return { kind: "single", value: await runGoogleImage(ctx, request, googleInput(request)) };
+            } };
+        case "multimode": return { execute: async () => {
+                const result = await runGoogleImage(ctx, request, googleInput(request));
+                return { kind: "sequence", value: googleSequence(result) };
+            } };
     }
 }

package/lib/providers/adapters/grok-api.js

@@ -0,0 +1,55 @@
+import { getProvider } from "../registry.js";
+const LANE_ID = "grok-api";
+const ERROR_PREFIX = getProvider(LANE_ID).errorPrefix;
+/** Status codes worth retrying: transient upstream conditions, not bad input. */
+const RETRYABLE_STATUSES = new Set([408, 425, 429, 500, 502, 503, 504]);
+function readStatus(error) {
+    if (!error || typeof error !== "object")
+        return undefined;
+    const candidate = error;
+    return typeof candidate.status === "number" ? candidate.status
+        : typeof candidate.statusCode === "number" ? candidate.statusCode
+            : undefined;
+}
+function readCode(error) {
+    if (!error || typeof error !== "object")
+        return undefined;
+    const candidate = error;
+    return typeof candidate.code === "string" ? candidate.code : undefined;
+}
+export function createGrokApiAdapter(ctx) {
+    return {
+        laneId: LANE_ID,
+        validateAuth() {
+            return ctx.xaiApiKey
+                ? { ok: true }
+                : { ok: false, reason: "xAI API key missing" };
+        },
+        listModels() {
+            // Straight from the registry. A hand-written list here is exactly the
+            // drift the capability registry was built to remove.
+            return getProvider(LANE_ID).models;
+        },
+        normalizeError(error) {
+            const status = readStatus(error);
+            const rawCode = readCode(error);
+            const message = error instanceof Error ? error.message
+                : typeof error === "string" ? error
+                    : "xAI request failed";
+            const code = !ERROR_PREFIX
+                ? rawCode ?? "UNKNOWN"
+                : rawCode?.startsWith(ERROR_PREFIX)
+                    ? rawCode
+                    : rawCode
+                        ? `${ERROR_PREFIX}${rawCode}`
+                        : `${ERROR_PREFIX}UNKNOWN`;
+            const retryable = status === undefined ? false : RETRYABLE_STATUSES.has(status);
+            return {
+                code,
+                message,
+                ...(status === undefined ? {} : { status }),
+                retryable,
+            };
+        },
+    };
+}

package/lib/providers/adapters/grokExecution.js

@@ -7,131 +7,86 @@ export function isGrokRequest(request) {
     return request.provider === "grok" || request.provider === "grok-api";
 }
 async function prepareGrokClassic(ctx, request) {
-    try {
-        const { provider: activeProvider, prompt: generationPrompt, requestId } = request;
-        const { model: imageModel, quality, size: effectiveSize, webSearchEnabled } = request.options;
-        const grokRefs = request.providerUrl
-            ? [{ b64: "", url: request.providerUrl, declaredMime: "image/png", detectedMime: "image/png" }, ...request.references]
-            : request.references;
-        // Keep classic's once-per-batch key and shared plan capture before any image attempt.
-        const grokDirectApiKey = activeProvider === "grok-api" ? ctx.xaiApiKey : undefined;
-        const sharedGrokPlan = await planGrokImage(generationPrompt, ctx, {
-            model: resolveGrokQualityModel(imageModel, quality),
-            size: effectiveSize,
-            signal: request.signal,
-            requestId,
-            referenceCount: grokRefs.length,
-            references: grokRefs,
-            directApiKey: grokDirectApiKey,
-            backgroundConstraint: request.backgroundConstraint,
-            webSearchEnabled,
-        });
-        return { execute: async () => {
-                try {
-                    const grokModel = resolveGrokQualityModel(imageModel, quality);
-                    const value = await generateViaGrok(generationPrompt, ctx, {
-                        model: grokModel,
-                        size: effectiveSize,
-                        signal: request.signal,
-                        requestId,
-                        plannedPrompt: sharedGrokPlan?.prompt,
-                        webSearchCalls: sharedGrokPlan?.webSearchCalls,
-                        references: grokRefs,
-                        directApiKey: grokDirectApiKey,
-                    });
-                    return { kind: "single", value };
-                }
-                catch (error) {
-                    throw error;
-                } // Caller owns lifecycle and the existing error envelope.
-            } };
-    }
-    catch (error) {
-        throw error;
-    }
+    const { provider: activeProvider, prompt: generationPrompt, requestId } = request;
+    const { model: imageModel, quality, size: effectiveSize, webSearchEnabled } = request.options;
+    const grokRefs = request.providerUrl
+        ? [{ b64: "", url: request.providerUrl, declaredMime: "image/png", detectedMime: "image/png" }, ...request.references]
+        : request.references;
+    // Keep classic's once-per-batch key and shared plan capture before any image attempt.
+    const grokDirectApiKey = activeProvider === "grok-api" ? ctx.xaiApiKey : undefined;
+    const sharedGrokPlan = await planGrokImage(generationPrompt, ctx, {
+        model: resolveGrokQualityModel(imageModel, quality),
+        size: effectiveSize,
+        signal: request.signal,
+        requestId,
+        referenceCount: grokRefs.length,
+        references: grokRefs,
+        directApiKey: grokDirectApiKey,
+        backgroundConstraint: request.backgroundConstraint,
+        webSearchEnabled,
+    });
+    return { execute: async () => {
+            const grokModel = resolveGrokQualityModel(imageModel, quality);
+            const value = await generateViaGrok(generationPrompt, ctx, {
+                model: grokModel,
+                size: effectiveSize,
+                signal: request.signal,
+                requestId,
+                plannedPrompt: sharedGrokPlan?.prompt,
+                webSearchCalls: sharedGrokPlan?.webSearchCalls,
+                references: grokRefs,
+                directApiKey: grokDirectApiKey,
+            });
+            return { kind: "single", value };
+        } };
 }
 function prepareGrokNode(ctx, request) {
     // The outer execution boundary checks current presence; retries retain this key.
     const grokDirectApiKey = request.provider === "grok-api" ? ctx.xaiApiKey : undefined;
     return { execute: async () => {
-            try {
-                return { kind: "single", value: await executeGrokNode(ctx, request, grokDirectApiKey) };
-            }
-            catch (error) {
-                throw error;
-            } // The caller owns retries and normalization.
+            return { kind: "single", value: await executeGrokNode(ctx, request, grokDirectApiKey) };
         } };
 }
 async function executeGrokNode(ctx, request, grokDirectApiKey) {
-    try {
-        const { sourceImage: parentB64, prompt: generationPrompt, references, requestId, signal, options } = request;
-        const { model, size, webSearchEnabled } = options;
-        const refsForRequest = request.contextMode === "parent-only" ? [] : references;
-        return await generateViaGrok(generationPrompt, ctx, {
-            model, size, requestId, signal,
-            references: toGrokReferences(parentB64, refsForRequest),
-            directApiKey: grokDirectApiKey,
-            webSearchEnabled,
-        });
-    }
-    catch (error) {
-        throw error;
-    }
+    const { sourceImage: parentB64, prompt: generationPrompt, references, requestId, signal, options } = request;
+    const { model, size, webSearchEnabled } = options;
+    const refsForRequest = request.contextMode === "parent-only" ? [] : references;
+    return await generateViaGrok(generationPrompt, ctx, {
+        model, size, requestId, signal,
+        references: toGrokReferences(parentB64, refsForRequest),
+        directApiKey: grokDirectApiKey,
+        webSearchEnabled,
+    });
 }
 async function executeGrokEdit(ctx, request) {
-    try {
-        const { provider, rawPrompt, sourceImage, signal, requestId, options } = request;
-        const directApiKey = provider === "grok-api" ? ctx.xaiApiKey : undefined;
-        return await editViaGrok(rawPrompt, sourceImage, ctx, {
-            model: resolveGrokQualityModel(options.model, options.quality),
-            size: options.size, signal, requestId, directApiKey,
-        });
-    }
-    catch (error) {
-        throw error;
-    }
+    const { provider, rawPrompt, sourceImage, signal, requestId, options } = request;
+    const directApiKey = provider === "grok-api" ? ctx.xaiApiKey : undefined;
+    return await editViaGrok(rawPrompt, sourceImage, ctx, {
+        model: resolveGrokQualityModel(options.model, options.quality),
+        size: options.size, signal, requestId, directApiKey,
+    });
 }
 async function executeGrokMultimode(ctx, request, progress) {
-    try {
-        const { provider, prompt, references, signal, requestId, options, maxImages } = request;
-        const directApiKey = provider === "grok-api" ? ctx.xaiApiKey : undefined;
-        const grokRefs = request.providerUrl
-            ? [{ b64: "", url: request.providerUrl }, ...references] : references;
-        return await generateMultimodeViaGrok(prompt, ctx, {
-            model: resolveGrokQualityModel(options.model, options.quality), maxImages,
-            size: options.size, signal, requestId, references: grokRefs, directApiKey,
-            onFinalImage: progress.onFinalImage,
-            webSearchEnabled: options.webSearchEnabled,
-        });
-    }
-    catch (error) {
-        throw error;
-    }
+    const { provider, prompt, references, signal, requestId, options, maxImages } = request;
+    const directApiKey = provider === "grok-api" ? ctx.xaiApiKey : undefined;
+    const grokRefs = request.providerUrl
+        ? [{ b64: "", url: request.providerUrl }, ...references] : references;
+    return await generateMultimodeViaGrok(prompt, ctx, {
+        model: resolveGrokQualityModel(options.model, options.quality), maxImages,
+        size: options.size, signal, requestId, references: grokRefs, directApiKey,
+        onFinalImage: progress.onFinalImage,
+        webSearchEnabled: options.webSearchEnabled,
+    });
 }
 export async function prepareGrokExecution(ctx, request, progress = {}) {
-    try {
-        switch (request.surface) {
-            case "classic": return await prepareGrokClassic(ctx, request);
-            case "node": return prepareGrokNode(ctx, request);
-            case "edit": return { execute: async () => {
-                    try {
-                        return { kind: "single", value: await executeGrokEdit(ctx, request) };
-                    }
-                    catch (error) {
-                        throw error;
-                    } // Route owns failure normalization and job cleanup.
-                } };
-            case "multimode": return { execute: async () => {
-                    try {
-                        return { kind: "sequence", value: await executeGrokMultimode(ctx, request, progress) };
-                    }
-                    catch (error) {
-                        throw error;
-                    } // Caller owns partial-timeout recovery.
-                } };
-        }
-    }
-    catch (error) {
-        throw error;
+    switch (request.surface) {
+        case "classic": return await prepareGrokClassic(ctx, request);
+        case "node": return prepareGrokNode(ctx, request);
+        case "edit": return { execute: async () => {
+                return { kind: "single", value: await executeGrokEdit(ctx, request) };
+            } };
+        case "multimode": return { execute: async () => {
+                return { kind: "sequence", value: await executeGrokMultimode(ctx, request, progress) };
+            } };
     }
 }

package/lib/providers/adapters/index.js

@@ -1,8 +1,14 @@
+import { createApiAdapter } from "./api.js";
+import { createGrokApiAdapter } from "./grok-api.js";
+import { createGeminiApiAdapter } from "./gemini-api.js";
 import { createAtlasCloudAdapter } from "./atlascloud.js";
 import { createComfyAdapter } from "./comfy.js";
 import { createMinimaxAdapter } from "./minimax.js";
 import { createNaiAdapter } from "./nai.js";
 const ADAPTER_FACTORIES = {
+    api: createApiAdapter,
+    "grok-api": createGrokApiAdapter,
+    "gemini-api": createGeminiApiAdapter,
     minimax: createMinimaxAdapter,
     atlascloud: createAtlasCloudAdapter,
     comfy: createComfyAdapter,

package/lib/providers/adapters/minimax.js

@@ -1,3 +1,10 @@
+/**
+ * MiniMax adapter: readiness, registry models, errors and image execution surfaces.
+ * The existing image adapter retains transport and provider protocol ownership.
+ */
+import { generateViaMinimax } from "../../minimaxImageAdapter.js";
+import { detectImageMimeFromB64 } from "../../refs.js";
+import { requireRuntimeContext } from "../../runtimeContext.js";
 import { getProvider } from "../registry.js";
 const LANE_ID = "minimax";
 const ERROR_PREFIX = "MINIMAX_";
@@ -28,6 +35,7 @@ function readCode(error) {
 export function createMinimaxAdapter(ctx) {
     return {
         laneId: LANE_ID,
+        prepareImageExecution: prepareLaneImageExecution,
         validateAuth() {
             // Presence only. MiniMax publishes no key prefix or length rule, so a
             // format check would invent one and reject valid keys.
@@ -61,3 +69,58 @@ export function createMinimaxAdapter(ctx) {
         },
     };
 }
+function prepareClassic(ctx, request) {
+    const { prompt: generationPrompt, requestId } = request;
+    const { model: imageModel, size: effectiveSize } = request.options;
+    // Capture scalars at prepare; ctx, refs, signal and lane options stay live.
+    return { execute: async () => {
+            const value = await generateViaMinimax(generationPrompt, requireRuntimeContext(ctx), {
+                model: imageModel, size: effectiveSize, signal: request.signal,
+                requestId, references: request.references,
+            });
+            return { kind: "single", value };
+        } };
+}
+function prepareNode(ctx, request) {
+    return { execute: async () => {
+            const { sourceImage: parentB64, rawPrompt: prompt, references, requestId, signal, options } = request;
+            const { model, size } = options;
+            const value = await generateViaMinimax(parentB64 ? `Edit this image: ${prompt}` : prompt, requireRuntimeContext(ctx), {
+                model, size, signal, requestId,
+                references: parentB64
+                    ? [{ b64: parentB64, declaredMime: null, detectedMime: null }, ...references]
+                    : references,
+            });
+            return { kind: "single", value };
+        } };
+}
+function prepareEdit(ctx, request) {
+    return { execute: async () => {
+            const { prompt, sourceImage, signal, requestId, options } = request;
+            const references = [{ b64: sourceImage, declaredMime: null, detectedMime: detectImageMimeFromB64(sourceImage) || null }];
+            const editPrompt = `Edit this image: ${prompt}`;
+            const params = { model: options.model, size: options.size, signal, ...(requestId !== undefined ? { requestId } : {}), references };
+            const value = await generateViaMinimax(editPrompt, ctx, params);
+            return { kind: "single", value };
+        } };
+}
+function prepareMultimode(ctx, request) {
+    return { execute: async () => {
+            const { rawPrompt, references, signal, requestId, options } = request;
+            const params = { model: options.model, size: options.size, signal, ...(requestId !== undefined ? { requestId } : {}), references };
+            const result = await generateViaMinimax(rawPrompt, ctx, params);
+            // Preserve the projection; the caller owns the final persistence sweep.
+            return { kind: "sequence", value: {
+                    images: [{ b64: result.b64, ...(result.revisedPrompt !== undefined ? { revisedPrompt: result.revisedPrompt } : {}) }],
+                    usage: result.usage, webSearchCalls: result.webSearchCalls,
+                } };
+        } };
+}
+async function prepareLaneImageExecution(ctx, request, _progress) {
+    switch (request.surface) {
+        case "classic": return prepareClassic(ctx, request);
+        case "node": return prepareNode(ctx, request);
+        case "edit": return prepareEdit(ctx, request);
+        case "multimode": return prepareMultimode(ctx, request);
+    }
+}

package/lib/providers/adapters/nai.js

@@ -1,3 +1,9 @@
+/**
+ * NovelAI adapter: readiness, registry models, errors and image execution surfaces.
+ * The existing image adapter retains transport and provider protocol ownership.
+ */
+import { generateViaNai } from "../../naiImageAdapter.js";
+import { requireRuntimeContext } from "../../runtimeContext.js";
 import { getProvider } from "../registry.js";
 const LANE_ID = "nai";
 const ERROR_PREFIX = "NAI_";
@@ -25,6 +31,7 @@ function readCode(error) {
 export function createNaiAdapter(ctx) {
     return {
         laneId: LANE_ID,
+        prepareImageExecution: prepareLaneImageExecution,
         validateAuth() {
             // Presence only. NovelAI accepts a persistent token or a session JWT and
             // publishes no prefix or length rule, so a format check would invent one.
@@ -58,3 +65,51 @@ export function createNaiAdapter(ctx) {
         },
     };
 }
+function prepareClassic(ctx, request) {
+    const { prompt: generationPrompt, requestId } = request;
+    const { model: imageModel, size: effectiveSize } = request.options;
+    // Capture scalars at prepare; ctx, refs, signal and lane options stay live.
+    return { execute: async () => {
+            // Text-to-image only: the caller already refused references.
+            const value = await generateViaNai(generationPrompt, requireRuntimeContext(ctx), {
+                model: imageModel, size: effectiveSize, signal: request.signal, requestId,
+                // Reuse the same normalized options as node and multimode.
+                ...request.nai,
+            });
+            return { kind: "single", value };
+        } };
+}
+function prepareNode(ctx, request) {
+    return { execute: async () => {
+            const { rawPrompt: prompt, requestId, signal, options } = request;
+            const { model, size } = options;
+            const value = await generateViaNai(prompt, requireRuntimeContext(ctx), {
+                model, size, signal, requestId, ...request.nai,
+            });
+            return { kind: "single", value };
+        } };
+}
+function prepareMultimode(ctx, request) {
+    return { execute: async () => {
+            const { rawPrompt, signal, requestId, options } = request;
+            // Text-to-image only: admission rejects references before startJob.
+            const result = await generateViaNai(rawPrompt, ctx, {
+                model: options.model, size: options.size, signal, requestId, ...request.nai,
+            });
+            // Preserve the projection; the caller owns the final persistence sweep.
+            return { kind: "sequence", value: {
+                    images: [{ b64: result.b64, ...(result.revisedPrompt !== undefined ? { revisedPrompt: result.revisedPrompt } : {}) }],
+                    usage: result.usage, webSearchCalls: result.webSearchCalls,
+                } };
+        } };
+}
+async function prepareLaneImageExecution(ctx, request, _progress) {
+    switch (request.surface) {
+        case "classic": return prepareClassic(ctx, request);
+        case "node": return prepareNode(ctx, request);
+        case "edit": return { execute: async () => {
+                throw new Error(`Unsupported legacy edit provider: ${request.provider}`);
+            } };
+        case "multimode": return prepareMultimode(ctx, request);
+    }
+}

package/lib/providers/adapters/openaiExecution.js

@@ -45,12 +45,7 @@ function prepareOpenaiClassic(ctx, request, _progress) {
         });
     };
     return { execute: async () => {
-            try {
-                return { kind: "single", value: await generateOne() };
-            }
-            catch (error) {
-                throw error;
-            } // Caller owns lifecycle and the existing error envelope.
+            return { kind: "single", value: await generateOne() };
         } };
 }
 async function executeOpenaiNode(ctx, request, progress) {
@@ -83,36 +78,16 @@ async function executeOpenaiMultimode(ctx, request, progress) {
         ...(progress.onFinalImage !== undefined ? { onFinalImage: progress.onFinalImage } : {}), signal });
 }
 export async function prepareOpenaiExecution(ctx, request, progress = {}) {
-    try {
-        switch (request.surface) {
-            case "classic": return prepareOpenaiClassic(ctx, request, progress);
-            case "node": return { execute: async () => {
-                    try {
-                        return { kind: "single", value: await executeOpenaiNode(ctx, request, progress) };
-                    }
-                    catch (error) {
-                        throw error;
-                    } // Caller owns retries and normalization.
-                } };
-            case "edit": return { execute: async () => {
-                    try {
-                        return { kind: "single", value: await executeOpenaiEdit(ctx, request) };
-                    }
-                    catch (error) {
-                        throw error;
-                    } // Route owns failure normalization and job cleanup.
-                } };
-            case "multimode": return { execute: async () => {
-                    try {
-                        return { kind: "sequence", value: await executeOpenaiMultimode(ctx, request, progress) };
-                    }
-                    catch (error) {
-                        throw error;
-                    } // Caller owns partial-timeout recovery.
-                } };
-        }
-    }
-    catch (error) {
-        throw error;
+    switch (request.surface) {
+        case "classic": return prepareOpenaiClassic(ctx, request, progress);
+        case "node": return { execute: async () => {
+                return { kind: "single", value: await executeOpenaiNode(ctx, request, progress) };
+            } };
+        case "edit": return { execute: async () => {
+                return { kind: "single", value: await executeOpenaiEdit(ctx, request) };
+            } };
+        case "multimode": return { execute: async () => {
+                return { kind: "sequence", value: await executeOpenaiMultimode(ctx, request, progress) };
+            } };
     }
 }

package/lib/providers/execution/index.js

@@ -1,3 +1,4 @@
+import { getProviderAdapter } from "../adapters/index.js";
 import { assertDirectGrokKey } from "./admission.js";
 import { isLegacyExecutionRequest, prepareLegacyImageExecution } from "./legacy.js";
 import { isOpenaiRequest, prepareOpenaiExecution } from "../adapters/openaiExecution.js";
@@ -10,25 +11,18 @@ function prepareSelected(ctx, request, progress) {
         return prepareGrokExecution(ctx, request, progress);
     if (isGoogleRequest(request))
         return prepareGoogleExecution(ctx, request, progress);
+    const adapter = getProviderAdapter(ctx, request.provider);
+    if (adapter?.prepareImageExecution)
+        return adapter.prepareImageExecution(ctx, request, progress);
     if (isLegacyExecutionRequest(request))
         return prepareLegacyImageExecution(ctx, request, progress);
     throw new Error("Unreachable image execution provider");
 }
 export async function prepareImageExecution(ctx, request, progress) {
-    try {
-        assertDirectGrokKey(ctx, request.provider);
-        const prepared = await prepareSelected(ctx, request, progress);
-        return { execute: async () => {
-                try {
-                    assertDirectGrokKey(ctx, request.provider);
-                    return await prepared.execute();
-                }
-                catch (error) {
-                    throw error;
-                } // Preserve transport identity; callers own normalization.
-            } };
-    }
-    catch (error) {
-        throw error;
-    }
+    assertDirectGrokKey(ctx, request.provider);
+    const prepared = await prepareSelected(ctx, request, progress);
+    return { execute: async () => {
+            assertDirectGrokKey(ctx, request.provider);
+            return await prepared.execute();
+        } };
 }