Val Town Code SearchReturn to Val Town

2 * Frontend MCP Prompts Utility
3 *
4 * Handles fetching prompts from MCP servers directly from the frontend
5 * without requiring backend proxy endpoints.
6 */
23
24/**
25 * Fetch prompts from a single MCP server
26 * @param server - MCP server configuration
27 * @returns Promise<MCPPrompt[]>
28 */
29async function fetchPromptsFromServer(server: MCPServerConfig): Promise<MCPPrompt[]> {
30  if (!server.enabled || !server.url) {
31    return [];
47    try {
48      // First, initialize the connection
49      const initResponse = await fetch(server.url, {
50        method: "POST",
51        headers,
71      }
72
73      // Then fetch prompts
74      const promptsResponse = await fetch(server.url, {
75        method: "POST",
76        headers,
100        }
101      }
102    } catch (fetchError: any) {
103      clearTimeout(timeoutId);
104
105      if (fetchError.name === "AbortError") {
106        console.warn(`Timeout fetching prompts from ${server.name}`);
107      } else {
108        throw fetchError;
109      }
110    }
112    return [];
113  } catch (error) {
114    console.warn(`Failed to fetch prompts from ${server.name}:`, error);
115    return [];
116  }
118
119/**
120 * Fetch prompts from all enabled MCP servers
121 * @param servers - Array of MCP server configurations
122 * @returns Promise<MCPPromptsResult>
123 */
124export async function fetchMCPPrompts(servers: MCPServerConfig[]): Promise<MCPPromptsResult> {
125  try {
126    if (!servers || !Array.isArray(servers)) {
141    }
142
143    // Fetch prompts from all enabled servers concurrently
144    const promptPromises = enabledServers.map(server => fetchPromptsFromServer(server));
145    const promptArrays = await Promise.all(promptPromises);
146
175
176/**
177 * Fetch prompts with caching support
178 * @param servers - Array of MCP server configurations
179 * @param cacheKey - Optional cache key for localStorage
181 * @returns Promise<MCPPromptsResult>
182 */
183export async function fetchMCPPromptsWithCache(
184  servers: MCPServerConfig[],
185  cacheKey: string = "mcp_prompts_cache",
202    }
203
204    // Fetch fresh data
205    const result = await fetchMCPPrompts(servers);
206
207    // Cache successful results
223      try {
224        const { data } = JSON.parse(cached);
225        console.warn("Using stale cached prompts due to fetch error:", error);
226        return {
227          success: true,

19});
20
21export default app.fetch;

22);
23
24export default app.fetch;
25

3  let videoId = "https://www.youtube.com/watch?v=5orZtBqftE8";
4  console.log("starting...");
5  let x = YoutubeTranscript.fetchTranscript(videoId);
6  console.log(x);
7};

20    });
21  } catch (error) {
22    console.error('Error fetching products:', error);
23    return c.json<ApiResponse<null>>({
24      success: false,
25      error: "Failed to fetch products"
26    }, 500);
27  }
37    });
38  } catch (error) {
39    console.error('Error fetching low stock products:', error);
40    return c.json<ApiResponse<null>>({
41      success: false,
42      error: "Failed to fetch low stock products"
43    }, 500);
44  }
69    });
70  } catch (error) {
71    console.error('Error fetching product:', error);
72    return c.json<ApiResponse<null>>({
73      success: false,
74      error: "Failed to fetch product"
75    }, 500);
76  }
259    });
260  } catch (error) {
261    console.error('Error fetching stock movements:', error);
262    return c.json<ApiResponse<null>>({
263      success: false,
264      error: "Failed to fetch stock movements"
265    }, 500);
266  }
278    });
279  } catch (error) {
280    console.error('Error fetching all stock movements:', error);
281    return c.json<ApiResponse<null>>({
282      success: false,
283      error: "Failed to fetch stock movements"
284    }, 500);
285  }

135  const lastSunday = today.startOf("week").minus({ days: 1 });
136
137  // Fetch relevant memories using the utility function
138  const memories = await getRelevantMemories();
139

