@uploadista/flow-images-replicate 0.0.3

package/.turbo/turbo-build.log

@@ -0,0 +1,5 @@
+
+
+> @uploadista/flow-images-replicate@0.0.2 build /Users/denislaboureyras/Documents/uploadista/dev/uploadista-workspace/uploadista-sdk/packages/flow/images/replicate
+> tsc -b
+

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 uploadista
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,236 @@
+# @uploadista/flow-images-replicate
+
+AI-powered image operations for Uploadista flows. Use Replicate's ML models for advanced image manipulation.
+
+## Overview
+
+Replicate integration enables AI image operations:
+
+- **Background Removal**: AI-powered background removal
+- **Upscaling**: Enhance image resolution
+- **Style Transfer**: Apply artistic styles
+- **Custom Models**: Use any Replicate model
+- **Serverless**: No GPU infrastructure needed
+
+Perfect for advanced image processing workflows.
+
+## Installation
+
+```bash
+npm install @uploadista/flow-images-replicate
+# or
+pnpm add @uploadista/flow-images-replicate
+```
+
+### Prerequisites
+
+- Replicate API token (get from replicate.com)
+- Node.js 18+
+
+## Quick Start
+
+```typescript
+import { imageAiPlugin } from "@uploadista/flow-images-replicate";
+
+const flow = {
+  nodes: [
+    { id: "input", type: "input" },
+    {
+      id: "remove-bg",
+      type: "background-removal",
+      params: { model: "rembg" },
+    },
+    { id: "s3", type: "s3" },
+    { id: "output", type: "output" },
+  ],
+};
+```
+
+## Features
+
+- ✅ **AI Models**: Background removal, upscaling, effects
+- ✅ **No GPU Needed**: Replicate handles compute
+- ✅ **Serverless**: Pay per request
+- ✅ **Webhook Support**: Async processing
+- ✅ **Custom Models**: Use any Replicate model
+
+## Node Types
+
+### Background Removal
+
+```typescript
+{
+  type: "remove-background",
+  params: {
+    model: "rembg",  // AI model
+    returnFormat: "png",
+  },
+}
+```
+
+### Upscaling
+
+```typescript
+{
+  type: "upscale",
+  params: {
+    scale: 4,  // 2x, 4x upscaling
+    model: "real-esrgan",
+  },
+}
+```
+
+### Style Transfer
+
+```typescript
+{
+  type: "style-transfer",
+  params: {
+    style: "oil-painting",
+    model: "arbitrary-style-transfer",
+  },
+}
+```
+
+## Configuration
+
+Set API token:
+
+```typescript
+export const config = {
+  replicate: {
+    apiToken: process.env.REPLICATE_API_TOKEN,
+  },
+};
+```
+
+## Use Cases
+
+- Remove backgrounds from product photos
+- Upscale low-resolution images
+- Apply artistic effects
+- Custom ML image processing
+- Batch AI operations
+
+## Examples
+
+### Product Image Processing
+
+```typescript
+const productFlow = {
+  nodes: [
+    { id: "input", type: "input" },
+    {
+      id: "remove-bg",
+      type: "remove-background",
+      params: { model: "rembg" },
+    },
+    {
+      id: "upscale",
+      type: "upscale",
+      params: { scale: 2, model: "real-esrgan" },
+    },
+    { id: "s3", type: "s3", params: { bucket: "products" } },
+    { id: "output", type: "output" },
+  ],
+  edges: [
+    { from: "input", to: "remove-bg" },
+    { from: "remove-bg", to: "upscale" },
+    { from: "upscale", to: "s3" },
+    { from: "s3", to: "output" },
+  ],
+};
+```
+
+### Creative Effects
+
+```typescript
+const creativeFlow = {
+  nodes: [
+    { id: "input", type: "input" },
+    {
+      id: "style",
+      type: "style-transfer",
+      params: {
+        style: "oil-painting",
+        model: "arbitrary-style-transfer",
+      },
+    },
+    { id: "upscale", type: "upscale", params: { scale: 2 } },
+    { id: "s3", type: "s3" },
+    { id: "output", type: "output" },
+  ],
+};
+```
+
+## Performance
+
+| Operation | Time |
+|-----------|------|
+| Background removal | 5-15s |
+| Upscaling (2x) | 10-20s |
+| Style transfer | 15-30s |
+| Async webhook | Variable |
+
+All operations asynchronous via webhook.
+
+## Cost
+
+Replicate pricing (varies by model):
+- Background removal: ~$0.001-0.002 per image
+- Upscaling: ~$0.01-0.05 per image
+- Style transfer: ~$0.02-0.10 per image
+
+## Best Practices
+
+### 1. Async Processing
+
+```typescript
+// Use webhooks for long-running AI ops
+{
+  type: "remove-background",
+  params: {
+    model: "rembg",
+    webhook: "https://yourapi.com/callbacks",
+    async: true,
+  },
+}
+```
+
+### 2. Batch Operations
+
+```typescript
+// Process multiple images in parallel
+const batch = [image1, image2, image3];
+const results = yield* Effect.all(
+  batch.map((img) => removeBackground(img))
+);
+```
+
+### 3. Error Handling
+
+```typescript
+// AI models may fail or timeout
+yield* removeBackground(image).pipe(
+  Effect.catch((error) => {
+    // Fallback to standard processing
+    return standardBackgroundRemoval(image);
+  })
+);
+```
+
+## Related Packages
+
+- [@uploadista/flow-images-nodes](../nodes) - Base types
+- [@uploadista/flow-images-sharp](../sharp) - Standard processing
+- [@uploadista/server](../../servers/server) - Upload server
+
+## License
+
+See [LICENSE](../../../LICENSE) in the main repository.
+
+## See Also
+
+- [Replicate Documentation](https://replicate.com/docs) - Replicate API
+- [FLOW_NODES.md](../FLOW_NODES.md) - All available nodes
+- [Replicate Models](https://replicate.com/explore) - Available AI models

package/dist/image-ai-plugin.d.ts

@@ -0,0 +1,42 @@
+import { UploadistaError } from "@uploadista/core/errors";
+import { type ImageAiContext, ImageAiPlugin } from "@uploadista/core/flow";
+import { Effect, Layer } from "effect";
+type ModelId = `${string}/${string}` | `${string}/${string}:${string}`;
+type ReplicateCredentials = {
+    apiKey: string;
+};
+type CredentialProvider = (context: ImageAiContext & {
+    serviceType: "replicate";
+}) => Effect.Effect<ReplicateCredentials, UploadistaError>;
+type PluginConfig = string | {
+    credentialProvider?: CredentialProvider;
+    useCredentialProviderService?: boolean;
+    removeBackgroundModelId?: ModelId;
+    describeImageModelId?: ModelId;
+};
+/**
+ * Create the Replicate ImageAI plugin
+ * Supports both static credentials (OSS) and dynamic credential providers (SaaS)
+ *
+ * @example
+ * // Static credentials (OSS)
+ * imageAiPlugin(process.env.REPLICATE_API_TOKEN)
+ *
+ * @example
+ * // Dynamic credentials with function (SaaS)
+ * imageAiPlugin({
+ *   credentialProvider: (context) => Effect.succeed({ apiKey: "..." })
+ * })
+ *
+ * @example
+ * // Dynamic credentials with Effect service (SaaS)
+ * imageAiPlugin({
+ *   useCredentialProviderService: true
+ * })
+ */
+export declare const imageAiPlugin: (config: PluginConfig, options?: {
+    removeBackgroundModelId?: ModelId;
+    describeImageModelId?: ModelId;
+}) => Layer.Layer<ImageAiPlugin, never, never>;
+export {};
+//# sourceMappingURL=image-ai-plugin.d.ts.map

package/dist/image-ai-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-ai-plugin.d.ts","sourceRoot":"","sources":["../src/image-ai-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,EAEL,KAAK,cAAc,EACnB,aAAa,EACd,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,MAAM,EAAE,KAAK,EAAU,MAAM,QAAQ,CAAC;AAG/C,KAAK,OAAO,GAAG,GAAG,MAAM,IAAI,MAAM,EAAE,GAAG,GAAG,MAAM,IAAI,MAAM,IAAI,MAAM,EAAE,CAAC;AAMvE,KAAK,oBAAoB,GAAG;IAC1B,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAGF,KAAK,kBAAkB,GAAG,CACxB,OAAO,EAAE,cAAc,GAAG;IAAE,WAAW,EAAE,WAAW,CAAA;CAAE,KACnD,MAAM,CAAC,MAAM,CAAC,oBAAoB,EAAE,eAAe,CAAC,CAAC;AAG1D,KAAK,YAAY,GACb,MAAM,GACN;IACE,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;IACxC,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC,CAAC;AAEN;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GACxB,QAAQ,YAAY,EACpB,UAAU;IACR,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC,6CAuJF,CAAC"}

package/dist/image-ai-plugin.js

@@ -0,0 +1,147 @@
+import { UploadistaError } from "@uploadista/core/errors";
+import { CredentialProvider as CredentialProviderService, ImageAiPlugin, } from "@uploadista/core/flow";
+import { Effect, Layer, Option } from "effect";
+import Replicate from "replicate";
+/**
+ * Create the Replicate ImageAI plugin
+ * Supports both static credentials (OSS) and dynamic credential providers (SaaS)
+ *
+ * @example
+ * // Static credentials (OSS)
+ * imageAiPlugin(process.env.REPLICATE_API_TOKEN)
+ *
+ * @example
+ * // Dynamic credentials with function (SaaS)
+ * imageAiPlugin({
+ *   credentialProvider: (context) => Effect.succeed({ apiKey: "..." })
+ * })
+ *
+ * @example
+ * // Dynamic credentials with Effect service (SaaS)
+ * imageAiPlugin({
+ *   useCredentialProviderService: true
+ * })
+ */
+export const imageAiPlugin = (config, options) => {
+    // Parse configuration
+    const isStatic = typeof config === "string";
+    const staticApiKey = isStatic ? config : null;
+    const credentialProvider = isStatic ? null : config.credentialProvider;
+    const useCredentialProviderService = isStatic
+        ? false
+        : config.useCredentialProviderService;
+    // Model IDs can come from either the config object or the options parameter
+    const removeBackgroundModelId = (isStatic
+        ? options?.removeBackgroundModelId
+        : config.removeBackgroundModelId) ||
+        "lucataco/remove-bg:95fcc2a26d3899cd6c2691c900465aaeff466285a65c14638cc5f36f34befaf1";
+    const describeImageModelId = (isStatic ? options?.describeImageModelId : config.describeImageModelId) ||
+        "zsxkib/blip-3:499bec581d8f64060fd695ec0c34d7595c6824c4118259aa8b0788e0d2d903e1";
+    // Helper to get API token (either static, from provider function, or from service)
+    const getApiToken = (context) => {
+        if (staticApiKey) {
+            return Effect.succeed(staticApiKey);
+        }
+        if (useCredentialProviderService) {
+            return Effect.gen(function* () {
+                const credentialProviderService = yield* Effect.serviceOption(CredentialProviderService);
+                if (Option.isNone(credentialProviderService)) {
+                    return yield* Effect.fail(UploadistaError.fromCode("UNKNOWN_ERROR", {
+                        cause: new Error("Credential provider service not found"),
+                    }));
+                }
+                else {
+                    const credentials = yield* credentialProviderService.value.getCredential({
+                        clientId: context.clientId,
+                        serviceType: "replicate",
+                    });
+                    if (typeof credentials === "object" &&
+                        credentials !== null &&
+                        "apiKey" in credentials &&
+                        typeof credentials.apiKey === "string") {
+                        return credentials.apiKey;
+                    }
+                }
+                return yield* Effect.fail(UploadistaError.fromCode("UNKNOWN_ERROR", {
+                    cause: new Error("Invalid credential format from service"),
+                }));
+            });
+        }
+        if (credentialProvider) {
+            return Effect.gen(function* () {
+                const credentials = yield* credentialProvider({
+                    ...context,
+                    serviceType: "replicate",
+                });
+                return credentials.apiKey;
+            });
+        }
+        return Effect.fail(UploadistaError.fromCode("UNKNOWN_ERROR", {
+            cause: new Error("No API credentials configured"),
+        }));
+    };
+    return Layer.succeed(ImageAiPlugin, ImageAiPlugin.of({
+        removeBackground: (inputUrl, context) => {
+            return Effect.gen(function* () {
+                // Get API token (static or from credential provider)
+                const apiToken = yield* getApiToken(context);
+                const output = yield* Effect.tryPromise({
+                    try: async () => {
+                        const replicate = new Replicate({
+                            auth: apiToken,
+                        });
+                        const input = {
+                            image: inputUrl,
+                        };
+                        console.log("input", input);
+                        return (await replicate.run(removeBackgroundModelId, {
+                            input,
+                        }));
+                    },
+                    catch: (error) => {
+                        console.log("error", error);
+                        return UploadistaError.fromCode("UNKNOWN_ERROR", {
+                            cause: error,
+                        });
+                    },
+                });
+                return { outputUrl: output.url() };
+            });
+        },
+        describeImage: (inputUrl, context) => {
+            return Effect.gen(function* () {
+                // Get API token (static or from credential provider)
+                const apiToken = yield* getApiToken(context);
+                const output = yield* Effect.tryPromise({
+                    try: async () => {
+                        const replicate = new Replicate({
+                            auth: apiToken,
+                        });
+                        return (await replicate.run(describeImageModelId, {
+                            input: {
+                                image: inputUrl,
+                                top_k: 50,
+                                top_p: 1,
+                                caption: false,
+                                question: "What is shown in the image?",
+                                do_sample: false,
+                                num_beams: 1,
+                                temperature: 1,
+                                system_prompt: "A chat between a curious user and an artificial intelligence assistant. The assistant gives helpful, detailed, and polite answers to the user's questions.",
+                                length_penalty: 1,
+                                max_new_tokens: 768,
+                                repetition_penalty: 1,
+                            },
+                        }));
+                    },
+                    catch: (error) => {
+                        return UploadistaError.fromCode("UNKNOWN_ERROR", {
+                            cause: error,
+                        });
+                    },
+                });
+                return { description: output };
+            });
+        },
+    }));
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./image-ai-plugin";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC"}

package/dist/index.js

@@ -0,0 +1 @@
+export * from "./image-ai-plugin";

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@uploadista/flow-images-replicate",
+  "type": "module",
+  "version": "0.0.3",
+  "description": "Replicate image AI processing service for Uploadista Flow",
+  "license": "MIT",
+  "author": "Uploadista",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "replicate": "1.3.0",
+    "effect": "3.18.4",
+    "zod": "4.1.12",
+    "@uploadista/core": "0.0.3"
+  },
+  "devDependencies": {
+    "@types/node": "24.8.1",
+    "@uploadista/typescript-config": "0.0.3"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "format": "biome format --write ./src",
+    "lint": "biome lint --write ./src",
+    "check": "biome check --write ./src"
+  }
+}

