@indreamai/openclaw-plugin 0.1.0

package/dist/index.js

@@ -0,0 +1,781 @@
+import {
+  DEFAULT_BASE_URL,
+  DEFAULT_POLL_INTERVAL_MS,
+  DEFAULT_TIMEOUT_MS,
+  PLUGIN_DESCRIPTION,
+  PLUGIN_ID,
+  PLUGIN_NAME,
+  __spreadProps,
+  __spreadValues,
+  buildMissingApiKeyMessage,
+  pluginConfigSchema,
+  resolvePluginConfig
+} from "./chunk-ENGUNMFI.js";
+
+// src/index.ts
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+
+// src/tools.ts
+import { IndreamClient } from "@indreamai/client";
+import { Type } from "@sinclair/typebox";
+
+// src/results.ts
+import { APIError } from "@indreamai/client";
+var stringifyPayload = (payload) => {
+  try {
+    return JSON.stringify(payload, null, 2);
+  } catch (e) {
+    return String(payload);
+  }
+};
+var createJsonResult = (payload) => {
+  return {
+    content: [
+      {
+        type: "text",
+        text: stringifyPayload(payload)
+      }
+    ],
+    details: payload
+  };
+};
+var normalizeToolError = (error) => {
+  if (error instanceof APIError) {
+    return {
+      status: "failed",
+      message: error.message,
+      detail: error.detail,
+      errorName: error.name,
+      errorCode: error.errorCode,
+      errorType: error.type,
+      httpStatus: error.status,
+      retriable: error.status === 429 || error.status >= 500
+    };
+  }
+  if (error instanceof Error) {
+    return {
+      status: "failed",
+      message: error.message,
+      detail: error.message,
+      errorName: error.name
+    };
+  }
+  return {
+    status: "failed",
+    message: "Unknown plugin error",
+    detail: "Unknown plugin error"
+  };
+};
+var createErrorResult = (error) => {
+  return createJsonResult(normalizeToolError(error));
+};
+
+// src/upload-source.ts
+import { readFile } from "fs/promises";
+import { basename, extname, resolve } from "path";
+import { lookup as lookupMimeType } from "mime-types";
+var readOptionalString = (value) => {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed ? trimmed : void 0;
+};
+var inferMimeTypeFromPath = (value) => {
+  const mimeType = lookupMimeType(value);
+  return typeof mimeType === "string" ? mimeType : void 0;
+};
+var parseContentDispositionFilename = (value) => {
+  if (!value) {
+    return void 0;
+  }
+  const utf8Match = value.match(/filename\*\s*=\s*UTF-8''([^;]+)/i);
+  if (utf8Match == null ? void 0 : utf8Match[1]) {
+    try {
+      return decodeURIComponent(utf8Match[1].trim().replace(/^"+|"+$/g, ""));
+    } catch (e) {
+      return utf8Match[1].trim().replace(/^"+|"+$/g, "");
+    }
+  }
+  const basicMatch = value.match(/filename\s*=\s*"?(.*?)"?(?:;|$)/i);
+  return readOptionalString(basicMatch == null ? void 0 : basicMatch[1]);
+};
+var inferFilenameFromUrl = (value) => {
+  const parsed = new URL(value);
+  return readOptionalString(basename(parsed.pathname));
+};
+var inferFilenameFromPath = (value) => {
+  return readOptionalString(basename(value));
+};
+var resolveLocalFilePath = (value, workspaceDir) => {
+  if (value.startsWith("~")) {
+    throw new Error('filePath does not support "~". Use an absolute path or a workspace-relative path.');
+  }
+  return value.startsWith("/") ? value : resolve(workspaceDir || process.cwd(), value);
+};
+var resolveUploadSource = async (params) => {
+  var _a;
+  const filePath = readOptionalString(params.filePath);
+  const sourceUrl = readOptionalString(params.sourceUrl);
+  const explicitFilename = readOptionalString(params.filename);
+  const explicitContentType = readOptionalString(params.contentType);
+  if (filePath && sourceUrl || !filePath && !sourceUrl) {
+    throw new Error("Exactly one of filePath or sourceUrl must be provided.");
+  }
+  if (filePath) {
+    if (!params.allowLocalPaths) {
+      throw new Error("Local file uploads are disabled in the plugin config.");
+    }
+    const resolvedPath = resolveLocalFilePath(filePath, params.workspaceDir);
+    const body2 = await readFile(resolvedPath);
+    const filename2 = explicitFilename || inferFilenameFromPath(resolvedPath);
+    if (!filename2) {
+      throw new Error("Could not infer filename from filePath. Pass filename explicitly.");
+    }
+    const contentType2 = explicitContentType || inferMimeTypeFromPath(filename2) || inferMimeTypeFromPath(resolvedPath);
+    if (!contentType2) {
+      throw new Error(
+        `Could not infer contentType for ${basename(resolvedPath) || resolvedPath}. Pass contentType explicitly.`
+      );
+    }
+    return {
+      body: body2,
+      filename: filename2,
+      contentType: contentType2,
+      sourceKind: "filePath",
+      source: resolvedPath
+    };
+  }
+  if (!params.allowRemoteUrls) {
+    throw new Error("Remote URL uploads are disabled in the plugin config.");
+  }
+  const parsedUrl = new URL(sourceUrl);
+  if (!["http:", "https:"].includes(parsedUrl.protocol)) {
+    throw new Error("sourceUrl must use http or https.");
+  }
+  const fetchFn = params.fetchFn || fetch;
+  const response = await fetchFn(parsedUrl, {
+    redirect: "follow"
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to download sourceUrl. HTTP ${response.status}.`);
+  }
+  const body = Buffer.from(await response.arrayBuffer());
+  const filename = explicitFilename || parseContentDispositionFilename(response.headers.get("content-disposition")) || inferFilenameFromUrl(sourceUrl) || `download${extname(parsedUrl.pathname) || ".bin"}`;
+  const contentType = explicitContentType || readOptionalString((_a = response.headers.get("content-type")) == null ? void 0 : _a.split(";")[0]) || inferMimeTypeFromPath(filename) || inferMimeTypeFromPath(parsedUrl.pathname);
+  if (!contentType) {
+    throw new Error("Could not infer contentType from sourceUrl. Pass contentType explicitly.");
+  }
+  return {
+    body,
+    filename,
+    contentType,
+    sourceKind: "sourceUrl",
+    source: sourceUrl
+  };
+};
+
+// src/tools.ts
+var EXPORT_RATIO_VALUES = ["16:9", "9:16", "1:1", "4:3", "3:4", "custom"];
+var EXPORT_FORMAT_VALUES = ["mp4", "webm"];
+var FPS_VALUES = [30, 60];
+var readRecord = (value) => {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+};
+var readOptionalString2 = (params, key) => {
+  const value = params[key];
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed ? trimmed : void 0;
+};
+var readRequiredString = (params, key) => {
+  const value = readOptionalString2(params, key);
+  if (!value) {
+    throw new Error(`${key} is required.`);
+  }
+  return value;
+};
+var readOptionalInteger = (params, key) => {
+  const value = params[key];
+  if (typeof value !== "number" || !Number.isInteger(value)) {
+    return void 0;
+  }
+  return value;
+};
+var readOptionalNumber = (params, key) => {
+  const value = params[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+};
+var readRequiredNumber = (params, key) => {
+  const value = readOptionalNumber(params, key);
+  if (value === void 0) {
+    throw new Error(`${key} is required.`);
+  }
+  return value;
+};
+var readRequiredLiteralString = (params, key, values) => {
+  const value = readRequiredString(params, key);
+  if (!values.includes(value)) {
+    throw new Error(`${key} must be one of ${values.join(", ")}.`);
+  }
+  return value;
+};
+var readRequiredLiteralNumber = (params, key, values) => {
+  const value = readRequiredNumber(params, key);
+  if (!values.includes(value)) {
+    throw new Error(`${key} must be one of ${values.join(", ")}.`);
+  }
+  return value;
+};
+var readOptionalStringRecord = (params, key) => {
+  const value = params[key];
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(`${key} must be an object of string values.`);
+  }
+  const result = {};
+  for (const [entryKey, entryValue] of Object.entries(value)) {
+    if (typeof entryValue !== "string") {
+      throw new Error(`${key}.${entryKey} must be a string.`);
+    }
+    result[entryKey] = entryValue;
+  }
+  return result;
+};
+var readEditorState = (params, key) => {
+  const value = params[key];
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(`${key} must be an object.`);
+  }
+  return value;
+};
+var createClient = (config) => {
+  if (!config.apiKey) {
+    throw new Error(buildMissingApiKeyMessage());
+  }
+  return new IndreamClient({
+    apiKey: config.apiKey,
+    baseURL: config.baseURL || DEFAULT_BASE_URL,
+    timeout: config.timeoutMs || DEFAULT_TIMEOUT_MS,
+    pollIntervalMs: config.pollIntervalMs || DEFAULT_POLL_INTERVAL_MS
+  });
+};
+var ensureClient = (api, deps) => {
+  const config = resolvePluginConfig(api.pluginConfig);
+  const clientFactory = deps.createClient || createClient;
+  return {
+    config,
+    client: clientFactory(config)
+  };
+};
+var executeWithClient = async (api, deps, handler) => {
+  try {
+    const { client, config } = ensureClient(api, deps);
+    return createJsonResult(await handler(client, config));
+  } catch (error) {
+    return createErrorResult(error);
+  }
+};
+var executeUploadWithClient = async (api, deps, ctx, params) => {
+  try {
+    const { client, config } = ensureClient(api, deps);
+    const uploadSource = await resolveUploadSource({
+      filePath: readOptionalString2(params, "filePath"),
+      sourceUrl: readOptionalString2(params, "sourceUrl"),
+      filename: readOptionalString2(params, "filename"),
+      contentType: readOptionalString2(params, "contentType"),
+      workspaceDir: ctx.workspaceDir,
+      allowLocalPaths: config.uploads.allowLocalPaths,
+      allowRemoteUrls: config.uploads.allowRemoteUrls,
+      fetchFn: deps.fetchFn
+    });
+    const asset = await client.uploads.upload(uploadSource.body, {
+      filename: uploadSource.filename,
+      contentType: uploadSource.contentType,
+      projectId: readOptionalString2(params, "projectId")
+    });
+    return createJsonResult(__spreadProps(__spreadValues({}, asset), {
+      uploadSource: {
+        kind: uploadSource.sourceKind,
+        source: uploadSource.source
+      },
+      editorAssetMapping: {
+        assetId: asset.assetId,
+        remoteUrl: asset.fileUrl,
+        remoteKey: asset.fileKey,
+        filename: asset.filename,
+        type: asset.type
+      }
+    }));
+  } catch (error) {
+    return createErrorResult(error);
+  }
+};
+var exportRatioSchema = Type.Union(EXPORT_RATIO_VALUES.map((value) => Type.Literal(value)));
+var exportFormatSchema = Type.Union(EXPORT_FORMAT_VALUES.map((value) => Type.Literal(value)));
+var fpsSchema = Type.Union(FPS_VALUES.map((value) => Type.Literal(value)));
+var paginationSchema = {
+  pageSize: Type.Optional(Type.Integer({ minimum: 1 })),
+  pageCursor: Type.Optional(Type.String())
+};
+var registerIndreamTools = (api, deps = {}) => {
+  const required = [];
+  const optional = [];
+  const withDefaultLabel = (name, tool) => {
+    if (typeof tool === "function") {
+      return ((ctx) => {
+        const created = tool(ctx);
+        if (!created) {
+          return created;
+        }
+        if (Array.isArray(created)) {
+          return created.map((item) => __spreadProps(__spreadValues({}, item), {
+            label: item.label || item.name || name
+          }));
+        }
+        return __spreadProps(__spreadValues({}, created), {
+          label: created.label || created.name || name
+        });
+      });
+    }
+    return __spreadProps(__spreadValues({}, tool), {
+      label: tool.label || tool.name || name
+    });
+  };
+  const register = (name, tool, toolIsOptional = false) => {
+    api.registerTool(
+      withDefaultLabel(name, tool),
+      toolIsOptional ? { optional: true } : void 0
+    );
+    const collection = toolIsOptional ? optional : required;
+    collection.push({
+      name,
+      optional: toolIsOptional
+    });
+  };
+  register("indream_editor_capabilities", {
+    name: "indream_editor_capabilities",
+    label: "Indream Editor Capabilities",
+    description: "Fetch the current Indream editor capability catalog.",
+    parameters: Type.Object({}),
+    async execute() {
+      return await executeWithClient(api, deps, async (client) => {
+        return await client.editor.capabilities();
+      });
+    }
+  });
+  register("indream_editor_validate", {
+    name: "indream_editor_validate",
+    label: "Validate Indream Editor JSON",
+    description: "Validate an Indream editor JSON payload before saving or exporting.",
+    parameters: Type.Object({
+      editorState: Type.Unknown()
+    }),
+    async execute(_id, rawParams) {
+      const params = readRecord(rawParams);
+      return await executeWithClient(api, deps, async (client) => {
+        return await client.editor.validate(readEditorState(params, "editorState"));
+      });
+    }
+  });
+  register("indream_projects_list", {
+    name: "indream_projects_list",
+    label: "List Indream Projects",
+    description: "List Indream projects.",
+    parameters: Type.Object(__spreadValues({}, paginationSchema)),
+    async execute(_id, rawParams) {
+      const params = readRecord(rawParams);
+      return await executeWithClient(api, deps, async (client) => {
+        return await client.projects.list({
+          pageSize: readOptionalInteger(params, "pageSize"),
+          pageCursor: readOptionalString2(params, "pageCursor")
+        });
+      });
+    }
+  });
+  register("indream_projects_get", {
+    name: "indream_projects_get",
+    label: "Get Indream Project",
+    description: "Get a single Indream project, including editorState.",
+    parameters: Type.Object({
+      projectId: Type.String()
+    }),
+    async execute(_id, rawParams) {
+      const params = readRecord(rawParams);
+      return await executeWithClient(api, deps, async (client) => {
+        return await client.projects.get(readRequiredString(params, "projectId"));
+      });
+    }
+  });
+  register("indream_projects_list_assets", {
+    name: "indream_projects_list_assets",
+    label: "List Indream Project Assets",
+    description: "List assets attached to a project.",
+    parameters: Type.Object(__spreadValues({
+      projectId: Type.String()
+    }, paginationSchema)),
+    async execute(_id, rawParams) {
+      const params = readRecord(rawParams);
+      return await executeWithClient(api, deps, async (client) => {
+        return await client.projects.listAssets({
+          projectId: readRequiredString(params, "projectId"),
+          pageSize: readOptionalInteger(params, "pageSize"),
+          pageCursor: readOptionalString2(params, "pageCursor")
+        });
+      });
+    }
+  });
+  register("indream_assets_get", {
+    name: "indream_assets_get",
+    label: "Get Indream Asset",
+    description: "Fetch a reusable Indream asset.",
+    parameters: Type.Object({
+      assetId: Type.String()
+    }),
+    async execute(_id, rawParams) {
+      const params = readRecord(rawParams);
+      return await executeWithClient(api, deps, async (client) => {
+        return await client.assets.get(readRequiredString(params, "assetId"));
+      });
+    }
+  });
+  register("indream_exports_get", {
+    name: "indream_exports_get",
+    label: "Get Indream Export",
+    description: "Fetch a single export task.",
+    parameters: Type.Object({
+      taskId: Type.String()
+    }),
+    async execute(_id, rawParams) {
+      const params = readRecord(rawParams);
+      return await executeWithClient(api, deps, async (client) => {
+        return await client.exports.get(readRequiredString(params, "taskId"));
+      });
+    }
+  });
+  register("indream_exports_list", {
+    name: "indream_exports_list",
+    label: "List Indream Exports",
+    description: "List export tasks.",
+    parameters: Type.Object(__spreadProps(__spreadValues({}, paginationSchema), {
+      createdByApiKeyId: Type.Optional(Type.String())
+    })),
+    async execute(_id, rawParams) {
+      const params = readRecord(rawParams);
+      return await executeWithClient(api, deps, async (client) => {
+        return await client.exports.list({
+          pageSize: readOptionalInteger(params, "pageSize"),
+          pageCursor: readOptionalString2(params, "pageCursor"),
+          createdByApiKeyId: readOptionalString2(params, "createdByApiKeyId")
+        });
+      });
+    }
+  });
+  register("indream_exports_wait", {
+    name: "indream_exports_wait",
+    label: "Wait For Indream Export",
+    description: "Poll an export task until it reaches a terminal state.",
+    parameters: Type.Object({
+      taskId: Type.String(),
+      timeoutMs: Type.Optional(Type.Integer({ minimum: 1 })),
+      pollIntervalMs: Type.Optional(Type.Integer({ minimum: 1 }))
+    }),
+    async execute(_id, rawParams) {
+      const params = readRecord(rawParams);
+      return await executeWithClient(api, deps, async (client) => {
+        return await client.exports.wait(readRequiredString(params, "taskId"), {
+          timeoutMs: readOptionalInteger(params, "timeoutMs"),
+          pollIntervalMs: readOptionalInteger(params, "pollIntervalMs")
+        });
+      });
+    }
+  });
+  register(
+    "indream_projects_create",
+    {
+      name: "indream_projects_create",
+      label: "Create Indream Project",
+      description: "Create a new persisted Indream project.",
+      parameters: Type.Object({
+        title: Type.Optional(Type.String()),
+        description: Type.Optional(Type.String()),
+        editorState: Type.Unknown(),
+        stateVersion: Type.Optional(Type.String()),
+        idempotencyKey: Type.Optional(Type.String())
+      }),
+      async execute(_id, rawParams) {
+        const params = readRecord(rawParams);
+        return await executeWithClient(api, deps, async (client) => {
+          var _a;
+          return await client.projects.create(
+            {
+              title: readOptionalString2(params, "title"),
+              description: (_a = readOptionalString2(params, "description")) != null ? _a : null,
+              editorState: readEditorState(params, "editorState"),
+              stateVersion: readOptionalString2(params, "stateVersion")
+            },
+            {
+              idempotencyKey: readOptionalString2(params, "idempotencyKey")
+            }
+          );
+        });
+      }
+    },
+    true
+  );
+  register(
+    "indream_projects_update",
+    {
+      name: "indream_projects_update",
+      label: "Update Indream Project",
+      description: "Update project title and description.",
+      parameters: Type.Object({
+        projectId: Type.String(),
+        title: Type.Optional(Type.String()),
+        description: Type.Optional(Type.String())
+      }),
+      async execute(_id, rawParams) {
+        const params = readRecord(rawParams);
+        return await executeWithClient(api, deps, async (client) => {
+          var _a;
+          return await client.projects.update(readRequiredString(params, "projectId"), {
+            title: readOptionalString2(params, "title"),
+            description: (_a = readOptionalString2(params, "description")) != null ? _a : null
+          });
+        });
+      }
+    },
+    true
+  );
+  register(
+    "indream_projects_sync",
+    {
+      name: "indream_projects_sync",
+      label: "Sync Indream Project",
+      description: "Replace the latest persisted editorState for a project.",
+      parameters: Type.Object({
+        projectId: Type.String(),
+        editorState: Type.Unknown(),
+        stateVersion: Type.Optional(Type.String())
+      }),
+      async execute(_id, rawParams) {
+        const params = readRecord(rawParams);
+        return await executeWithClient(api, deps, async (client) => {
+          return await client.projects.sync(readRequiredString(params, "projectId"), {
+            editorState: readEditorState(params, "editorState"),
+            stateVersion: readOptionalString2(params, "stateVersion")
+          });
+        });
+      }
+    },
+    true
+  );
+  register(
+    "indream_projects_delete",
+    {
+      name: "indream_projects_delete",
+      label: "Delete Indream Project",
+      description: "Delete a project.",
+      parameters: Type.Object({
+        projectId: Type.String()
+      }),
+      async execute(_id, rawParams) {
+        const params = readRecord(rawParams);
+        return await executeWithClient(api, deps, async (client) => {
+          return await client.projects.delete(readRequiredString(params, "projectId"));
+        });
+      }
+    },
+    true
+  );
+  register(
+    "indream_projects_add_asset",
+    {
+      name: "indream_projects_add_asset",
+      label: "Add Asset To Indream Project",
+      description: "Attach an existing asset to a project.",
+      parameters: Type.Object({
+        projectId: Type.String(),
+        assetId: Type.String()
+      }),
+      async execute(_id, rawParams) {
+        const params = readRecord(rawParams);
+        return await executeWithClient(api, deps, async (client) => {
+          return await client.projects.addAsset(
+            readRequiredString(params, "projectId"),
+            readRequiredString(params, "assetId")
+          );
+        });
+      }
+    },
+    true
+  );
+  register(
+    "indream_projects_remove_asset",
+    {
+      name: "indream_projects_remove_asset",
+      label: "Remove Asset From Indream Project",
+      description: "Detach an asset from a project.",
+      parameters: Type.Object({
+        projectId: Type.String(),
+        assetId: Type.String()
+      }),
+      async execute(_id, rawParams) {
+        const params = readRecord(rawParams);
+        return await executeWithClient(api, deps, async (client) => {
+          return await client.projects.removeAsset(
+            readRequiredString(params, "projectId"),
+            readRequiredString(params, "assetId")
+          );
+        });
+      }
+    },
+    true
+  );
+  register(
+    "indream_assets_upload",
+    (ctx) => ({
+      name: "indream_assets_upload",
+      label: "Upload Indream Asset",
+      description: "Upload a local file path or remote HTTP/HTTPS URL and return editor JSON asset mapping fields.",
+      parameters: Type.Object({
+        filePath: Type.Optional(Type.String()),
+        sourceUrl: Type.Optional(Type.String()),
+        filename: Type.Optional(Type.String()),
+        contentType: Type.Optional(Type.String()),
+        projectId: Type.Optional(Type.String())
+      }),
+      async execute(_id, rawParams) {
+        const params = readRecord(rawParams);
+        return await executeUploadWithClient(api, deps, ctx, params);
+      }
+    }),
+    true
+  );
+  register(
+    "indream_assets_delete",
+    {
+      name: "indream_assets_delete",
+      label: "Delete Indream Asset",
+      description: "Delete an asset.",
+      parameters: Type.Object({
+        assetId: Type.String()
+      }),
+      async execute(_id, rawParams) {
+        const params = readRecord(rawParams);
+        return await executeWithClient(api, deps, async (client) => {
+          return await client.assets.delete(readRequiredString(params, "assetId"));
+        });
+      }
+    },
+    true
+  );
+  register(
+    "indream_exports_create",
+    {
+      name: "indream_exports_create",
+      label: "Create Indream Export",
+      description: "Create a stateless export directly from editor JSON.",
+      parameters: Type.Object({
+        editorState: Type.Unknown(),
+        stateVersion: Type.Optional(Type.String()),
+        clientTaskId: Type.Optional(Type.String()),
+        fps: fpsSchema,
+        compositionWidth: Type.Optional(Type.Integer({ minimum: 1 })),
+        compositionHeight: Type.Optional(Type.Integer({ minimum: 1 })),
+        ratio: exportRatioSchema,
+        scale: Type.Number({ exclusiveMinimum: 0 }),
+        format: exportFormatSchema,
+        callbackUrl: Type.Optional(Type.String()),
+        callbackHeaders: Type.Optional(Type.Record(Type.String(), Type.String())),
+        idempotencyKey: Type.Optional(Type.String())
+      }),
+      async execute(_id, rawParams) {
+        const params = readRecord(rawParams);
+        return await executeWithClient(api, deps, async (client) => {
+          return await client.exports.create(
+            {
+              editorState: readEditorState(params, "editorState"),
+              stateVersion: readOptionalString2(params, "stateVersion"),
+              clientTaskId: readOptionalString2(params, "clientTaskId"),
+              fps: readRequiredLiteralNumber(params, "fps", FPS_VALUES),
+              compositionWidth: readOptionalInteger(params, "compositionWidth"),
+              compositionHeight: readOptionalInteger(params, "compositionHeight"),
+              ratio: readRequiredLiteralString(params, "ratio", EXPORT_RATIO_VALUES),
+              scale: readRequiredNumber(params, "scale"),
+              format: readRequiredLiteralString(params, "format", EXPORT_FORMAT_VALUES),
+              callbackUrl: readOptionalString2(params, "callbackUrl"),
+              callbackHeaders: readOptionalStringRecord(params, "callbackHeaders")
+            },
+            {
+              idempotencyKey: readOptionalString2(params, "idempotencyKey")
+            }
+          );
+        });
+      }
+    },
+    true
+  );
+  register(
+    "indream_projects_create_export",
+    {
+      name: "indream_projects_create_export",
+      label: "Create Indream Project Export",
+      description: "Create an export task from the latest saved project state.",
+      parameters: Type.Object({
+        projectId: Type.String(),
+        clientTaskId: Type.Optional(Type.String()),
+        fps: fpsSchema,
+        ratio: exportRatioSchema,
+        scale: Type.Number({ exclusiveMinimum: 0 }),
+        format: exportFormatSchema,
+        callbackUrl: Type.Optional(Type.String()),
+        callbackHeaders: Type.Optional(Type.Record(Type.String(), Type.String())),
+        idempotencyKey: Type.Optional(Type.String())
+      }),
+      async execute(_id, rawParams) {
+        const params = readRecord(rawParams);
+        return await executeWithClient(api, deps, async (client) => {
+          return await client.projects.createExport(
+            readRequiredString(params, "projectId"),
+            {
+              clientTaskId: readOptionalString2(params, "clientTaskId"),
+              fps: readRequiredLiteralNumber(params, "fps", FPS_VALUES),
+              ratio: readRequiredLiteralString(params, "ratio", EXPORT_RATIO_VALUES),
+              scale: readRequiredNumber(params, "scale"),
+              format: readRequiredLiteralString(params, "format", EXPORT_FORMAT_VALUES),
+              callbackUrl: readOptionalString2(params, "callbackUrl"),
+              callbackHeaders: readOptionalStringRecord(params, "callbackHeaders")
+            },
+            {
+              idempotencyKey: readOptionalString2(params, "idempotencyKey")
+            }
+          );
+        });
+      }
+    },
+    true
+  );
+  return {
+    required,
+    optional
+  };
+};
+
+// src/index.ts
+var index_default = definePluginEntry({
+  id: PLUGIN_ID,
+  name: PLUGIN_NAME,
+  description: PLUGIN_DESCRIPTION,
+  configSchema: pluginConfigSchema,
+  register(api) {
+    registerIndreamTools(api);
+  }
+});
+export {
+  index_default as default
+};