cursor-opencode-provider 0.5.0 → 0.6.0

package/dist/plan-execution-kickoff.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Queue OpenCode's post-plan-exit kickoff after CreatePlan approval.
+ *
+ * Native `plan_exit` asks the user, then injects a synthetic user message with
+ * `agent: "build"` so a new turn starts implementing. Our CreatePlan → question
+ * path already asks; this module is the missing second half. A host plugin
+ * installs the prompt handler; the language model records a request after Yes,
+ * and the outer stream wrapper flushes it only after the current `doStream`
+ * result stream has settled. This prevents a second generation from starting
+ * while the continuation Run is still live.
+ */
+export type PlanExecutionKickoffInput = {
+    sessionID: string;
+    /** Filesystem path (or relative display path) of the approved plan. */
+    planPath: string;
+    /** Concrete Cursor Run that owns the approval. Guards recovery/supersession. */
+    cursorSessionID?: string;
+};
+export type PlanExecutionKickoffFn = (input: PlanExecutionKickoffInput) => void | Promise<void>;
+/** Upstream `PlanExitTool` wording — keep verbatim so behaviour matches OpenCode. */
+export declare function createPlanExecutionKickoffText(planPath: string): string;
+/**
+ * Prefer a worktree-relative label when the plan sits under `workspaceRoot`,
+ * matching OpenCode's `path.relative(instance.worktree, Session.plan(...))`.
+ * Otherwise keep the absolute path (global data `plans/` is outside the tree).
+ */
+export declare function formatPlanKickoffPath(planPath: string, workspaceRoot?: string): string;
+/** Decode a `file://` plan URI to a filesystem path; pass other strings through. */
+export declare function planPathFromUri(planUri: string): string;
+export type PlanExecutionKickoffState = PlanExecutionKickoffInput & {
+    status: "pending" | "failed";
+    attempts: number;
+    lastError?: string;
+};
+/** Install (or clear) the host kickoff. */
+export declare function setPlanExecutionKickoff(fn: PlanExecutionKickoffFn | undefined): void;
+export declare function hasPlanExecutionKickoff(): boolean;
+/** Record the approved plan; execution is flushed after the stream settles. */
+export declare function queuePlanExecutionKickoff(input: PlanExecutionKickoffInput): boolean;
+/**
+ * Run one pending kickoff only after the owning Cursor Run reached a terminal,
+ * idle state. Returns true only after successful host handoff.
+ */
+export declare function flushPlanExecutionKickoff(sessionID: string | undefined, options?: {
+    cursorSessionID?: string;
+    terminal?: boolean;
+    pumpActive?: boolean;
+    pendingExecs?: number;
+}): Promise<boolean>;
+/** Consume a user-visible warning on the next provider turn. */
+export declare function takePlanExecutionKickoffWarning(sessionID: string | undefined): string | undefined;
+/** Retry state remains explicit; no timer or automatic loop fires it. */
+export declare function planExecutionKickoffState(sessionID: string | undefined): PlanExecutionKickoffState | undefined;
+/** Test helper: clear the registered kickoff and pending approvals. */
+export declare function resetPlanExecutionKickoffForTests(): void;

package/dist/plan-execution-kickoff.js

