@translateimage/mcp-server 1.0.0

package/dist/src/schemas/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../src/schemas/common.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,kBAAkB,aAE6B,CAAC;AAE7D;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0BmC,CAAC;AAEjE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/dist/src/schemas/common.js

@@ -0,0 +1,31 @@
+import { z } from "zod";
+export const LanguageCodeSchema = z
+    .string()
+    .describe("Language code (e.g., 'en', 'ja', 'zh', 'es').");
+/**
+ * Image input schema - handles URL, base64, or data URLs
+ * Refinements:
+ * - Requires either url OR base64 (at least one)
+ * - If base64 is raw (not starting with "data:"), mimeType is required
+ * - If base64 starts with "data:", mimeType is extracted automatically
+ */
+export const ImageInputSchema = z
+    .object({
+    url: z.string().url().optional().describe("Image URL (HTTP/HTTPS)"),
+    base64: z
+        .string()
+        .optional()
+        .describe("Base64-encoded image data. Can be raw base64 or data URL (data:image/png;base64,...)"),
+    mimeType: z
+        .enum(["image/jpeg", "image/png", "image/webp", "image/gif"])
+        .optional()
+        .describe("MIME type of the image. Required if base64 is raw (not a data URL). Ignored if base64 is a data URL."),
+})
+    .refine((data) => data.url || data.base64, "Either 'url' or 'base64' must be provided")
+    .refine((data) => {
+    // If base64 is provided and is NOT a data URL, mimeType is required
+    if (data.base64 && !data.base64.startsWith("data:")) {
+        return !!data.mimeType;
+    }
+    return true;
+}, "mimeType is required when base64 is raw (not a data URL)");

package/dist/src/schemas/image-to-text.d.ts

@@ -0,0 +1,69 @@
+import { z } from "zod";
+/**
+ * Image to text input schema
+ */
+export declare const ImageToTextInputSchema: z.ZodObject<{
+    image: z.ZodEffects<z.ZodEffects<z.ZodObject<{
+        url: z.ZodOptional<z.ZodString>;
+        base64: z.ZodOptional<z.ZodString>;
+        mimeType: z.ZodOptional<z.ZodEnum<["image/jpeg", "image/png", "image/webp", "image/gif"]>>;
+    }, "strip", z.ZodTypeAny, {
+        url?: string | undefined;
+        base64?: string | undefined;
+        mimeType?: "image/jpeg" | "image/png" | "image/webp" | "image/gif" | undefined;
+    }, {
+        url?: string | undefined;
+        base64?: string | undefined;
+        mimeType?: "image/jpeg" | "image/png" | "image/webp" | "image/gif" | undefined;
+    }>, {
+        url?: string | undefined;
+        base64?: string | undefined;
+        mimeType?: "image/jpeg" | "image/png" | "image/webp" | "image/gif" | undefined;
+    }, {
+        url?: string | undefined;
+        base64?: string | undefined;
+        mimeType?: "image/jpeg" | "image/png" | "image/webp" | "image/gif" | undefined;
+    }>, {
+        url?: string | undefined;
+        base64?: string | undefined;
+        mimeType?: "image/jpeg" | "image/png" | "image/webp" | "image/gif" | undefined;
+    }, {
+        url?: string | undefined;
+        base64?: string | undefined;
+        mimeType?: "image/jpeg" | "image/png" | "image/webp" | "image/gif" | undefined;
+    }>;
+    targetLanguages: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    image: {
+        url?: string | undefined;
+        base64?: string | undefined;
+        mimeType?: "image/jpeg" | "image/png" | "image/webp" | "image/gif" | undefined;
+    };
+    targetLanguages?: string[] | undefined;
+}, {
+    image: {
+        url?: string | undefined;
+        base64?: string | undefined;
+        mimeType?: "image/jpeg" | "image/png" | "image/webp" | "image/gif" | undefined;
+    };
+    targetLanguages?: string[] | undefined;
+}>;
+export type ImageToTextInput = z.infer<typeof ImageToTextInputSchema>;
+/**
+ * Image to text output schema
+ */
+export declare const ImageToTextOutputSchema: z.ZodObject<{
+    extractedText: z.ZodString;
+    detectedLanguage: z.ZodOptional<z.ZodString>;
+    translations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    extractedText: string;
+    detectedLanguage?: string | undefined;
+    translations?: Record<string, string> | undefined;
+}, {
+    extractedText: string;
+    detectedLanguage?: string | undefined;
+    translations?: Record<string, string> | undefined;
+}>;
+export type ImageToTextOutput = z.infer<typeof ImageToTextOutputSchema>;
+//# sourceMappingURL=image-to-text.d.ts.map

