Val Town Code SearchReturn to Val Town

77async function generateFunFacts(previousFacts) {
78  try {
79    // Get API key from environment
80    const apiKey = Deno.env.get("ANTHROPIC_API_KEY");
81    if (!apiKey) {
82      console.error("Anthropic API key is not configured.");
83      return null;
84    }
85
86    // Initialize Anthropic client
87    const anthropic = new Anthropic({ apiKey });
88
89    // Format previous facts for the prompt

20### 2. HTTP Vals
21
22- Create web APIs and endpoints
23- Handle HTTP requests and responses
24- Example structure:
66- Generate code in TypeScript
67- Add appropriate TypeScript types and interfaces for all data structures
68- Prefer official SDKs or libraries than writing API calls directly
69- Ask the user to supply API or library documentation if you are at all unsure about it
70- **Never bake in secrets into the code** - always use environment variables
71- Include comments explaining complex logic (avoid commenting obvious operations)
190- For AI-generated images, use: `https://maxm-imggenurl.web.val.run/the-description-of-your-image`
191- **Storage:** DO NOT use the Deno KV module for storage
192- **Browser APIs:** DO NOT use the `alert()`, `prompt()`, or `confirm()` methods
193- **Weather Data:** Use open-meteo for weather data (doesn't require API keys) unless otherwise specified
194- **View Source:** Add a view source link with `import.meta.url.replace("esm.town", "val.town")` and include `target="_top"` attribute
195- **Error Debugging:** Add `<script src="https://esm.town/v/std/catch"></script>` to HTML to capture client-side errors
196- **Error Handling:** Only use try...catch when there's a clear local resolution; avoid catches that merely log or return 500s - let errors bubble up with full context
197- **Environment Variables:** Use `Deno.env.get('keyname')` and minimize their use - prefer APIs without keys
198- **Imports:** Use `https://esm.sh` for npm and Deno dependencies to ensure compatibility on server and browser
199- **Storage Strategy:** Only use backend storage if explicitly required; prefer simple static client-side sites
230
231### Backend (Hono) Best Practices
232- Hono is the recommended API framework (similar to Express, Flask, or Sinatra)
233- Main entry point should be `backend/index.ts`
234- **Static asset serving:** Use the utility functions to read and serve project files:
251  });
252  ```
253- Create RESTful API routes for CRUD operations
254- Be careful with error handling as Hono tends to swallow errors
255- Always include this snippet at the top-level Hono app to re-throwing errors to see full stack traces:
268- Use React 18.2.0 consistently in all imports and the `@jsxImportSource` pragma
269- Follow the React component pattern from the example project
270- Handle API calls properly with proper error catching
271
272### Database Patterns
299   - For files in the project, use `readFile` helpers
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`

10import { NotebookView } from "./NotebookView.tsx";
11
12const API_BASE = "/api/memories";
13const MEMORIES_PER_PAGE = 20; // Increased from 7 to 20 memories per page
14
90
91    // Fetch avatar image
92    fetch("/api/images/stevens.jpg")
93      .then((response) => {
94        if (response.ok) return response.blob();
104
105    // Fetch wood background
106    fetch("/api/images/wood.jpg")
107      .then((response) => {
108        if (response.ok) return response.blob();
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}`);
176
177    try {
178      const response = await fetch(API_BASE, {
179        method: "POST",
180        headers: { "Content-Type": "application/json" },
199
200    try {
201      const response = await fetch(`${API_BASE}/${id}`, {
202        method: "DELETE",
203      });
231
232    try {
233      const response = await fetch(`${API_BASE}/${editingMemory.id}`, {
234        method: "PUT",
235        headers: { "Content-Type": "application/json" },
606    <div className="font-pixel text-[#f8f1e0]">
607      <style jsx>{`
608        @import url("https://fonts.googleapis.com/css2?family=Pixelify+Sans&display=swap");
609
610        @tailwind base;

1export default async function(req: Request) {
2  try {
3    const apiKey = Deno.env.get("VALTOWN_API_TOKEN");
4
5    if (!apiKey) {
6      return new Response(
7        JSON.stringify({ error: "VALTOWN_API_TOKEN not found" }, null, 2),
8        { status: 400, headers: { "Content-Type": "application/json" } },
9      );
11
12    // Get my vals using the authenticated /me/vals endpoint
13    const valsResponse = await fetch("https://api.val.town/v2/me/vals", {
14      headers: {
15        "Authorization": `Bearer ${apiKey}`,
16        "Content-Type": "application/json",
17      },
20    if (!valsResponse.ok) {
21      const errorText = await valsResponse.text();
22      console.log("API Error response:", errorText);
23      throw new Error(
24        `Failed to fetch vals: ${valsResponse.status} ${valsResponse.statusText}. Response: ${errorText}`,
42    for (const val of vals) {
43      try {
44        // Use the files API to get the actual file structure
45        const filesResponse = await fetch(
46          `https://api.val.town/v2/vals/${val.id}/files?path=&recursive=true&limit=100`,
47          {
48            headers: {
49              "Authorization": `Bearer ${apiKey}`,
50              "Content-Type": "application/json",
51            },
80                // First get the file metadata to get the HTTP URL
81                const fileContentResponse = await fetch(
82                  `https://api.val.town/v2/vals/${val.id}/files?path=${encodeURIComponent(endpointsFile.path)}`,
83                  {
84                    headers: {
85                      "Authorization": `Bearer ${apiKey}`,
86                      "Content-Type": "application/json",
87                    },

6⦿ The system can use natural language processing to analyze user input and suggest the next best course or module.
7
8⦿ Built using open-source tools like LangChain, and doesn't require paid APIs. Perfect for educational startups or personal use.`;
9}

12    <html>
13      <head>
14        <title>Test Person Enrichment API</title>
15        <script src="https://cdn.twind.style" crossOrigin="anonymous"></script>
16        <script src="https://esm.town/v/std/catch"></script>
50      <body>
51        <div className="container">
52          <h1>Test Person Enrichment API</h1>
53          <p>Endpoint: <code>${endpointUrl}</code></p>
54          <form id="enrichmentForm">
124                  
125                  responseArea.textContent = JSON.stringify(result, null, 2);
126                  // Check for result.success as per the target API spec in index.ts (PersonEnrichmentResponse)
127                  if (response.ok && result.success) { 
128                    responseArea.className = 'success';

6⦿ Can be implemented using open-source tools like LangChain or HuggingFace.
7
8⦿ Doesn't require a paid API and is suitable for educational or practical purposes.`;
9}

18    return serveFile(path, import.meta.url);
19  }
20  if (path.startsWith("/api/list")) {
21    // Get all rows from lab_upload_blobs
22    const response = await sqlite.execute(`
26    return Response.json({ ok: true, rows: response.rows });
27  }
28  if (path.startsWith("/api/upload")) {
29    return upload(req);
30  }
31  if (path.startsWith("/api/delete")) {
32    return _delete(req);
33  }

230      uploadButton.disabled = true;
231      uploadButton.textContent = "Uploading...";
232      const response = await fetch("/api/upload", {
233        method: "POST",
234        body,
251
252  async function fetchUploads() {
253    const response = await fetch("/api/list");
254    const data = await response.json();
255    return data.rows;
395        deleteButton.textContent = "Deleting...";
396        const response = await fetch(
397          `/api/delete`,
398          {
399            method: "POST",

6⦿ Can be implemented using open-source tools like LangChain or HuggingFace.
7
8⦿ Doesn't require a paid API and is suitable for educational or practical purposes.`;
9}