@zhigang1992/happy-cli 0.12.3 → 0.12.4

package/dist/lib.d.cts

@@ -291,6 +291,16 @@ type RawJSONLines = z.infer<typeof RawJSONLinesSchema>;
 /**
  * Common RPC types and interfaces for both session and machine clients
  */
+/**
+ * Session context for RPC handlers
+ * Contains environment and path information for the current session
+ */
+interface RpcSessionContext {
+    /** Working directory path for the session */
+    path: string;
+    /** Environment variables (includes direnv if available) */
+    env: Record<string, string>;
+}
 /**
  * Generic RPC handler function type
  * @template TRequest - The request data type
@@ -326,7 +336,19 @@ declare class RpcHandlerManager {
     private readonly encryptionVariant;
     private readonly logger;
     private socket;
+    private sessionContext;
     constructor(config: RpcHandlerConfig);
+    /**
+     * Set the session context (path and environment)
+     * This should be called after direnv environment is loaded
+     * @param context - The session context with path and environment
+     */
+    setSessionContext(context: RpcSessionContext): void;
+    /**
+     * Get the current session context
+     * @returns The session context or null if not set
+     */
+    getSessionContext(): RpcSessionContext | null;
     /**
      * Register an RPC handler for a specific method
      * @param method - The method name (without prefix)
@@ -423,6 +445,30 @@ declare class ApiSessionClient extends EventEmitter {
      */
     flush(): Promise<void>;
     close(): Promise<void>;
+    /**
+     * Download and decrypt a blob from the server
+     * @param blobId - The blob ID to download
+     * @returns The decrypted binary data and metadata, or null if download/decryption fails
+     */
+    downloadBlob(blobId: string): Promise<{
+        data: Uint8Array;
+        mimeType: string;
+        size: number;
+    } | null>;
+    /**
+     * Convert an image_ref content block to a Claude API image content block
+     * Downloads, decrypts, and base64 encodes the image
+     * @param imageRef - The image reference content block
+     * @returns Claude API image content block, or null if conversion fails
+     */
+    resolveImageRef(imageRef: ImageRefContent): Promise<{
+        type: 'image';
+        source: {
+            type: 'base64';
+            media_type: string;
+            data: string;
+        };
+    } | null>;
 }
 
 type PermissionMode = 'default' | 'acceptEdits' | 'bypassPermissions' | 'plan';
@@ -505,9 +551,32 @@ type Machine = {
     daemonState: DaemonState | null;
     daemonStateVersion: number;
 };