package/dist/src/schemas/image-to-text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-to-text.d.ts","sourceRoot":"","sources":["../../../src/schemas/image-to-text.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;EAYlC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC"}

package/dist/src/schemas/image-to-text.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { ImageInputSchema, LanguageCodeSchema } from "./common.js";
+/**
+ * Image to text input schema
+ */
+export const ImageToTextInputSchema = z.object({
+    image: ImageInputSchema.describe("Image to extract text from (URL or base64)"),
+    targetLanguages: z
+        .array(LanguageCodeSchema)
+        .optional()
+        .describe("Target languages for translation. If provided, extracted text will be translated to these languages."),
+});
+/**
+ * Image to text output schema
+ */
+export const ImageToTextOutputSchema = z.object({
+    extractedText: z.string().describe("Text extracted from the image"),
+    detectedLanguage: z
+        .string()
+        .optional()
+        .describe("Detected language of the extracted text"),
+    translations: z
+        .record(z.string())
+        .optional()
+        .describe("Translations of extracted text. Keys are language codes, values are translated text."),
+});

package/dist/src/schemas/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./common.js";
+export * from "./translate.js";
+export * from "./ocr.js";
+export * from "./text-removal.js";
+export * from "./image-to-text.js";
+export * from "./shopify.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/schemas/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/schemas/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,UAAU,CAAC;AACzB,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC"}

package/dist/src/schemas/index.js

@@ -0,0 +1,6 @@
+export * from "./common.js";
+export * from "./translate.js";
+export * from "./ocr.js";
+export * from "./text-removal.js";
+export * from "./image-to-text.js";
+export * from "./shopify.js";

package/dist/src/schemas/ocr.d.ts

