@fre4x/grok 1.0.46 → 1.0.49

package/README.md

@@ -18,6 +18,8 @@ xAI's Grok is more than an LLM. It's a real-time sensor for the global conscious
 
 Search tools support `limit` and `offset` pagination and return normalized results with citations.
 
+Image generation responses include direct MCP `image` content blocks when media can be embedded. Video responses include direct MCP embedded `resource` blobs because MCP does not define a dedicated `video` content block.
+
 ## Configuration
 
 Required environment variable:
@@ -29,6 +31,10 @@ Mock mode is supported for local development and offline validation:
 MOCK=true npx @fre4x/grok
 ```
 
+Optional media embedding controls:
+- `GROK_MAX_EMBEDDED_MEDIA_BYTES`: Maximum bytes to inline into MCP `content` blocks. Defaults to `5242880`.
+- `GROK_MEDIA_FETCH_TIMEOUT_MS`: Timeout for downloading generated media before embedding. Defaults to `15000`.
+
 ## Deploy
 
 ```json

package/dist/index.js

@@ -18436,7 +18436,8 @@ var require_follow_redirects = __commonJS({
 });
 
 // src/index.ts
-import { pathToFileURL } from "node:url";
+import { realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
 
 // ../packages/shared/dist/errors.js
 function createApiError(message, statusCode) {
@@ -43634,6 +43635,16 @@ var z3 = external_exports || zod_default || zod_exports;
 var XAI_API_KEY = process.env.XAI_API_KEY;
 var aspectRatioValues = ["1:1", "16:9", "9:16"];
 var MAX_SEARCH_RESULTS = 100;
+var MAX_EMBEDDED_MEDIA_BYTES = Number.parseInt(
+  process.env.GROK_MAX_EMBEDDED_MEDIA_BYTES || "5242880",
+  10
+);
+var MEDIA_FETCH_TIMEOUT_MS = Number.parseInt(
+  process.env.GROK_MEDIA_FETCH_TIMEOUT_MS || "15000",
+  10
+);
+var MOCK_IMAGE_BASE64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==";
+var MOCK_VIDEO_BASE64 = "AAAAHGZ0eXBpc29tAAAAAGlzb21pc28yYXZjMQ==";
 var xSearchSchema = paginationSchema.extend({
   query: z3.string().min(1).max(500),
   allowed_handles: z3.array(z3.string().min(1).max(50)).max(10).optional(),
@@ -43984,6 +43995,97 @@ function asArray(value) {
 function asString(value) {
   return typeof value === "string" && value.trim() ? value : void 0;
 }
+function inferMimeTypeFromUrl(url3, kind) {
+  try {
+    const pathname = new URL(url3).pathname.toLowerCase();
+    if (pathname.endsWith(".png")) return "image/png";
+    if (pathname.endsWith(".jpg") || pathname.endsWith(".jpeg")) {
+      return "image/jpeg";
+    }
+    if (pathname.endsWith(".webp")) return "image/webp";
+    if (pathname.endsWith(".gif")) return "image/gif";
+    if (pathname.endsWith(".mp4")) return "video/mp4";
+    if (pathname.endsWith(".webm")) return "video/webm";
+    if (pathname.endsWith(".mov")) return "video/quicktime";
+  } catch {
+  }
+  return kind === "image" ? "image/png" : "video/mp4";
+}
+function normalizeMediaMimeType(value, kind, sourceUrl) {
+  if (typeof value === "string") {
+    const trimmed = value.split(";", 1)[0]?.trim().toLowerCase();
+    if (trimmed && (kind === "image" && trimmed.startsWith("image/") || kind === "video" && trimmed.startsWith("video/"))) {
+      return trimmed;
+    }
+  }
+  return inferMimeTypeFromUrl(sourceUrl, kind) || "application/octet-stream";
+}
+async function fetchMediaAsBase64(sourceUrl, kind, client = axios_default) {
+  try {
+    const response = await client.get(sourceUrl, {
+      responseType: "arraybuffer",
+      timeout: MEDIA_FETCH_TIMEOUT_MS,
+      maxContentLength: MAX_EMBEDDED_MEDIA_BYTES,
+      maxBodyLength: MAX_EMBEDDED_MEDIA_BYTES
+    });
+    const buffer = Buffer.from(response.data);
+    if (buffer.byteLength === 0 || buffer.byteLength > MAX_EMBEDDED_MEDIA_BYTES) {
+      return void 0;
+    }
+    return {
+      data: buffer.toString("base64"),
+      mimeType: normalizeMediaMimeType(
+        response.headers["content-type"],
+        kind,
+        sourceUrl
+      )
+    };
+  } catch {
+    return void 0;
+  }
+}
+async function buildImageContent(imageUrl, client = axios_default) {
+  const media = await fetchMediaAsBase64(imageUrl, "image", client);
+  if (!media) {
+    return void 0;
+  }
+  return {
+    type: "image",
+    data: media.data,
+    mimeType: media.mimeType
+  };
+}
+async function buildVideoContent(videoUrl, client = axios_default) {
+  const media = await fetchMediaAsBase64(videoUrl, "video", client);
+  if (!media) {
+    return void 0;
+  }
+  return {
+    type: "resource",
+    resource: {
+      uri: videoUrl,
+      mimeType: media.mimeType,
+      blob: media.data
+    }
+  };
+}
+function buildMockImageContent() {
+  return {
+    type: "image",
+    data: MOCK_IMAGE_BASE64,
+    mimeType: "image/png"
+  };
+}
+function buildMockVideoContent(videoUrl) {
+  return {
+    type: "resource",
+    resource: {
+      uri: videoUrl,
+      mimeType: "video/mp4",
+      blob: MOCK_VIDEO_BASE64
+    }
+  };
+}
 function extractNestedText(value) {
   if (typeof value === "string") {
     return value.trim() ? [value.trim()] : [];
@@ -44215,9 +44317,12 @@ function parseArguments(toolName, schema, args) {
   }
   return { data: parsed.data };
 }
-function toolResult(text, structuredContent) {
+function toolResult(text, structuredContent, extraContent = []) {
   return {
-    content: [{ type: "text", text }],
+    content: [
+      { type: "text", text },
+      ...extraContent
+    ],
     structuredContent
   };
 }
@@ -44370,7 +44475,14 @@ async function handleToolCall(name, args, client = xaiClient) {
           prompt,
           aspect_ratio
         );
-        return toolResult(renderImagine(output), output);
+        const mediaContent = IS_MOCK ? [buildMockImageContent()] : (await Promise.all(
+          output.images.map(
+            (image) => buildImageContent(image.url)
+          )
+        )).filter(
+          (item) => item !== void 0
+        );
+        return toolResult(renderImagine(output), output, mediaContent);
       }
       case "grok_animate": {
         const parsed = parseArguments(name, animateSchema, args);
@@ -44390,7 +44502,16 @@ async function handleToolCall(name, args, client = xaiClient) {
           aspect_ratio,
           image_url
         );
-        return toolResult(renderVideoGeneration(output), output);
+        const mediaContent = output.video_url === void 0 ? [] : IS_MOCK ? [buildMockVideoContent(output.video_url)] : (await Promise.all([
+          buildVideoContent(output.video_url)
+        ])).filter(
+          (item) => item !== void 0
+        );
+        return toolResult(
+          renderVideoGeneration(output),
+          output,
+          mediaContent
+        );
       }
       case "grok_check_video_status": {
         const parsed = parseArguments(name, videoStatusSchema, args);
@@ -44400,7 +44521,16 @@ async function handleToolCall(name, args, client = xaiClient) {
         const { request_id } = parsed.data;
         const rawResponse = IS_MOCK ? MOCK_FIXTURES.grok_check_video_status : (await client.get(`/videos/status/${request_id}`)).data;
         const output = normalizeVideoStatusResponse(rawResponse);
-        return toolResult(renderVideoStatus(output), output);
+        const mediaContent = output.video_url === void 0 ? [] : IS_MOCK ? [buildMockVideoContent(output.video_url)] : (await Promise.all([
+          buildVideoContent(output.video_url)
+        ])).filter(
+          (item) => item !== void 0
+        );
+        return toolResult(
+          renderVideoStatus(output),
+          output,
+          mediaContent
+        );
       }
       default:
         throw new McpError(
@@ -44431,8 +44561,18 @@ async function runServer() {
   await server.connect(transport);
   console.error("Grok MCP Server running on stdio");
 }
-var isMainModule = Boolean(process.argv[1]) && import.meta.url === pathToFileURL(process.argv[1]).href;
-if (isMainModule) {
+function isMainModule(url3) {
+  if (!process.argv[1]) return false;
+  try {
+    const scriptPath = fileURLToPath(url3);
+    const realScriptPath = realpathSync(scriptPath);
+    const realArgvPath = realpathSync(process.argv[1]);
+    return realScriptPath === realArgvPath;
+  } catch {
+    return false;
+  }
+}
+if (isMainModule(import.meta.url)) {
   runServer().catch((error48) => {
     console.error("Fatal error running server:", error48);
     process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fre4x/grok",
-  "version": "1.0.46",
+  "version": "1.0.49",
   "description": "An MCP server for xAI (Grok) with search and generation capabilities.",
   "type": "module",
   "main": "dist/index.js",
@@ -16,7 +16,7 @@
     "start": "node dist/index.js",
     "dev": "tsx src/index.ts",
     "watch": "tsc -w",
-    "inspector": "cross-env MOCK=true npx @modelcontextprotocol/inspector node dist/index.js",
+    "inspector": "node ../scripts/run-official-inspector.mjs node dist/index.js",
     "prepublishOnly": "npm run build && npm run typecheck",
     "test": "vitest run --passWithNoTests --exclude dist"
   },