+/**
+ * Image reference content block for user messages (E2E encrypted images)
+ */
+declare const ImageRefContentSchema: z.ZodObject<{
+    type: z.ZodLiteral<"image_ref">;
+    blobId: z.ZodString;
+    mimeType: z.ZodEnum<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: "image_ref";
+    blobId: string;
+    mimeType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+    width?: number | undefined;
+    height?: number | undefined;
+}, {
+    type: "image_ref";
+    blobId: string;
+    mimeType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+    width?: number | undefined;
+    height?: number | undefined;
+}>;
+type ImageRefContent = z.infer<typeof ImageRefContentSchema>;
 declare const UserMessageSchema: z.ZodObject<{
     role: z.ZodLiteral<"user">;
-    content: z.ZodObject<{
+    content: z.ZodUnion<[z.ZodObject<{
         type: z.ZodLiteral<"text">;
         text: z.ZodString;
     }, "strip", z.ZodTypeAny, {
@@ -516,7 +585,34 @@ declare const UserMessageSchema: z.ZodObject<{
     }, {
         type: "text";
         text: string;
-    }>;
+    }>, z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "text";
+        text: string;
+    }, {
+        type: "text";
+        text: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"image_ref">;
+        blobId: z.ZodString;
+        mimeType: z.ZodEnum<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
+        width: z.ZodOptional<z.ZodNumber>;
+        height: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: "image_ref";
+        blobId: string;
+        mimeType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        width?: number | undefined;
+        height?: number | undefined;
+    }, {
+        type: "image_ref";
+        blobId: string;
+        mimeType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        width?: number | undefined;
+        height?: number | undefined;
+    }>]>, "many">]>;
     localKey: z.ZodOptional<z.ZodString>;
     meta: z.ZodOptional<z.ZodObject<{
         sentFrom: z.ZodOptional<z.ZodString>;
@@ -550,7 +646,16 @@ declare const UserMessageSchema: z.ZodObject<{
     content: {
         type: "text";
         text: string;
-    };
+    } | ({
+        type: "text";
+        text: string;
+    } | {
+        type: "image_ref";
+        blobId: string;
+        mimeType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        width?: number | undefined;
+        height?: number | undefined;
+    })[];
     role: "user";
     localKey?: string | undefined;
     meta?: {
@@ -567,7 +672,16 @@ declare const UserMessageSchema: z.ZodObject<{
     content: {
         type: "text";
         text: string;
-    };
+    } | ({
+        type: "text";
+        text: string;
+    } | {
+        type: "image_ref";
+        blobId: string;
+        mimeType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        width?: number | undefined;
+        height?: number | undefined;
+    })[];
     role: "user";
     localKey?: string | undefined;
     meta?: {

package/dist/lib.d.mts

@@ -291,6 +291,16 @@ type RawJSONLines = z.infer<typeof RawJSONLinesSchema>;
 /**
  * Common RPC types and interfaces for both session and machine clients
  */
+/**
+ * Session context for RPC handlers
+ * Contains environment and path information for the current session
+ */
+interface RpcSessionContext {
+    /** Working directory path for the session */
+    path: string;
+    /** Environment variables (includes direnv if available) */
+    env: Record<string, string>;
+}
 /**
  * Generic RPC handler function type
  * @template TRequest - The request data type
@@ -326,7 +336,19 @@ declare class RpcHandlerManager {
     private readonly encryptionVariant;
     private readonly logger;
     private socket;
+    private sessionContext;
     constructor(config: RpcHandlerConfig);
+    /**
+     * Set the session context (path and environment)
+     * This should be called after direnv environment is loaded
+     * @param context - The session context with path and environment
+     */
+    setSessionContext(context: RpcSessionContext): void;
+    /**
+     * Get the current session context
+     * @returns The session context or null if not set
+     */
+    getSessionContext(): RpcSessionContext | null;
     /**
      * Register an RPC handler for a specific method
      * @param method - The method name (without prefix)
@@ -423,6 +445,30 @@ declare class ApiSessionClient extends EventEmitter {
      */
     flush(): Promise<void>;
     close(): Promise<void>;
+    /**
+     * Download and decrypt a blob from the server
+     * @param blobId - The blob ID to download
+     * @returns The decrypted binary data and metadata, or null if download/decryption fails
+     */
+    downloadBlob(blobId: string): Promise<{
+        data: Uint8Array;
+        mimeType: string;
+        size: number;
+    } | null>;
+    /**
+     * Convert an image_ref content block to a Claude API image content block
+     * Downloads, decrypts, and base64 encodes the image
+     * @param imageRef - The image reference content block
+     * @returns Claude API image content block, or null if conversion fails
+     */
+    resolveImageRef(imageRef: ImageRefContent): Promise<{
+        type: 'image';
+        source: {
+            type: 'base64';
+            media_type: string;
+            data: string;
+        };
+    } | null>;
 }
 
 type PermissionMode = 'default' | 'acceptEdits' | 'bypassPermissions' | 'plan';
@@ -505,9 +551,32 @@ type Machine = {
     daemonState: DaemonState | null;
     daemonStateVersion: number;
 };
+/**
+ * Image reference content block for user messages (E2E encrypted images)
+ */
+declare const ImageRefContentSchema: z.ZodObject<{
+    type: z.ZodLiteral<"image_ref">;
+    blobId: z.ZodString;
+    mimeType: z.ZodEnum<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: "image_ref";
+    blobId: string;
+    mimeType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+    width?: number | undefined;
+    height?: number | undefined;
+}, {
+    type: "image_ref";
+    blobId: string;
+    mimeType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+    width?: number | undefined;
+    height?: number | undefined;
+}>;
+type ImageRefContent = z.infer<typeof ImageRefContentSchema>;
 declare const UserMessageSchema: z.ZodObject<{
     role: z.ZodLiteral<"user">;
-    content: z.ZodObject<{
+    content: z.ZodUnion<[z.ZodObject<{
         type: z.ZodLiteral<"text">;
         text: z.ZodString;
     }, "strip", z.ZodTypeAny, {
@@ -516,7 +585,34 @@ declare const UserMessageSchema: z.ZodObject<{
     }, {
         type: "text";
         text: string;
-    }>;
+    }>, z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "text";
+        text: string;
+    }, {
+        type: "text";
+        text: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"image_ref">;
+        blobId: z.ZodString;
+        mimeType: z.ZodEnum<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
+        width: z.ZodOptional<z.ZodNumber>;
+        height: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: "image_ref";
+        blobId: string;
+        mimeType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        width?: number | undefined;
+        height?: number | undefined;
+    }, {
+        type: "image_ref";
+        blobId: string;
+        mimeType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        width?: number | undefined;
+        height?: number | undefined;
+    }>]>, "many">]>;
     localKey: z.ZodOptional<z.ZodString>;
     meta: z.ZodOptional<z.ZodObject<{
         sentFrom: z.ZodOptional<z.ZodString>;
@@ -550,7 +646,16 @@ declare const UserMessageSchema: z.ZodObject<{
     content: {
         type: "text";
         text: string;
-    };
+    } | ({
+        type: "text";
+        text: string;
+    } | {
+        type: "image_ref";
+        blobId: string;
+        mimeType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        width?: number | undefined;
+        height?: number | undefined;
+    })[];
     role: "user";
     localKey?: string | undefined;
     meta?: {
@@ -567,7 +672,16 @@ declare const UserMessageSchema: z.ZodObject<{
     content: {
         type: "text";
         text: string;
-    };
+    } | ({
+        type: "text";
+        text: string;
+    } | {
+        type: "image_ref";
+        blobId: string;
+        mimeType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        width?: number | undefined;
+        height?: number | undefined;
+    })[];
     role: "user";
     localKey?: string | undefined;
     meta?: {

package/dist/lib.mjs

@@ -1,4 +1,4 @@
-export { A as ApiClient, a as ApiSessionClient, R as RawJSONLinesSchema, c as configuration, l as logger } from './types-D4_aCy-H.mjs';
+export { A as ApiClient, a as ApiSessionClient, R as RawJSONLinesSchema, c as configuration, l as logger } from './types-Cw6y7GyQ.mjs';
 import 'axios';
 import 'chalk';
 import 'fs';

package/dist/{list-D_NjiLPx.mjs → list-BvtUKVTq.mjs}

@@ -1,4 +1,4 @@
-import { c as configuration, l as logger, d as decodeBase64, b as decrypt, f as formatTimeAgo, e as libsodiumDecryptFromPublicKey } from './types-D4_aCy-H.mjs';
+import { c as configuration, l as logger, d as decodeBase64, b as decrypt, f as formatTimeAgo, e as libsodiumDecryptFromPublicKey } from './types-Cw6y7GyQ.mjs';
 import axios from 'axios';
 import { existsSync, readdirSync, statSync, readFileSync } from 'fs';
 import { join } from 'path';

package/dist/{list-DiamEbqL.cjs → list-DOsBjFRJ.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var types = require('./types-CllU28mx.cjs');
+var types = require('./types-Q-euvEmG.cjs');
 var axios = require('axios');
 var fs = require('fs');
 var path = require('path');

package/dist/{prompt-CJh1Mo2A.mjs → prompt-BbMNN7fl.mjs}

@@ -1,4 +1,4 @@
-import { c as configuration, b as decrypt, d as decodeBase64, l as logger, g as encodeBase64, h as encrypt } from './types-D4_aCy-H.mjs';
+import { c as configuration, b as decrypt, d as decodeBase64, l as logger, g as encodeBase64, h as encrypt } from './types-Cw6y7GyQ.mjs';
 import axios from 'axios';
 import { io } from 'socket.io-client';
 import 'chalk';

package/dist/{prompt-Cu47wZlI.cjs → prompt-Dh_trad0.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var types = require('./types-CllU28mx.cjs');
+var types = require('./types-Q-euvEmG.cjs');
 var axios = require('axios');
 var socket_ioClient = require('socket.io-client');
 require('chalk');

package/dist/{runCodex-B5ZlUUec.mjs → runCodex-CYkmZphO.mjs}

@@ -1,13 +1,13 @@
 import { useStdout, useInput, Box, Text, render } from 'ink';
 import React, { useState, useRef, useEffect, useCallback } from 'react';
-import { l as logger, A as ApiClient, r as readSettings, p as projectPath, c as configuration, i as packageJson } from './types-D4_aCy-H.mjs';
+import { l as logger, A as ApiClient, r as readSettings, p as projectPath, c as configuration, i as packageJson } from './types-Cw6y7GyQ.mjs';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { z } from 'zod';
 import { ElicitRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { execSync } from 'child_process';
 import { randomUUID } from 'node:crypto';
-import { i as initialMachineMetadata, n as notifyDaemonSessionStarted, M as MessageQueue2, h as hashObject, r as registerKillSessionHandler, a as MessageBuffer, s as startHappyServer, t as trimIdent, b as stopCaffeinate } from './index-DNeoLdzx.mjs';
+import { i as initialMachineMetadata, n as notifyDaemonSessionStarted, M as MessageQueue2, h as hashObject, r as registerKillSessionHandler, a as MessageBuffer, s as startHappyServer, t as trimIdent, b as stopCaffeinate } from './index-BERBU6rR.mjs';
 import os from 'node:os';
 import { resolve, join } from 'node:path';
 import fs from 'node:fs';
@@ -752,6 +752,21 @@ const CodexDisplay = ({ messageBuffer, logPath, onExit }) => {
   ));
 };
 
+function extractTextFromContent(content) {
+  if (!Array.isArray(content)) {
+    if (content.type === "text") {
+      return content.text;
+    }
+    return "";
+  }
+  const textParts = [];
+  for (const block of content) {
+    if (block.type === "text") {
+      textParts.push(block.text);
+    }
+  }
+  return textParts.join("\n");
+}
 function emitReadyIfIdle({ pending, queueSize, shouldExit, sendReady, notify }) {
   if (shouldExit) {
     return false;
@@ -847,7 +862,8 @@ async function runCodex(opts) {
       permissionMode: messagePermissionMode || "default",
       model: messageModel
     };
-    messageQueue.push(message.content.text, enhancedMode);
+    const textContent = extractTextFromContent(message.content);
+    messageQueue.push(textContent, enhancedMode);
   });
   let thinking = false;
   session.keepAlive(thinking, "remote");

package/dist/{runCodex-DErgypij.cjs → runCodex-DUqqO-m8.cjs}

@@ -2,14 +2,14 @@
 
 var ink = require('ink');
 var React = require('react');
-var types = require('./types-CllU28mx.cjs');
+var types = require('./types-Q-euvEmG.cjs');
 var index_js = require('@modelcontextprotocol/sdk/client/index.js');
 var stdio_js = require('@modelcontextprotocol/sdk/client/stdio.js');
 var z = require('zod');
 var types_js = require('@modelcontextprotocol/sdk/types.js');
 var child_process = require('child_process');
 var node_crypto = require('node:crypto');
-var index = require('./index-y8CVImEp.cjs');
+var index = require('./index-CHEjP0zg.cjs');
 var os = require('node:os');
 var node_path = require('node:path');
 var fs = require('node:fs');
@@ -754,6 +754,21 @@ const CodexDisplay = ({ messageBuffer, logPath, onExit }) => {
   ));
 };
 
+function extractTextFromContent(content) {
+  if (!Array.isArray(content)) {
+    if (content.type === "text") {
+      return content.text;
+    }
+    return "";
+  }
+  const textParts = [];
+  for (const block of content) {
+    if (block.type === "text") {
+      textParts.push(block.text);
+    }
+  }
+  return textParts.join("\n");
+}
 function emitReadyIfIdle({ pending, queueSize, shouldExit, sendReady, notify }) {
   if (shouldExit) {
     return false;
@@ -849,7 +864,8 @@ async function runCodex(opts) {
       permissionMode: messagePermissionMode || "default",
       model: messageModel
     };
-    messageQueue.push(message.content.text, enhancedMode);
+    const textContent = extractTextFromContent(message.content);
+    messageQueue.push(textContent, enhancedMode);
   });
   let thinking = false;
   session.keepAlive(thinking, "remote");

package/dist/{types-D4_aCy-H.mjs → types-Cw6y7GyQ.mjs}

@@ -20,7 +20,7 @@ import { fileURLToPath } from 'url';
 import { Expo } from 'expo-server-sdk';
 
 var name = "@zhigang1992/happy-cli";
-var version = "0.12.2";
+var version = "0.12.4";
 var description = "Mobile and Web client for Claude Code and Codex";
 var author = "Kirill Dubovitskiy";
 var license = "MIT";
@@ -311,6 +311,31 @@ function decryptWithDataKey(bundle, dataKey) {
     return null;
   }
 }
+function decryptBlobWithDataKey(bundle, dataKey) {
+  if (bundle.length < 1) {
+    return null;
+  }
+  if (bundle[0] !== 0) {
+    return null;
+  }
+  if (bundle.length < 12 + 16 + 1) {
+    return null;
+  }
+  const nonce = bundle.slice(1, 13);
+  const authTag = bundle.slice(bundle.length - 16);
+  const ciphertext = bundle.slice(13, bundle.length - 16);
+  try {
+    const decipher = createDecipheriv("aes-256-gcm", dataKey, nonce);
+    decipher.setAuthTag(authTag);
+    const decrypted = Buffer.concat([
+      decipher.update(ciphertext),
+      decipher.final()
+    ]);
+    return new Uint8Array(decrypted);
+  } catch (error) {
+    return null;
+  }
+}
 function encrypt(key, variant, data) {
   if (variant === "legacy") {
     return encryptLegacy(data, key);
@@ -852,12 +877,27 @@ z$1.object({
     agentStateVersion: z$1.number()
   })
 });
+const TextContentSchema = z$1.object({
+  type: z$1.literal("text"),
+  text: z$1.string()
+});
+const ImageRefContentSchema = z$1.object({
+  type: z$1.literal("image_ref"),
+  blobId: z$1.string(),
+  mimeType: z$1.enum(["image/jpeg", "image/png", "image/gif", "image/webp"]),
+  width: z$1.number().optional(),
+  height: z$1.number().optional()
+});
+const ContentBlockSchema = z$1.union([TextContentSchema, ImageRefContentSchema]);
+const UserMessageContentSchema = z$1.union([
+  TextContentSchema,
+  // Legacy: single text content
+  z$1.array(ContentBlockSchema)
+  // New: array of content blocks
+]);
 const UserMessageSchema = z$1.object({
   role: z$1.literal("user"),
-  content: z$1.object({
-    type: z$1.literal("text"),
-    text: z$1.string()
-  }),
+  content: UserMessageContentSchema,
   localKey: z$1.string().optional(),
   // Mobile messages include this
   meta: MessageMetaSchema.optional()
@@ -969,12 +1009,29 @@ class RpcHandlerManager {
   encryptionVariant;
   logger;
   socket = null;
+  sessionContext = null;
   constructor(config) {
     this.scopePrefix = config.scopePrefix;
     this.encryptionKey = config.encryptionKey;
     this.encryptionVariant = config.encryptionVariant;
     this.logger = config.logger || ((msg, data) => logger.debug(msg, data));
   }
+  /**
+   * Set the session context (path and environment)
+   * This should be called after direnv environment is loaded
+   * @param context - The session context with path and environment
+   */
+  setSessionContext(context) {
+    this.sessionContext = context;
+    this.logger("[RPC] Session context set", { path: context.path, envVarCount: Object.keys(context.env).length });
+  }
+  /**
+   * Get the current session context
+   * @returns The session context or null if not set
+   */
+  getSessionContext() {
+    return this.sessionContext;
+  }
   /**
    * Register an RPC handler for a specific method
    * @param method - The method name (without prefix)
@@ -1150,10 +1207,13 @@ function registerCommonHandlers(rpcHandlerManager) {
   rpcHandlerManager.registerHandler("bash", async (data) => {
     logger.debug("Shell command request:", data.command);
     try {
+      const sessionContext = rpcHandlerManager.getSessionContext();
       const options = {
         cwd: data.cwd,
-        timeout: data.timeout || 3e4
+        timeout: data.timeout || 3e4,
         // Default 30 seconds timeout
+        // Use session environment if available, otherwise inherit process.env
+        env: sessionContext?.env ?? process.env
       };
       const { stdout, stderr } = await execAsync(data.command, options);
       return {
@@ -1683,6 +1743,64 @@ class ApiSessionClient extends EventEmitter {
     logger.debug("[API] socket.close() called");
     this.socket.close();
   }
+  /**
+   * Download and decrypt a blob from the server
+   * @param blobId - The blob ID to download
+   * @returns The decrypted binary data and metadata, or null if download/decryption fails
+   */
+  async downloadBlob(blobId) {
+    try {
+      const response = await axios.get(
+        `${configuration.serverUrl}/v1/sessions/${this.sessionId}/blobs/${blobId}`,
+        {
+          headers: {
+            "Authorization": `Bearer ${this.token}`
+          },
+          responseType: "arraybuffer"
+        }
+      );
+      const encryptedData = new Uint8Array(response.data);
+      const mimeType = response.headers["x-blob-mimetype"];
+      const originalSize = parseInt(response.headers["x-blob-size"], 10);
+      if (this.encryptionVariant !== "dataKey") {
+        logger.debug("[API] Cannot decrypt blob: session uses legacy encryption");
+        return null;
+      }
+      const decryptedData = decryptBlobWithDataKey(encryptedData, this.encryptionKey);
+      if (!decryptedData) {
+        logger.debug("[API] Failed to decrypt blob");
+        return null;
+      }
+      return {
+        data: decryptedData,
+        mimeType,
+        size: originalSize
+      };
+    } catch (error) {
+      logger.debug("[API] Failed to download blob:", error);
+      return null;
+    }
+  }
+  /**
+   * Convert an image_ref content block to a Claude API image content block
+   * Downloads, decrypts, and base64 encodes the image
+   * @param imageRef - The image reference content block
+   * @returns Claude API image content block, or null if conversion fails
+   */
+  async resolveImageRef(imageRef) {
+    const blob = await this.downloadBlob(imageRef.blobId);
+    if (!blob) {
+      return null;
+    }
+    return {
+      type: "image",
+      source: {
+        type: "base64",
+        media_type: blob.mimeType,
+        data: Buffer.from(blob.data).toString("base64")
+      }
+    };
+  }
 }
 
 class ApiMachineClient {