@@ -0,0 +1,333 @@
+import { z } from "zod";
+export declare const OcrWordSchema: z.ZodObject<{
+    boundingBox: z.ZodArray<z.ZodNumber, "many">;
+    text: z.ZodString;
+    confidence: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    text: string;
+    boundingBox: number[];
+    confidence: number;
+}, {
+    text: string;
+    boundingBox: number[];
+    confidence: number;
+}>;
+export type OcrWord = z.infer<typeof OcrWordSchema>;
+export declare const OcrLineSchema: z.ZodObject<{
+    boundingBox: z.ZodArray<z.ZodNumber, "many">;
+    text: z.ZodString;
+    words: z.ZodArray<z.ZodObject<{
+        boundingBox: z.ZodArray<z.ZodNumber, "many">;
+        text: z.ZodString;
+        confidence: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        text: string;
+        boundingBox: number[];
+        confidence: number;
+    }, {
+        text: string;
+        boundingBox: number[];
+        confidence: number;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    text: string;
+    boundingBox: number[];
+    words: {
+        text: string;
+        boundingBox: number[];
+        confidence: number;
+    }[];
+}, {
+    text: string;
+    boundingBox: number[];
+    words: {
+        text: string;
+        boundingBox: number[];
+        confidence: number;
+    }[];
+}>;
+export type OcrLine = z.infer<typeof OcrLineSchema>;
+export declare const OcrDetectedLanguageSchema: z.ZodObject<{
+    language: z.ZodString;
+    code: z.ZodString;
+    confidence: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    confidence: number;
+    language: string;
+}, {
+    code: string;
+    confidence: number;
+    language: string;
+}>;
+export type OcrDetectedLanguage = z.infer<typeof OcrDetectedLanguageSchema>;
+export declare const OcrParagraphSchema: z.ZodObject<{
+    boundingBox: z.ZodArray<z.ZodNumber, "many">;
+    text: z.ZodString;
+    lines: z.ZodArray<z.ZodObject<{
+        boundingBox: z.ZodArray<z.ZodNumber, "many">;
+        text: z.ZodString;
+        words: z.ZodArray<z.ZodObject<{
+            boundingBox: z.ZodArray<z.ZodNumber, "many">;
+            text: z.ZodString;
+            confidence: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            text: string;
+            boundingBox: number[];
+            confidence: number;
+        }, {
+            text: string;
+            boundingBox: number[];
+            confidence: number;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        text: string;
+        boundingBox: number[];
+        words: {
+            text: string;
+            boundingBox: number[];
+            confidence: number;
+        }[];
+    }, {
+        text: string;
+        boundingBox: number[];
+        words: {
+            text: string;
+            boundingBox: number[];
+            confidence: number;
+        }[];
+    }>, "many">;
+    detectedLanguage: z.ZodObject<{
+        language: z.ZodString;
+        code: z.ZodString;
+        confidence: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        code: string;
+        confidence: number;
+        language: string;
+    }, {
+        code: string;
+        confidence: number;
+        language: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    text: string;
+    boundingBox: number[];
+    lines: {
+        text: string;
+        boundingBox: number[];
+        words: {
+            text: string;
+            boundingBox: number[];
+            confidence: number;
+        }[];
+    }[];
+    detectedLanguage: {
+        code: string;
+        confidence: number;
+        language: string;
+    };
+}, {
+    text: string;
+    boundingBox: number[];
+    lines: {
+        text: string;
+        boundingBox: number[];
+        words: {
+            text: string;
+            boundingBox: number[];
+            confidence: number;
+        }[];
+    }[];
+    detectedLanguage: {
+        code: string;
+        confidence: number;
+        language: string;
+    };
+}>;
+export type OcrParagraph = z.infer<typeof OcrParagraphSchema>;
+/**
+ * OCR input schema
+ */
+export declare const OcrInputSchema: z.ZodObject<{
+    image: z.ZodEffects<z.ZodEffects<z.ZodObject<{
+        url: z.ZodOptional<z.ZodString>;
+        base64: z.ZodOptional<z.ZodString>;
+        mimeType: z.ZodOptional<z.ZodEnum<["image/jpeg", "image/png", "image/webp", "image/gif"]>>;
+    }, "strip", z.ZodTypeAny, {
+        url?: string | undefined;
+        base64?: string | undefined;
+        mimeType?: "image/jpeg" | "image/png" | "image/webp" | "image/gif" | undefined;
+    }, {
+        url?: string | undefined;
+        base64?: string | undefined;
+        mimeType?: "image/jpeg" | "image/png" | "image/webp" | "image/gif" | undefined;
+    }>, {
+        url?: string | undefined;
+        base64?: string | undefined;
+        mimeType?: "image/jpeg" | "image/png" | "image/webp" | "image/gif" | undefined;
+    }, {
+        url?: string | undefined;
+        base64?: string | undefined;
+        mimeType?: "image/jpeg" | "image/png" | "image/webp" | "image/gif" | undefined;
+    }>, {
+        url?: string | undefined;
+        base64?: string | undefined;
+        mimeType?: "image/jpeg" | "image/png" | "image/webp" | "image/gif" | undefined;
+    }, {
+        url?: string | undefined;
+        base64?: string | undefined;
+        mimeType?: "image/jpeg" | "image/png" | "image/webp" | "image/gif" | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    image: {
+        url?: string | undefined;
+        base64?: string | undefined;
+        mimeType?: "image/jpeg" | "image/png" | "image/webp" | "image/gif" | undefined;
+    };
+}, {
+    image: {
+        url?: string | undefined;
+        base64?: string | undefined;
+        mimeType?: "image/jpeg" | "image/png" | "image/webp" | "image/gif" | undefined;
+    };
+}>;
+export type OcrInput = z.infer<typeof OcrInputSchema>;
+/**
+ * OCR output schema
+ */
+export declare const OcrOutputSchema: z.ZodObject<{
+    paragraphs: z.ZodArray<z.ZodObject<{
+        boundingBox: z.ZodArray<z.ZodNumber, "many">;
+        text: z.ZodString;
+        lines: z.ZodArray<z.ZodObject<{
+            boundingBox: z.ZodArray<z.ZodNumber, "many">;
+            text: z.ZodString;
+            words: z.ZodArray<z.ZodObject<{
+                boundingBox: z.ZodArray<z.ZodNumber, "many">;
+                text: z.ZodString;
+                confidence: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                text: string;
+                boundingBox: number[];
+                confidence: number;
+            }, {
+                text: string;
+                boundingBox: number[];
+                confidence: number;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            text: string;
+            boundingBox: number[];
+            words: {
+                text: string;
+                boundingBox: number[];
+                confidence: number;
+            }[];
+        }, {
+            text: string;
+            boundingBox: number[];
+            words: {
+                text: string;
+                boundingBox: number[];
+                confidence: number;
+            }[];
+        }>, "many">;
+        detectedLanguage: z.ZodObject<{
+            language: z.ZodString;
+            code: z.ZodString;
+            confidence: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            code: string;
+            confidence: number;
+            language: string;
+        }, {
+            code: string;
+            confidence: number;
+            language: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        text: string;
+        boundingBox: number[];
+        lines: {
+            text: string;
+            boundingBox: number[];
+            words: {
+                text: string;
+                boundingBox: number[];
+                confidence: number;
+            }[];
+        }[];
+        detectedLanguage: {
+            code: string;
+            confidence: number;
+            language: string;
+        };
+    }, {
+        text: string;
+        boundingBox: number[];
+        lines: {
+            text: string;
+            boundingBox: number[];
+            words: {
+                text: string;
+                boundingBox: number[];
+                confidence: number;
+            }[];
+        }[];
+        detectedLanguage: {
+            code: string;
+            confidence: number;
+            language: string;
+        };
+    }>, "many">;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    angle: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    width: number;
+    height: number;
+    paragraphs: {
+        text: string;
+        boundingBox: number[];
+        lines: {
+            text: string;
+            boundingBox: number[];
+            words: {
+                text: string;
+                boundingBox: number[];
+                confidence: number;
+            }[];
+        }[];
+        detectedLanguage: {
+            code: string;
+            confidence: number;
+            language: string;
+        };
+    }[];
+    angle: number;
+}, {
+    width: number;
+    height: number;
+    paragraphs: {
+        text: string;
+        boundingBox: number[];
+        lines: {
+            text: string;
+            boundingBox: number[];
+            words: {
+                text: string;
+                boundingBox: number[];
+                confidence: number;
+            }[];
+        }[];
+        detectedLanguage: {
+            code: string;
+            confidence: number;
+            language: string;
+        };
+    }[];
+    angle: number;
+}>;
+export type OcrOutput = z.infer<typeof OcrOutputSchema>;
+//# sourceMappingURL=ocr.d.ts.map

package/dist/src/schemas/ocr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ocr.d.ts","sourceRoot":"","sources":["../../../src/schemas/ocr.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,aAAa;;;;;;;;;;;;EAMxB,CAAC;AAEH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAEpD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMxB,CAAC;AAEH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAEpD,eAAO,MAAM,yBAAyB;;;;;;;;;;;;EAIpC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAS7B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIzB,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAO1B,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/dist/src/schemas/ocr.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { ImageInputSchema } from "./common.js";
+export const OcrWordSchema = z.object({
+    boundingBox: z
+        .array(z.number())
+        .describe("Bounding box coordinates [x1, y1, x2, y2]"),
+    text: z.string().describe("Word text"),
+    confidence: z.number().describe("Confidence score (0-1)"),
+});
+export const OcrLineSchema = z.object({
+    boundingBox: z
+        .array(z.number())
+        .describe("Bounding box coordinates [x1, y1, x2, y2]"),
+    text: z.string().describe("Line text"),
+    words: z.array(OcrWordSchema).describe("Array of words in the line"),
+});
+export const OcrDetectedLanguageSchema = z.object({
+    language: z.string().describe("Language name"),
+    code: z.string().describe("Language code"),
+    confidence: z.number().describe("Confidence score (0-1)"),
+});
+export const OcrParagraphSchema = z.object({
+    boundingBox: z
+        .array(z.number())
+        .describe("Bounding box coordinates [x1, y1, x2, y2]"),
+    text: z.string().describe("Paragraph text"),
+    lines: z.array(OcrLineSchema).describe("Array of lines in the paragraph"),
+    detectedLanguage: OcrDetectedLanguageSchema.describe("Detected language information"),
+});
+/**
+ * OCR input schema
+ */
+export const OcrInputSchema = z.object({
+    image: ImageInputSchema.describe("Image to extract text from (URL or base64)"),
+});
+/**
+ * OCR output schema
+ */
+export const OcrOutputSchema = z.object({
+    paragraphs: z
+        .array(OcrParagraphSchema)
+        .describe("Array of detected paragraphs with text and bounding boxes"),
+    width: z.number().describe("Image width in pixels"),
+    height: z.number().describe("Image height in pixels"),
+    angle: z.number().describe("Detected text angle/rotation in degrees"),
+});