openbot 0.5.8 → 0.5.10

package/src/plugins/storage/index.ts

@@ -10,404 +10,464 @@ export const storagePlugin: Plugin = {
   id: 'storage',
   name: 'Storage',
   description: 'Infrastructure storage handlers for channels, threads, agents, and files.',
-  factory: ({ storage, publicBaseUrl }) => (builder) => {
-    const resolvePublicBaseUrl = () => publicBaseUrl;
+  factory:
+    ({ storage, publicBaseUrl }) =>
+    (builder) => {
+      const resolvePublicBaseUrl = () => publicBaseUrl;
+
+      builder.on('action:create_thread', async function* (event, context) {
+        const threadId = event.meta?.threadId;
+        const channelId = context.state.channelId;
+        const { threadTitle, initialState } = (event as any).data;
+
+        if (!threadId) {
+          console.warn('[storage] Cannot create thread: meta.threadId is missing');
+          return;
+        }
+
+        context.state.threadId = threadId;
+
+        if (channelId) {
+          try {
+            await storage.createThread({
+              channelId,
+              threadId,
+              threadTitle,
+              initialState: (initialState as Record<string, unknown>) || {},
+            });
+
+            context.state.threadDetails = await storage.getThreadDetails({
+              channelId,
+              threadId,
+            });
+          } catch (error) {
+            console.warn(
+              `[storage] Failed to initialize thread for channel ${channelId} thread ${threadId}`,
+              error,
+            );
+          }
+        }
+
+        yield {
+          type: 'action:create_thread:result',
+          data: { success: true, threadId, threadTitle },
+          meta: { ...(event.meta || {}), threadId, agentId: context.state.agentId },
+        } as OpenBotEvent;
+      });
+
+      builder.on('agent:usage', async function* (event, context) {
+        const { usage } = event.data;
+        const channelId = context.state.channelId;
+        if (!channelId || !context.state.threadId) return;
+
+        const currentState = (context.state.threadDetails?.state as Record<string, any>) || {};
+        const currentUsage = currentState.usage || {
+          promptTokens: 0,
+          completionTokens: 0,
+          totalTokens: 0,
+        };
+
+        const nextUsage = {
+          promptTokens: (currentUsage.promptTokens || 0) + usage.promptTokens,
+          completionTokens: (currentUsage.completionTokens || 0) + usage.completionTokens,
+          totalTokens: (currentUsage.totalTokens || 0) + usage.totalTokens,
+        };
+
+        await storage.patchThreadState({
+          channelId,
+          threadId: context.state.threadId,
+          state: { usage: nextUsage },
+        });
 
-    builder.on('action:create_thread', async function* (event, context) {
-      const threadId = event.meta?.threadId;
-      const channelId = context.state.channelId;
-      const { threadTitle, initialState } = (event as any).data;
+        context.state.threadDetails = await storage.getThreadDetails({
+          channelId,
+          threadId: context.state.threadId,
+        });
+      });
 
-      if (!threadId) {
-        console.warn('[storage] Cannot create thread: meta.threadId is missing');
-        return;
-      }
+      builder.on('action:storage:get-channels', async function* () {
+        const channels = await storage.getChannels();
+        yield { type: 'action:storage:get-channels-result', data: { channels } };
+      });
 
-      context.state.threadId = threadId;
+      builder.on('action:storage:get-threads', async function* (event) {
+        const threads = await storage.getThreads({ channelId: event.data.channelId });
+        yield { type: 'action:storage:get-threads-result', data: { threads } };
+      });
 
-      if (channelId) {
+      builder.on('action:storage:set-last-read', async function* (event, context) {
+        const { channelId, threadId, lastReadEventId } = event.data;
+        const resolvedChannelId = channelId || context.state.channelId;
+        if (!resolvedChannelId) {
+          yield {
+            type: 'action:storage:set-last-read-result',
+            data: { success: false, error: 'channelId is required' },
+          };
+          return;
+        }
         try {
-          await storage.createThread({
-            channelId,
-            threadId,
-            threadTitle,
-            initialState: (initialState as Record<string, unknown>) || {},
+          await storage.setLastRead({
+            channelId: resolvedChannelId,
+            threadId: threadId || context.state.threadId,
+            lastReadEventId,
           });
+          yield { type: 'action:storage:set-last-read-result', data: { success: true } };
+        } catch (error) {
+          yield {
+            type: 'action:storage:set-last-read-result',
+            data: {
+              success: false,
+              error: error instanceof Error ? error.message : 'Unknown error',
+            },
+          };
+        }
+      });
 
-          context.state.threadDetails = await storage.getThreadDetails({
-            channelId,
-            threadId,
+      builder.on('action:storage:get-channel-details', async function* (_, state) {
+        const channelId = state.state.channelId;
+        if (!channelId) {
+          yield {
+            type: 'action:storage:get-channel-details-result',
+            data: { channelDetails: null as any, error: 'channelId is required' },
+          };
+          return;
+        }
+        const channelDetails = await storage.getChannelDetails({ channelId });
+        yield { type: 'action:storage:get-channel-details-result', data: { channelDetails } };
+      });
+
+      builder.on('action:storage:get-thread-details', async function* (_, state) {
+        const channelId = state.state.channelId;
+        const threadId = state.state.threadId;
+        if (!channelId) {
+          yield {
+            type: 'action:storage:get-thread-details-result',
+            data: { threadDetails: null, error: 'channelId is required' },
+          };
+          return;
+        }
+        const threadDetails = threadId
+          ? await storage.getThreadDetails({ channelId, threadId })
+          : null;
+        yield { type: 'action:storage:get-thread-details-result', data: { threadDetails } };
+      });
+
+      builder.on('action:storage:get-agents', async function* () {
+        const agents = await storage.getAgents();
+        yield { type: 'action:storage:get-agents-result', data: { agents } };
+      });
+
+      builder.on('action:storage:get-plugins', async function* () {
+        const plugins = await storage.getPlugins();
+        yield { type: 'action:storage:get-plugins-result', data: { plugins } };
+      });
+
+      builder.on('action:storage:get-agent-details', async function* (event) {
+        try {
+          const agentDetails = await storage.getAgentDetails({ agentId: event.data.agentId });
+          yield { type: 'action:storage:get-agent-details-result', data: { agentDetails } };
+        } catch (error) {
+          console.error(`[storage] Failed to get agent details for ${event.data.agentId}`, error);
+          yield {
+            type: 'action:storage:get-agent-details-result',
+            data: {
+              agentDetails: null as any,
+              error: error instanceof Error ? error.message : 'Unknown error',
+            },
+          };
+        }
+      });
+
+      builder.on('action:storage:create-agent', async function* (event) {
+        try {
+          const { agentId, name, description, image, hidden, instructions, plugins } = event.data;
+          await storage.createAgent({
+            agentId,
+            name,
+            description,
+            image,
+            hidden,
+            instructions,
+            plugins,
           });
+          yield { type: 'action:storage:create-agent-result', data: { success: true } };
         } catch (error) {
-          console.warn(
-            `[storage] Failed to initialize thread for channel ${channelId} thread ${threadId}`,
-            error,
-          );
+          yield {
+            type: 'action:storage:create-agent-result',
+            data: {
+              success: false,
+              error: error instanceof Error ? error.message : 'Unknown error',
+            },
+          };
         }
-      }
-
-      yield {
-        type: 'action:create_thread:result',
-        data: { success: true, threadId, threadTitle },
-        meta: { ...(event.meta || {}), threadId, agentId: context.state.agentId },
-      } as OpenBotEvent;
-    });
-
-    builder.on('agent:usage', async function* (event, context) {
-      const { usage } = event.data;
-      if (!context.state.threadId) return;
-
-      const currentState = (context.state.threadDetails?.state as Record<string, any>) || {};
-      const currentUsage = currentState.usage || {
-        promptTokens: 0,
-        completionTokens: 0,
-        totalTokens: 0,
-      };
-
-      const nextUsage = {
-        promptTokens: (currentUsage.promptTokens || 0) + usage.promptTokens,
-        completionTokens: (currentUsage.completionTokens || 0) + usage.completionTokens,
-        totalTokens: (currentUsage.totalTokens || 0) + usage.totalTokens,
-      };
-
-      await storage.patchThreadState({
-        channelId: context.state.channelId,
-        threadId: context.state.threadId,
-        state: { usage: nextUsage },
       });
 
-      context.state.threadDetails = await storage.getThreadDetails({
-        channelId: context.state.channelId,
-        threadId: context.state.threadId,
+      builder.on('action:storage:update-agent', async function* (event) {
+        try {
+          const { agentId, name, description, image, hidden, instructions, plugins } = event.data;
+          await storage.updateAgent({
+            agentId,
+            name,
+            description,
+            image,
+            hidden,
+            instructions,
+            plugins,
+          });
+          yield { type: 'action:storage:update-agent-result', data: { success: true } };
+        } catch (error) {
+          yield {
+            type: 'action:storage:update-agent-result',
+            data: {
+              success: false,
+              error: error instanceof Error ? error.message : 'Unknown error',
+            },
+          };
+        }
       });
-    });
-
-    builder.on('action:storage:get-channels', async function* () {
-      const channels = await storage.getChannels();
-      yield { type: 'action:storage:get-channels-result', data: { channels } };
-    });
-
-    builder.on('action:storage:get-threads', async function* (event) {
-      const threads = await storage.getThreads({ channelId: event.data.channelId });
-      yield { type: 'action:storage:get-threads-result', data: { threads } };
-    });
-
-    builder.on('action:storage:set-last-read', async function* (event, context) {
-      const { channelId, threadId, lastReadEventId } = event.data;
-      try {
-        await storage.setLastRead({
-          channelId: channelId || context.state.channelId,
-          threadId: threadId || context.state.threadId,
-          lastReadEventId,
-        });
-        yield { type: 'action:storage:set-last-read-result', data: { success: true } };
-      } catch (error) {
-        yield {
-          type: 'action:storage:set-last-read-result',
-          data: {
-            success: false,
-            error: error instanceof Error ? error.message : 'Unknown error',
-          },
-        };
-      }
-    });
 
-    builder.on('action:storage:get-channel-details', async function* (_, state) {
-      const channelDetails = await storage.getChannelDetails({
-        channelId: state.state.channelId,
+      builder.on('action:storage:delete-channel', async function* (event) {
+        try {
+          await storage.deleteChannel({ channelId: event.data.channelId });
+          yield { type: 'action:storage:delete-channel-result', data: { success: true } };
+        } catch (error) {
+          yield {
+            type: 'action:storage:delete-channel-result',
+            data: {
+              success: false,
+              error: error instanceof Error ? error.message : 'Unknown error',
+            },
+          };
+        }
       });
-      yield { type: 'action:storage:get-channel-details-result', data: { channelDetails } };
-    });
-
-    builder.on('action:storage:get-thread-details', async function* (_, state) {
-      const threadId = state.state.threadId;
-      const threadDetails = threadId
-        ? await storage.getThreadDetails({ channelId: state.state.channelId, threadId })
-        : null;
-      yield { type: 'action:storage:get-thread-details-result', data: { threadDetails } };
-    });
-
-    builder.on('action:storage:get-agents', async function* () {
-      const agents = await storage.getAgents();
-      yield { type: 'action:storage:get-agents-result', data: { agents } };
-    });
-
-    builder.on('action:storage:get-plugins', async function* () {
-      const plugins = await storage.getPlugins();
-      yield { type: 'action:storage:get-plugins-result', data: { plugins } };
-    });
-
-    builder.on('action:storage:get-agent-details', async function* (event) {
-      try {
-        const agentDetails = await storage.getAgentDetails({ agentId: event.data.agentId });
-        yield { type: 'action:storage:get-agent-details-result', data: { agentDetails } };
-      } catch (error) {
-        console.error(`[storage] Failed to get agent details for ${event.data.agentId}`, error);
-        yield {
-          type: 'action:storage:get-agent-details-result',
-          data: {
-            agentDetails: null as any,
-            error: error instanceof Error ? error.message : 'Unknown error',
-          },
-        };
-      }
-    });
-
-    builder.on('action:storage:create-agent', async function* (event) {
-      try {
-        const { agentId, name, description, image, hidden, instructions, plugins } = event.data;
-        await storage.createAgent({
-          agentId,
-          name,
-          description,
-          image,
-          hidden,
-          instructions,
-          plugins,
-        });
-        yield { type: 'action:storage:create-agent-result', data: { success: true } };
-      } catch (error) {
-        yield {
-          type: 'action:storage:create-agent-result',
-          data: {
-            success: false,
-            error: error instanceof Error ? error.message : 'Unknown error',
-          },
-        };
-      }
-    });
-
-    builder.on('action:storage:update-agent', async function* (event) {
-      try {
-        const { agentId, name, description, image, hidden, instructions, plugins } = event.data;
-        await storage.updateAgent({
-          agentId,
-          name,
-          description,
-          image,
-          hidden,
-          instructions,
-          plugins,
-        });
-        yield { type: 'action:storage:update-agent-result', data: { success: true } };
-      } catch (error) {
-        yield {
-          type: 'action:storage:update-agent-result',
-          data: {
-            success: false,
-            error: error instanceof Error ? error.message : 'Unknown error',
-          },
-        };
-      }
-    });
-
-    builder.on('action:storage:delete-channel', async function* (event) {
-      try {
-        await storage.deleteChannel({ channelId: event.data.channelId });
-        yield { type: 'action:storage:delete-channel-result', data: { success: true } };
-      } catch (error) {
-        yield {
-          type: 'action:storage:delete-channel-result',
-          data: {
-            success: false,
-            error: error instanceof Error ? error.message : 'Unknown error',
-          },
-        };
-      }
-    });
-
-    builder.on('action:storage:delete-agent', async function* (event) {
-      try {
-        await storage.deleteAgent({ agentId: event.data.agentId });
-        yield { type: 'action:storage:delete-agent-result', data: { success: true } };
-      } catch (error) {
-        yield {
-          type: 'action:storage:delete-agent-result',
-          data: {
-            success: false,
-            error: error instanceof Error ? error.message : 'Unknown error',
-          },
-        };
-      }
-    });
-
-    builder.on('action:storage:get-events', async function* (_, state) {
-      const events = await storage.getEvents(state.state);
-      yield { type: 'action:storage:get-events-result', data: { events } };
-    });
-
-    builder.on('action:storage:get-variables', async function* () {
-      const variables = await storage.getVariables();
-      const masked: Record<string, string> = {};
-      for (const [key, val] of Object.entries(variables)) {
-        if (typeof val === 'object' && val !== null && val.secret) {
-          masked[key] = '********';
-        } else {
-          masked[key] = typeof val === 'string' ? val : val.value;
+
+      builder.on('action:storage:delete-agent', async function* (event) {
+        try {
+          await storage.deleteAgent({ agentId: event.data.agentId });
+          yield { type: 'action:storage:delete-agent-result', data: { success: true } };
+        } catch (error) {
+          yield {
+            type: 'action:storage:delete-agent-result',
+            data: {
+              success: false,
+              error: error instanceof Error ? error.message : 'Unknown error',
+            },
+          };
         }
-      }
-      yield {
-        type: 'action:storage:get-variables-result',
-        data: { variables: masked },
-      } as OpenBotEvent;
-    });
-
-    builder.on('action:storage:create-variable', async function* (event) {
-      try {
-        const { key, value, secret } = event.data;
-        await storage.createVariable({ key, value, secret });
-        yield { type: 'action:storage:create-variable-result', data: { success: true } };
-      } catch (error) {
-        yield {
-          type: 'action:storage:create-variable-result',
-          data: {
-            success: false,
-            error: error instanceof Error ? error.message : 'Unknown error',
-          },
-        };
-      }
-    });
-
-    builder.on('action:storage:delete-variable', async function* (event) {
-      try {
-        await storage.deleteVariable({ key: event.data.key });
-        yield { type: 'action:storage:delete-variable-result', data: { success: true } };
-      } catch (error) {
-        yield {
-          type: 'action:storage:delete-variable-result',
-          data: {
-            success: false,
-            error: error instanceof Error ? error.message : 'Unknown error',
-          },
-        };
-      }
-    });
-
-    builder.on('action:storage:patch-channel-state', async function* (event, state) {
-      try {
-        await storage.patchChannelState({
-          channelId: state.state.channelId,
-          state: event.data.state,
-        });
-        yield { type: 'action:storage:patch-channel-state-result', data: { success: true } };
-      } catch {
-        yield { type: 'action:storage:patch-channel-state-result', data: { success: false } };
-      }
-    });
-
-    builder.on('action:storage:patch-thread-state', async function* (event, state) {
-      try {
-        if (!state.state.threadId) {
-          throw new Error('Missing threadId in state for patch-thread-state');
+      });
+
+      builder.on('action:storage:get-events', async function* (_, state) {
+        const channelId = state.state.channelId;
+        if (!channelId) {
+          yield { type: 'action:storage:get-events-result', data: { events: [] } };
+          return;
+        }
+        const events = await storage.getEvents({ channelId, threadId: state.state.threadId });
+        yield { type: 'action:storage:get-events-result', data: { events } };
+      });
+
+      builder.on('action:storage:get-variables', async function* () {
+        const variables = await storage.getVariables();
+        const masked: Record<string, string> = {};
+        for (const [key, val] of Object.entries(variables)) {
+          if (typeof val === 'object' && val !== null && val.secret) {
+            masked[key] = '********';
+          } else {
+            masked[key] = typeof val === 'string' ? val : val.value;
+          }
         }
-        await storage.patchThreadState({
-          channelId: state.state.channelId,
-          threadId: state.state.threadId,
-          state: event.data.state,
-        });
-        yield { type: 'action:storage:patch-thread-state-result', data: { success: true } };
-      } catch {
-        yield { type: 'action:storage:patch-thread-state-result', data: { success: false } };
-      }
-    });
-
-    builder.on('action:storage:list-files', async function* (event, context) {
-      const channelId = context.state.channelId;
-      const subPath = (event.data as any)?.path || '';
-      try {
-        const files = await storage.listFiles({ channelId, path: subPath });
-        yield {
-          type: 'action:storage:list-files:result',
-          data: { success: true, files },
-        };
-      } catch (error) {
-        yield {
-          type: 'action:storage:list-files:result',
-          data: {
-            success: false,
-            files: [],
-            error: error instanceof Error ? error.message : 'Unknown error',
-          },
-        };
-      }
-    });
-
-    builder.on('action:storage:read-file', async function* (event, context) {
-      const channelId = context.state.channelId;
-      const data = event.data as { path?: string; encoding?: 'utf8' | 'base64' };
-      const filePath = data?.path;
-      const encoding = data?.encoding ?? 'utf8';
-      if (!filePath) {
         yield {
-          type: 'action:storage:read-file:result',
-          data: { success: false, path: '', error: 'Path is required' },
-        };
-        return;
-      }
-      try {
-        if (encoding === 'utf8') {
-          const content = await storage.readFile({ channelId, path: filePath });
+          type: 'action:storage:get-variables-result',
+          data: { variables: masked },
+        } as OpenBotEvent;
+      });
+
+      builder.on('action:storage:create-variable', async function* (event) {
+        try {
+          const { key, value, secret } = event.data;
+          await storage.createVariable({ key, value, secret });
+          yield { type: 'action:storage:create-variable-result', data: { success: true } };
+        } catch (error) {
           yield {
-            type: 'action:storage:read-file:result',
-            data: { success: true, content, path: filePath, encoding },
+            type: 'action:storage:create-variable-result',
+            data: {
+              success: false,
+              error: error instanceof Error ? error.message : 'Unknown error',
+            },
+          };
+        }
+      });
+
+      builder.on('action:storage:delete-variable', async function* (event) {
+        try {
+          await storage.deleteVariable({ key: event.data.key });
+          yield { type: 'action:storage:delete-variable-result', data: { success: true } };
+        } catch (error) {
+          yield {
+            type: 'action:storage:delete-variable-result',
+            data: {
+              success: false,
+              error: error instanceof Error ? error.message : 'Unknown error',
+            },
           };
+        }
+      });
+
+      builder.on('action:storage:patch-channel-state', async function* (event, state) {
+        const channelId = state.state.channelId;
+        if (!channelId) {
+          yield { type: 'action:storage:patch-channel-state-result', data: { success: false } };
           return;
         }
+        try {
+          await storage.patchChannelState({
+            channelId,
+            state: event.data.state,
+          });
+          yield { type: 'action:storage:patch-channel-state-result', data: { success: true } };
+        } catch {
+          yield { type: 'action:storage:patch-channel-state-result', data: { success: false } };
+        }
+      });
 
-        const { content, mimeType, size } = await storage.readChannelFile({
-          channelId,
-          path: filePath,
-          encoding,
-        });
-        yield {
-          type: 'action:storage:read-file:result',
-          data: { success: true, content, path: filePath, encoding, mimeType, size },
-        };
-      } catch (error) {
-        yield {
-          type: 'action:storage:read-file:result',
-          data: {
-            success: false,
+      builder.on('action:storage:patch-thread-state', async function* (event, state) {
+        const channelId = state.state.channelId;
+        try {
+          if (!channelId || !state.state.threadId) {
+            throw new Error('Missing channelId or threadId in state for patch-thread-state');
+          }
+          await storage.patchThreadState({
+            channelId,
+            threadId: state.state.threadId,
+            state: event.data.state,
+          });
+          yield { type: 'action:storage:patch-thread-state-result', data: { success: true } };
+        } catch {
+          yield { type: 'action:storage:patch-thread-state-result', data: { success: false } };
+        }
+      });
+
+      builder.on('action:storage:list-files', async function* (event, context) {
+        const channelId = context.state.channelId;
+        const subPath = (event.data as any)?.path || '';
+        if (!channelId) {
+          yield {
+            type: 'action:storage:list-files:result',
+            data: { success: false, files: [], error: 'channelId is required' },
+          };
+          return;
+        }
+        try {
+          const files = await storage.listFiles({ channelId, path: subPath });
+          yield {
+            type: 'action:storage:list-files:result',
+            data: { success: true, files },
+          };
+        } catch (error) {
+          yield {
+            type: 'action:storage:list-files:result',
+            data: {
+              success: false,
+              files: [],
+              error: error instanceof Error ? error.message : 'Unknown error',
+            },
+          };
+        }
+      });
+
+      builder.on('action:storage:read-file', async function* (event, context) {
+        const channelId = context.state.channelId;
+        const data = event.data as { path?: string; encoding?: 'utf8' | 'base64' };
+        const filePath = data?.path;
+        const encoding = data?.encoding ?? 'utf8';
+        if (!filePath) {
+          yield {
+            type: 'action:storage:read-file:result',
+            data: { success: false, path: '', error: 'Path is required' },
+          };
+          return;
+        }
+        if (!channelId) {
+          yield {
+            type: 'action:storage:read-file:result',
+            data: { success: false, path: filePath, error: 'channelId is required' },
+          };
+          return;
+        }
+        try {
+          if (encoding === 'utf8') {
+            const content = await storage.readFile({ channelId, path: filePath });
+            yield {
+              type: 'action:storage:read-file:result',
+              data: { success: true, content, path: filePath, encoding },
+            };
+            return;
+          }
+
+          const { content, mimeType, size } = await storage.readChannelFile({
+            channelId,
             path: filePath,
-            error: error instanceof Error ? error.message : 'Unknown error',
-          },
-        };
-      }
-    });
+            encoding,
+          });
+          yield {
+            type: 'action:storage:read-file:result',
+            data: { success: true, content, path: filePath, encoding, mimeType, size },
+          };
+        } catch (error) {
+          yield {
+            type: 'action:storage:read-file:result',
+            data: {
+              success: false,
+              path: filePath,
+              error: error instanceof Error ? error.message : 'Unknown error',
+            },
+          };
+        }
+      });
 
-    builder.on('action:storage:get-file-url', async function* (event, context) {
-      const channelId = context.state.channelId;
-      const filePath = (event.data as { path?: string })?.path;
-      if (!filePath) {
-        yield {
-          type: 'action:storage:get-file-url:result',
-          data: { success: false, path: '', error: 'Path is required' },
-        };
-        return;
-      }
-      try {
-        const { size, mimeType } = await storage.getChannelFileStat({ channelId, path: filePath });
-        const url = buildWorkspaceFileUrl({
-          baseUrl: resolvePublicBaseUrl(),
-          channelId,
-          filePath,
-        });
-        yield {
-          type: 'action:storage:get-file-url:result',
-          data: { success: true, path: filePath, url, mimeType, size },
-        };
-      } catch (error) {
-        yield {
-          type: 'action:storage:get-file-url:result',
-          data: {
-            success: false,
+      builder.on('action:storage:get-file-url', async function* (event, context) {
+        const channelId = context.state.channelId;
+        const filePath = (event.data as { path?: string })?.path;
+        if (!filePath) {
+          yield {
+            type: 'action:storage:get-file-url:result',
+            data: { success: false, path: '', error: 'Path is required' },
+          };
+          return;
+        }
+        if (!channelId) {
+          yield {
+            type: 'action:storage:get-file-url:result',
+            data: { success: false, path: filePath, error: 'channelId is required' },
+          };
+          return;
+        }
+        try {
+          const { size, mimeType } = await storage.getChannelFileStat({
+            channelId,
             path: filePath,
-            error: error instanceof Error ? error.message : 'Unknown error',
-          },
-        };
-      }
-    });
-  },
+          });
+          const url = buildWorkspaceFileUrl({
+            baseUrl: resolvePublicBaseUrl(),
+            channelId,
+            filePath,
+          });
+          yield {
+            type: 'action:storage:get-file-url:result',
+            data: { success: true, path: filePath, url, mimeType, size },
+          };
+        } catch (error) {
+          yield {
+            type: 'action:storage:get-file-url:result',
+            data: {
+              success: false,
+              path: filePath,
+              error: error instanceof Error ? error.message : 'Unknown error',
+            },
+          };
+        }
+      });
+    },
 };
 
 export default storagePlugin;