67  const [currentPage, setCurrentPage] = useState(1);
68
69  const fetchMemories = useCallback(async () => {
70    setLoading(true);
71    setError(null);
72    try {
73      const response = await fetch(API_BASE);
74      if (!response.ok) {
75        throw new Error(`HTTP error! status: ${response.status}`);
78      setMemories(data);
79    } catch (e) {
80      console.error("Failed to fetch memories:", e);
81      setError(e.message || "Failed to fetch memories.");
82    } finally {
83      setLoading(false);
86
87  useEffect(() => {
88    fetchMemories();
89  }, [fetchMemories]);
90
91  const handleAddMemory = async (e: React.FormEvent) => {
100
101    try {
102      const response = await fetch(API_BASE, {
103        method: "POST",
104        headers: { "Content-Type": "application/json" },
112      setNewMemoryTags("");
113      setShowAddForm(false);
114      await fetchMemories();
115    } catch (e) {
116      console.error("Failed to add memory:", e);
123
124    try {
125      const response = await fetch(`${API_BASE}/${id}`, {
126        method: "DELETE",
127      });
129        throw new Error(`HTTP error! status: ${response.status}`);
130      }
131      await fetchMemories();
132    } catch (e) {
133      console.error("Failed to delete memory:", e);
155
156    try {
157      const response = await fetch(`${API_BASE}/${editingMemory.id}`, {
158        method: "PUT",
159        headers: { "Content-Type": "application/json" },
164      }
165      setEditingMemory(null);
166      await fetchMemories();
167    } catch (e) {
168      console.error("Failed to update memory:", e);

135  ));
136
137// HTTP vals expect an exported "fetch handler"
138export default app.fetch;

163```
164
1655. **fetchTranspiledJavaScript** - Fetch and transpile TypeScript to JavaScript:
166```ts
167const jsCode = await fetchTranspiledJavaScript("https://esm.town/v/username/project/path/to/file.ts");
168```
169
242
243    // Inject data to avoid extra round-trips
244    const initialData = await fetchInitialData();
245    const dataScript = `<script>
246      window.__INITIAL_DATA__ = ${JSON.stringify(initialData)};
300
3015. **API Design:**
302   - `fetch` handler is the entry point for HTTP vals
303   - Run the Hono app with `export default app.fetch // This is the entry point for HTTP vals`
304   - Properly handle CORS if needed for external access

82  const [cookieAndTeaMode, setCookieAndTeaMode] = useState(false);
83
84  // Fetch images from backend instead of blob storage directly
85  useEffect(() => {
86    // Set default background color in case image doesn't load
89    }
90
91    // Fetch avatar image
92    fetch("/api/images/stevens.jpg")
93      .then((response) => {
94        if (response.ok) return response.blob();
103      });
104
105    // Fetch wood background
106    fetch("/api/images/wood.jpg")
107      .then((response) => {
108        if (response.ok) return response.blob();
129  }, []);
130
131  const fetchMemories = useCallback(async () => {
132    setLoading(true);
133    setError(null);
134    try {
135      const response = await fetch(API_BASE);
136      if (!response.ok) {
137        throw new Error(`HTTP error! status: ${response.status}`);
154      }
155    } catch (e) {
156      console.error("Failed to fetch memories:", e);
157      setError(e.message || "Failed to fetch memories.");
158    } finally {
159      setLoading(false);
162
163  useEffect(() => {
164    fetchMemories();
165  }, [fetchMemories]);
166
167  const handleAddMemory = async (e: React.FormEvent) => {
176
177    try {
178      const response = await fetch(API_BASE, {
179        method: "POST",
180        headers: { "Content-Type": "application/json" },
188      setNewMemoryTags("");
189      setShowAddForm(false);
190      await fetchMemories();
191    } catch (e) {
192      console.error("Failed to add memory:", e);
199
200    try {
201      const response = await fetch(`${API_BASE}/${id}`, {
202        method: "DELETE",
203      });
205        throw new Error(`HTTP error! status: ${response.status}`);
206      }
207      await fetchMemories();
208    } catch (e) {
209      console.error("Failed to delete memory:", e);
231
232    try {
233      const response = await fetch(`${API_BASE}/${editingMemory.id}`, {
234        method: "PUT",
235        headers: { "Content-Type": "application/json" },
240      }
241      setEditingMemory(null);
242      await fetchMemories();
243    } catch (e) {
244      console.error("Failed to update memory:", e);