@@ -0,0 +1,162 @@
+/**
+ * Queue OpenCode's post-plan-exit kickoff after CreatePlan approval.
+ *
+ * Native `plan_exit` asks the user, then injects a synthetic user message with
+ * `agent: "build"` so a new turn starts implementing. Our CreatePlan → question
+ * path already asks; this module is the missing second half. A host plugin
+ * installs the prompt handler; the language model records a request after Yes,
+ * and the outer stream wrapper flushes it only after the current `doStream`
+ * result stream has settled. This prevents a second generation from starting
+ * while the continuation Run is still live.
+ */
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { trace } from "./debug.js";
+/** Upstream `PlanExitTool` wording — keep verbatim so behaviour matches OpenCode. */
+export function createPlanExecutionKickoffText(planPath) {
+    const where = planPath.trim() || "the plan";
+    return `The plan at ${where} has been approved, you can now edit files. Execute the plan`;
+}
+/**
+ * Prefer a worktree-relative label when the plan sits under `workspaceRoot`,
+ * matching OpenCode's `path.relative(instance.worktree, Session.plan(...))`.
+ * Otherwise keep the absolute path (global data `plans/` is outside the tree).
+ */
+export function formatPlanKickoffPath(planPath, workspaceRoot) {
+    const absolute = planPath.trim();
+    if (!absolute)
+        return absolute;
+    const root = workspaceRoot?.trim();
+    if (!root)
+        return absolute;
+    const relative = path.relative(root, absolute);
+    if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {
+        return absolute;
+    }
+    return relative;
+}
+/** Decode a `file://` plan URI to a filesystem path; pass other strings through. */
+export function planPathFromUri(planUri) {
+    const raw = planUri.trim();
+    if (!raw)
+        return "";
+    if (raw.startsWith("file:")) {
+        try {
+            return fileURLToPath(raw);
+        }
+        catch {
+            return raw;
+        }
+    }
+    return raw;
+}
+let kickoff;
+const pending = new Map();
+const warnings = new Map();
+/** Install (or clear) the host kickoff. */
+export function setPlanExecutionKickoff(fn) {
+    kickoff = fn;
+}
+export function hasPlanExecutionKickoff() {
+    return kickoff !== undefined;
+}
+/** Record the approved plan; execution is flushed after the stream settles. */
+export function queuePlanExecutionKickoff(input) {
+    const sessionID = input.sessionID.trim();
+    const planPath = input.planPath.trim();
+    if (!sessionID || !planPath || !kickoff) {
+        trace(`plan-execution-kickoff: not queued sessionID=${JSON.stringify(sessionID)} ` +
+            `planPath=${JSON.stringify(planPath)} handler=${Boolean(kickoff)}`);
+        return false;
+    }
+    pending.set(sessionID, {
+        sessionID,
+        planPath,
+        ...(input.cursorSessionID ? { cursorSessionID: input.cursorSessionID } : {}),
+        status: "pending",
+        attempts: 0,
+    });
+    warnings.delete(sessionID);
+    trace(`plan-execution-kickoff: pending sessionID=${sessionID} ` +
+        `cursorSessionID=${input.cursorSessionID ?? ""} planPath=${planPath}`);
+    return true;
+}
+/**
+ * Run one pending kickoff only after the owning Cursor Run reached a terminal,
+ * idle state. Returns true only after successful host handoff.
+ */
+export async function flushPlanExecutionKickoff(sessionID, options = {}) {
+    const key = sessionID?.trim();
+    if (!key)
+        return false;
+    const state = pending.get(key);
+    if (!state)
+        return false;
+    if (options.terminal !== true || options.pumpActive || (options.pendingExecs ?? 0) > 0) {
+        trace(`plan-execution-kickoff: deferred sessionID=${key} terminal=${Boolean(options.terminal)} ` +
+            `pumpActive=${Boolean(options.pumpActive)} pending=${options.pendingExecs ?? 0}`);
+        return false;
+    }
+    if (state.cursorSessionID
+        && options.cursorSessionID
+        && state.cursorSessionID !== options.cursorSessionID) {
+        trace(`plan-execution-kickoff: skipped stale Run sessionID=${key} ` +
+            `owner=${state.cursorSessionID} terminal=${options.cursorSessionID}`);
+        return false;
+    }
+    const run = kickoff;
+    if (!run) {
+        const message = "The plan was approved, but this host cannot start its execution turn.";
+        state.status = "failed";
+        state.lastError = message;
+        warnings.set(key, message);
+        return false;
+    }
+    state.attempts += 1;
+    try {
+        await run({
+            sessionID: state.sessionID,
+            planPath: state.planPath,
+            ...(state.cursorSessionID ? { cursorSessionID: state.cursorSessionID } : {}),
+        });
+        pending.delete(key);
+        warnings.delete(key);
+        trace(`plan-execution-kickoff: queued sessionID=${key} planPath=${state.planPath}`);
+        return true;
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        const message = `The approved plan could not start execution: ${detail}. ` +
+            "The plan remains active and can be retried.";
+        state.status = "failed";
+        state.lastError = detail;
+        // A later explicit provider turn may retry after its own terminal boundary;
+        // do not keep pinning the retry to the now-finished Cursor Run.
+        delete state.cursorSessionID;
+        warnings.set(key, message);
+        trace(`plan-execution-kickoff: FAILED sessionID=${key} attempts=${state.attempts} err=${detail}`);
+        return false;
+    }
+}
+/** Consume a user-visible warning on the next provider turn. */
+export function takePlanExecutionKickoffWarning(sessionID) {
+    const key = sessionID?.trim();
+    if (!key)
+        return undefined;
+    const message = warnings.get(key);
+    if (message)
+        warnings.delete(key);
+    return message;
+}
+/** Retry state remains explicit; no timer or automatic loop fires it. */
+export function planExecutionKickoffState(sessionID) {
+    const key = sessionID?.trim();
+    const state = key ? pending.get(key) : undefined;
+    return state ? { ...state } : undefined;
+}
+/** Test helper: clear the registered kickoff and pending approvals. */
+export function resetPlanExecutionKickoffForTests() {
+    kickoff = undefined;
+    pending.clear();
+    warnings.clear();
+}

