@fre4x/grok 1.0.47 → 1.0.50

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

@@ -43635,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(),
@@ -43985,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()] : [];
@@ -44216,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
   };
 }
@@ -44274,20 +44378,24 @@ function normalizeVideoGenerationResponse(raw, prompt, aspectRatio, imageUrl) {
     request_id: asString(raw.request_id) || "unknown",
     status: asString(raw.status) || "unknown",
     image_url: imageUrl,
-    video_url: asString(raw.video_url)
+    video_url: extractVideoUrl(raw)
   };
 }
-function normalizeVideoStatusResponse(raw) {
+function extractVideoUrl(raw) {
+  const nestedVideo = raw.video;
+  return asString(raw.video_url) || (isRecord(nestedVideo) ? asString(nestedVideo.url) : void 0);
+}
+function normalizeVideoStatusResponse(raw, requestId) {
   if (!isRecord(raw)) {
     return {
-      request_id: "unknown",
+      request_id: requestId,
       status: "unknown"
     };
   }
   return {
-    request_id: asString(raw.request_id) || "unknown",
+    request_id: asString(raw.request_id) || requestId,
     status: asString(raw.status) || "unknown",
-    video_url: asString(raw.video_url)
+    video_url: extractVideoUrl(raw)
   };
 }
 async function handleToolCall(name, args, client = xaiClient) {
@@ -44371,7 +44479,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, client)
+          )
+        )).filter(
+          (item) => item !== void 0
+        );
+        return toolResult(renderImagine(output), output, mediaContent);
       }
       case "grok_animate": {
         const parsed = parseArguments(name, animateSchema, args);
@@ -44391,7 +44506,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, client)
+        ])).filter(
+          (item) => item !== void 0
+        );
+        return toolResult(
+          renderVideoGeneration(output),
+          output,
+          mediaContent
+        );
       }
       case "grok_check_video_status": {
         const parsed = parseArguments(name, videoStatusSchema, args);
@@ -44399,9 +44523,21 @@ async function handleToolCall(name, args, client = xaiClient) {
           return parsed.error;
         }
         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 rawResponse = IS_MOCK ? MOCK_FIXTURES.grok_check_video_status : (await client.get(`/videos/${request_id}`)).data;
+        const output = normalizeVideoStatusResponse(
+          rawResponse,
+          request_id
+        );
+        const mediaContent = output.video_url === void 0 ? [] : IS_MOCK ? [buildMockVideoContent(output.video_url)] : (await Promise.all([
+          buildVideoContent(output.video_url, client)
+        ])).filter(
+          (item) => item !== void 0
+        );
+        return toolResult(
+          renderVideoStatus(output),
+          output,
+          mediaContent
+        );
       }
       default:
         throw new McpError(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fre4x/grok",
-  "version": "1.0.47",
+  "version": "1.0.50",
   "description": "An MCP server for xAI (Grok) with search and generation capabilities.",
   "type": "module",
   "main": "dist/index.js",