package/src/image-ai-plugin.ts

@@ -0,0 +1,211 @@
+import { UploadistaError } from "@uploadista/core/errors";
+import {
+  CredentialProvider as CredentialProviderService,
+  type ImageAiContext,
+  ImageAiPlugin,
+} from "@uploadista/core/flow";
+import { Effect, Layer, Option } from "effect";
+import Replicate from "replicate";
+
+type ModelId = `${string}/${string}` | `${string}/${string}:${string}`;
+
+type RemoveBackgroundOutput = {
+  url: () => string;
+};
+
+type ReplicateCredentials = {
+  apiKey: string;
+};
+
+// Credential provider function type
+type CredentialProvider = (
+  context: ImageAiContext & { serviceType: "replicate" },
+) => Effect.Effect<ReplicateCredentials, UploadistaError>;
+
+// Plugin configuration can be either a static API key or options with credential provider or service
+type PluginConfig =
+  | string
+  | {
+      credentialProvider?: CredentialProvider;
+      useCredentialProviderService?: boolean;
+      removeBackgroundModelId?: ModelId;
+      describeImageModelId?: ModelId;
+    };
+
+/**
+ * Create the Replicate ImageAI plugin
+ * Supports both static credentials (OSS) and dynamic credential providers (SaaS)
+ *
+ * @example
+ * // Static credentials (OSS)
+ * imageAiPlugin(process.env.REPLICATE_API_TOKEN)
+ *
+ * @example
+ * // Dynamic credentials with function (SaaS)
+ * imageAiPlugin({
+ *   credentialProvider: (context) => Effect.succeed({ apiKey: "..." })
+ * })
+ *
+ * @example
+ * // Dynamic credentials with Effect service (SaaS)
+ * imageAiPlugin({
+ *   useCredentialProviderService: true
+ * })
+ */
+export const imageAiPlugin = (
+  config: PluginConfig,
+  options?: {
+    removeBackgroundModelId?: ModelId;
+    describeImageModelId?: ModelId;
+  },
+) => {
+  // Parse configuration
+  const isStatic = typeof config === "string";
+  const staticApiKey = isStatic ? config : null;
+  const credentialProvider = isStatic ? null : config.credentialProvider;
+  const useCredentialProviderService = isStatic
+    ? false
+    : config.useCredentialProviderService;
+
+  // Model IDs can come from either the config object or the options parameter
+  const removeBackgroundModelId =
+    (isStatic
+      ? options?.removeBackgroundModelId
+      : config.removeBackgroundModelId) ||
+    "lucataco/remove-bg:95fcc2a26d3899cd6c2691c900465aaeff466285a65c14638cc5f36f34befaf1";
+  const describeImageModelId =
+    (isStatic ? options?.describeImageModelId : config.describeImageModelId) ||
+    "zsxkib/blip-3:499bec581d8f64060fd695ec0c34d7595c6824c4118259aa8b0788e0d2d903e1";
+
+  // Helper to get API token (either static, from provider function, or from service)
+  const getApiToken = (context: ImageAiContext) => {
+    if (staticApiKey) {
+      return Effect.succeed(staticApiKey);
+    }
+    if (useCredentialProviderService) {
+      return Effect.gen(function* () {
+        const credentialProviderService = yield* Effect.serviceOption(
+          CredentialProviderService,
+        );
+
+        if (Option.isNone(credentialProviderService)) {
+          return yield* Effect.fail(
+            UploadistaError.fromCode("UNKNOWN_ERROR", {
+              cause: new Error("Credential provider service not found"),
+            }),
+          );
+        } else {
+          const credentials =
+            yield* credentialProviderService.value.getCredential({
+              clientId: context.clientId,
+              serviceType: "replicate",
+            });
+
+          if (
+            typeof credentials === "object" &&
+            credentials !== null &&
+            "apiKey" in credentials &&
+            typeof credentials.apiKey === "string"
+          ) {
+            return credentials.apiKey;
+          }
+        }
+
+        return yield* Effect.fail(
+          UploadistaError.fromCode("UNKNOWN_ERROR", {
+            cause: new Error("Invalid credential format from service"),
+          }),
+        );
+      });
+    }
+    if (credentialProvider) {
+      return Effect.gen(function* () {
+        const credentials = yield* credentialProvider({
+          ...context,
+          serviceType: "replicate",
+        });
+        return credentials.apiKey;
+      });
+    }
+    return Effect.fail(
+      UploadistaError.fromCode("UNKNOWN_ERROR", {
+        cause: new Error("No API credentials configured"),
+      }),
+    );
+  };
+
+  return Layer.succeed(
+    ImageAiPlugin,
+    ImageAiPlugin.of({
+      removeBackground: (inputUrl, context) => {
+        return Effect.gen(function* () {
+          // Get API token (static or from credential provider)
+          const apiToken = yield* getApiToken(context);
+
+          const output = yield* Effect.tryPromise({
+            try: async () => {
+              const replicate = new Replicate({
+                auth: apiToken,
+              });
+
+              const input = {
+                image: inputUrl,
+              };
+
+              console.log("input", input);
+
+              return (await replicate.run(removeBackgroundModelId, {
+                input,
+              })) as RemoveBackgroundOutput;
+            },
+            catch: (error) => {
+              console.log("error", error);
+              return UploadistaError.fromCode("UNKNOWN_ERROR", {
+                cause: error,
+              });
+            },
+          });
+          return { outputUrl: output.url() };
+        });
+      },
+      describeImage: (inputUrl, context) => {
+        return Effect.gen(function* () {
+          // Get API token (static or from credential provider)
+          const apiToken = yield* getApiToken(context);
+
+          const output = yield* Effect.tryPromise({
+            try: async () => {
+              const replicate = new Replicate({
+                auth: apiToken,
+              });
+
+              return (await replicate.run(describeImageModelId, {
+                input: {
+                  image: inputUrl,
+                  top_k: 50,
+                  top_p: 1,
+                  caption: false,
+                  question: "What is shown in the image?",
+                  do_sample: false,
+                  num_beams: 1,
+                  temperature: 1,
+                  system_prompt:
+                    "A chat between a curious user and an artificial intelligence assistant. The assistant gives helpful, detailed, and polite answers to the user's questions.",
+                  length_penalty: 1,
+                  max_new_tokens: 768,
+                  repetition_penalty: 1,
+                },
+              })) as unknown as string;
+            },
+            catch: (error) => {
+              return UploadistaError.fromCode("UNKNOWN_ERROR", {
+                cause: error,
+              });
+            },
+          });
+          return { description: output };
+        });
+      },
+    }),
+  );
+};

package/src/index.ts

@@ -0,0 +1 @@
+export * from "./image-ai-plugin";

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "@uploadista/typescript-config/server.json",
+  "compilerOptions": {
+    "baseUrl": "./",
+    "paths": {
+      "@/*": ["./src/*"]
+    },
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "lib": ["ESNext", "DOM", "DOM.Iterable"],
+    "types": []
+  },
+  "include": ["src"]
+}

package/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["./src/image-ai-plugin.ts","./src/index.ts"],"version":"5.9.3"}