package/dist/plugin-opencode2.js

@@ -1,15 +1,18 @@
 import { CURSOR_PROVIDER_ID } from "./shared.js";
 import { createSdk, cursorApiBaseURL, cursorGetServerConfigTelemetryEnabled, isCursorPackage } from "./plugin-core.js";
-import { adoptCompatHostCacheDir, opencodeGlobalCacheDir } from "./context/paths.js";
+import { opencodeGlobalCacheDir } from "./context/paths.js";
 import { discoverModels, isCacheFresh, readCache } from "./models.js";
 import { resolveAgentUrl } from "./agent-url.js";
 import { sessionActivity } from "./activity.js";
 import { fetchOpenCodeWebSearchText } from "./web-tools.js";
+import { executeCursorImageSave, } from "./image-save.js";
+import { CURSOR_IMAGE_SAVE_TOOL } from "./protocol/generate-image.js";
 import { captureCursorShellResult, cursorShellOriginalCommand, prepareCursorShellArgs, releaseCursorShellEnv, sanitizeRegisteredCursorShellOutput, } from "./shell-timeout.js";
 import { applyCursorModels, applyCursorProvider } from "./opencode2/catalog.js";
 import { applyCursorIntegration, resolveCursorAccessToken } from "./opencode2/integration.js";
 import { markCompactionSession } from "./compaction-marker.js";
 import { markSessionDirectory } from "./session-directory.js";
+import { setPlanExecutionKickoff } from "./plan-execution-kickoff.js";
 /**
  * OpenCode 2.0 beta plugin.
  *
@@ -44,9 +47,12 @@ function toolExecutionID(event) {
 const plugin = {
     id: "cursor.provider",
     setup: async (ctx) => {
-        // Prefer OCP HostProfile.cacheDir when present; else XDG host heuristic.
-        await adoptCompatHostCacheDir();
         const cacheDir = opencodeGlobalCacheDir();
+        // The 2.0 SessionDomain has `prompt` but no agent-selection method, so it
+        // cannot faithfully reproduce classic plan_exit's `agent: "build"` kickoff.
+        // Leave the handler absent: the continuation reports an execution error and
+        // retains plan mode instead of returning false success.
+        setPlanExecutionKickoff(undefined);
         const registrations = [];
         const track = async (p) => {
             registrations.push(await p);
@@ -143,6 +149,48 @@ const plugin = {
                     };
                 },
             });
+            // Same handle-only commit tool as classic plugin.ts. Uses host-neutral
+            // executeCursorImageSave (not image-save-tool.ts) so this entrypoint never
+            // imports `@opencode-ai/plugin`'s classic `tool()` helper.
+            draft.add({
+                name: CURSOR_IMAGE_SAVE_TOOL,
+                description: "Save an image that Cursor generated during this session to its target path. "
+                    + "Takes only the id of an already-generated image — it cannot write arbitrary "
+                    + "files, and it is not a general-purpose file writer. You do not normally call "
+                    + "this: the Cursor provider issues it after an image is generated.",
+                input: {
+                    type: "object",
+                    properties: {
+                        image_id: {
+                            type: "string",
+                            description: "Id of the pending Cursor-generated image to save",
+                        },
+                    },
+                    required: ["image_id"],
+                    additionalProperties: false,
+                },
+                execute: async (input, context) => {
+                    const saveCtx = {
+                        worktree: typeof context?.worktree === "string" ? context.worktree : "",
+                        directory: typeof context?.directory === "string" ? context.directory : "",
+                        ask: typeof context?.ask === "function"
+                            ? context.ask.bind(context)
+                            : async () => {
+                                throw new Error("OpenCode 2.0 tool context did not provide ask(); cannot gate image save");
+                            },
+                    };
+                    const result = await executeCursorImageSave(input, saveCtx);
+                    if (typeof result === "string") {
+                        return { title: CURSOR_IMAGE_SAVE_TOOL, output: result, metadata: {} };
+                    }
+                    const typed = result;
+                    return {
+                        title: typed.title,
+                        output: typed.output,
+                        metadata: {},
+                    };
+                },
+            });
         }));
         // ── Shell timeout wrapper ────────────────────────────────────────────────
         await track(ctx.tool.hook("execute.before", (event) => {
@@ -249,6 +297,7 @@ const plugin = {
         return async () => {
             clearInterval(retry);
             unsubscribe?.();
+            setPlanExecutionKickoff(undefined);
             for (const registration of registrations.reverse()) {
                 await registration.dispose().catch(() => { });
             }

package/dist/plugin-v2.d.ts

@@ -1,9 +1,11 @@
-/**
- * OpenCode Effect / Promise v2 plugin.
- *
- * Wires the Cursor provider through `ctx.aisdk.sdk` / `ctx.aisdk.language`
- * (the V2 extension points). Auth still lives in the classic Hooks plugin
- * (`plugin.ts`) until OpenCode integrations fully replace provider OAuth.
- */
-declare const _default: import("@opencode-ai/plugin/v2/promise").Plugin;
-export default _default;
+type PromiseV2Plugin = {
+    id: string;
+    setup: (ctx: {
+        aisdk: {
+            sdk: (callback: (event: any) => void) => Promise<void>;
+            language: (callback: (event: any) => void) => Promise<void>;
+        };
+    }) => Promise<void>;
+};
+declare const plugin: PromiseV2Plugin;
+export default plugin;

package/dist/plugin-v2.js

@@ -1,20 +1,12 @@
-import { define } from "@opencode-ai/plugin/v2/promise";
 import { CURSOR_PROVIDER_ID } from "./shared.js";
 import { createSdk, isCursorPackage } from "./plugin-core.js";
-import { adoptCompatHostCacheDir } from "./context/paths.js";
-/**
- * OpenCode Effect / Promise v2 plugin.
- *
- * Wires the Cursor provider through `ctx.aisdk.sdk` / `ctx.aisdk.language`
- * (the V2 extension points). Auth still lives in the classic Hooks plugin
- * (`plugin.ts`) until OpenCode integrations fully replace provider OAuth.
- */
-export default define({
+/** OpenCode's v2/promise `define` is an identity function. */
+function define(plugin) {
+    return plugin;
+}
+const plugin = define({
     id: "cursor.provider",
     setup: async (ctx) => {
-        // Prefer OCP HostProfile.cacheDir when present; else XDG host heuristic.
-        // Explicit createCursor({ cacheDir }) / event.options.cacheDir still wins via LM.
-        await adoptCompatHostCacheDir();
         await ctx.aisdk.sdk((event) => {
             if (event.sdk)
                 return;
@@ -36,3 +28,4 @@ export default define({
         });
     },
 });
+export default plugin;

package/dist/plugin.d.ts

@@ -1,3 +1,12 @@
 import type { Hooks, PluginInput } from "@opencode-ai/plugin";
 export { modelInfoToConfig, modelsToConfig, thinkingSuffixBaseNames } from "./model-config.js";
+export declare function loadClassicTools(options?: {
+    importModule?: (specifier: string) => Promise<{
+        tool?: any;
+    }>;
+    configDirs?: string[];
+}): Promise<{
+    webSearch: any;
+    imageSave: any;
+}>;
 export declare function CursorPlugin(input: PluginInput): Promise<Hooks>;

package/dist/plugin.js

@@ -1,3 +1,5 @@
+import path from "node:path";
+import { pathToFileURL } from "node:url";
 import { CURSOR_COMPACTION_OPTION, CURSOR_PROVIDER_ID, CURSOR_WEBSITE_HOST, CURSOR_API_HOST } from "./shared.js";
 import { cursorApiBaseURL, cursorGetServerConfigTelemetryEnabled } from "./plugin-core.js";
 import { pollForTokens, exchangeApiKey, refreshAccessToken, isExpiringSoon, generatePkceParams, generatePkceChallenge, buildLoginUrl, decodeJwtExpiryMs } from "./auth.js";
@@ -7,18 +9,68 @@ import { readCache, discoverModels, isCacheFresh } from "./models.js";
 // host plugin imports so the OpenCode 2.0 entrypoint can share it.
 import { modelsToConfig } from "./model-config.js";
 export { modelInfoToConfig, modelsToConfig, thinkingSuffixBaseNames } from "./model-config.js";
-import { adoptCompatHostCacheDir, opencodeGlobalCacheDir } from "./context/paths.js";
+import { opencodeGlobalCacheDir, opencodeGlobalConfigDirs } from "./context/paths.js";
 import { readStoredAuth } from "./context/auth-store.js";
 import { resolveAgentUrl } from "./agent-url.js";
 import { captureCursorShellResult, cursorShellEnvForCall, cursorShellOriginalCommand, prepareCursorShellArgs, releaseCursorShellEnv, sanitizeRegisteredCursorShellOutput, setCursorShellPath, } from "./shell-timeout.js";
 import { sessionActivity } from "./activity.js";
-import { openCodeWebSearchTool } from "./web-search-tool.js";
+import { createOpenCodeWebSearchTool, openCodeWebSearchTool } from "./web-search-tool.js";
+import { createCursorImageSaveTool, cursorImageSaveTool } from "./image-save-tool.js";
+import { createPlanExecutionKickoffText, setPlanExecutionKickoff, } from "./plan-execution-kickoff.js";
 const MODULE_URL = new URL("./index.js", import.meta.url).href;
+export async function loadClassicTools(options = {}) {
+    const configDir = options.configDirs?.[0] ?? opencodeGlobalConfigDirs()[0];
+    const candidates = [
+        ...(configDir
+            ? [path.join(configDir, "node_modules", "@opencode-ai", "plugin", "dist", "index.js")]
+            : []),
+        "@opencode-ai/plugin",
+    ];
+    const importModule = options.importModule ?? ((specifier) => import(specifier));
+    // The global config copy is the host-owned installation; bare import is a fallback.
+    for (const candidate of candidates) {
+        try {
+            const specifier = path.win32.isAbsolute(candidate) && !path.isAbsolute(candidate)
+                ? new URL(`file:///${candidate.replaceAll("\\", "/")}`).href
+                : path.isAbsolute(candidate)
+                    ? pathToFileURL(candidate).href
+                    : candidate;
+            const module = await importModule(specifier);
+            if (typeof module.tool === "function" && module.tool.schema) {
+                const factory = { tool: module.tool, schema: module.tool.schema };
+                return {
+                    webSearch: createOpenCodeWebSearchTool(factory),
+                    imageSave: createCursorImageSaveTool(factory),
+                };
+            }
+        }
+        catch {
+            // Try the next host-owned/normal resolution location.
+        }
+    }
+    // `tool()` is an identity helper; the fallback definitions use plain JSON
+    // Schema accepted by OpenCode's legacy registry when no Zod helper is present.
+    return { webSearch: openCodeWebSearchTool, imageSave: cursorImageSaveTool };
+}
 export async function CursorPlugin(input) {
-    // Prefer strong OCP host identity when available; otherwise resolve from explicit host signals/install path.
-    await adoptCompatHostCacheDir();
     const cacheDir = opencodeGlobalCacheDir();
     const apiBaseURL = cursorApiBaseURL();
+    const classicTools = await loadClassicTools();
+    // After CreatePlan Yes, queue OpenCode's plan_exit-shaped synthetic turn so
+    // implementation starts. Failures stay in the kickoff module (trace only).
+    setPlanExecutionKickoff(async ({ sessionID, planPath }) => {
+        await input.client.session.promptAsync({
+            path: { id: sessionID },
+            body: {
+                agent: "build",
+                parts: [{
+                        type: "text",
+                        text: createPlanExecutionKickoffText(planPath),
+                        synthetic: true,
+                    }],
+            },
+        });
+    });
     // Last access token successfully resolved in this plugin instance. Config's
     // loadModels can only read OpenCode's durable store (auth.json /
     // OPENCODE_AUTH_CONTENT); auth.loader gets live credentials via getAuth().
@@ -140,7 +192,11 @@ export async function CursorPlugin(input) {
             // `websearch` is a reserved OpenCode id and is filtered for third-party
             // providers after plugin tools are merged. Use the collision-safe id
             // Cursor already sees so this host-side fallback survives that filter.
-            custom_websearch: openCodeWebSearchTool,
+            custom_websearch: classicTools.webSearch,
+            // Commits Cursor-generated image bytes, which cannot travel through the
+            // host's text `write`. Handle-only, so its presence in the catalog does
+            // not give any model a way to write arbitrary files — see image-save.ts.
+            cursor_image_save: classicTools.imageSave,
         },
         async event({ event }) {
             switch (event.type) {

package/dist/pricing-data.d.ts

@@ -74,10 +74,10 @@ export declare const CURSOR_MODEL_COSTS: {
         readonly cache_write: 3.75;
     };
     readonly "claude-sonnet-5": {
-        readonly input: 3;
-        readonly output: 15;
-        readonly cache_read: 0.3;
-        readonly cache_write: 3.75;
+        readonly input: 2;
+        readonly output: 10;
+        readonly cache_read: 0.2;
+        readonly cache_write: 2.5;
     };
     readonly "gemini-2.5-flash": {
         readonly input: 0.3;
@@ -104,6 +104,11 @@ export declare const CURSOR_MODEL_COSTS: {
         readonly output: 7.5;
         readonly cache_read: 0.15;
     };
+    readonly "gemini-3.7-flash": {
+        readonly input: 0.75;
+        readonly output: 3.5;
+        readonly cache_read: 0.075;
+    };
     readonly "glm-5.2": {
         readonly input: 1.4;
         readonly output: 4.4;
@@ -261,6 +266,10 @@ export declare const CURSOR_MODEL_CONTEXTS: {
         readonly maxContext: 200000;
         readonly maxContextForMaxMode: 1000000;
     };
+    readonly "gemini-3.7-flash": {
+        readonly maxContext: 200000;
+        readonly maxContextForMaxMode: 1000000;
+    };
     readonly "glm-5.2": {
         readonly maxContext: 200000;
     };
@@ -369,6 +378,9 @@ export declare const CURSOR_MODEL_CAPABILITIES: {
     readonly "gemini-3.6-flash": {
         readonly supportsImages: true;
     };
+    readonly "gemini-3.7-flash": {
+        readonly supportsImages: true;
+    };
     readonly "glm-5.2": {
         readonly supportsImages: false;
     };

package/dist/pricing-data.js

@@ -74,10 +74,10 @@ export const CURSOR_MODEL_COSTS = {
         "cache_write": 3.75
     },
     "claude-sonnet-5": {
-        "input": 3,
-        "output": 15,
-        "cache_read": 0.3,
-        "cache_write": 3.75
+        "input": 2,
+        "output": 10,
+        "cache_read": 0.2,
+        "cache_write": 2.5
     },
     "gemini-2.5-flash": {
         "input": 0.3,
@@ -104,6 +104,11 @@ export const CURSOR_MODEL_COSTS = {
         "output": 7.5,
         "cache_read": 0.15
     },
+    "gemini-3.7-flash": {
+        "input": 0.75,
+        "output": 3.5,
+        "cache_read": 0.075
+    },
     "glm-5.2": {
         "input": 1.4,
         "output": 4.4,
@@ -261,6 +266,10 @@ export const CURSOR_MODEL_CONTEXTS = {
         "maxContext": 200000,
         "maxContextForMaxMode": 1000000
     },
+    "gemini-3.7-flash": {
+        "maxContext": 200000,
+        "maxContextForMaxMode": 1000000
+    },
     "glm-5.2": {
         "maxContext": 200000
     },
@@ -369,6 +378,9 @@ export const CURSOR_MODEL_CAPABILITIES = {
     "gemini-3.6-flash": {
         "supportsImages": true
     },
+    "gemini-3.7-flash": {
+        "supportsImages": true
+    },
     "glm-5.2": {
         "supportsImages": false
     },