Val Town Code SearchReturn to Val Town

85  console.log(e.text);
86
87  // Get Anthropic API key from environment
88  const apiKey = Deno.env.get("ANTHROPIC_API_KEY");
89  if (!apiKey) {
90    console.error("Anthropic API key is not configured for this val.");
91    return;
92  }
93
94  // Initialize Anthropic client
95  const anthropic = new Anthropic({ apiKey });
96
97  // Process each image attachment serially

92
93/**
94 * Format chat history for Anthropic API
95 */
96function formatChatHistoryForAI(history) {
321bot.on("message", async (ctx) => {
322  try {
323    // Get Anthropic API key from environment
324    const apiKey = Deno.env.get("ANTHROPIC_API_KEY");
325    if (!apiKey) {
326      console.error("Anthropic API key is not configured.");
327      ctx.reply(
328        "I apologize, but I'm not properly configured at the moment. Please inform the household administrator."
332
333    // Initialize Anthropic client
334    const anthropic = new Anthropic({ apiKey });
335
336    // Get message text and user info
502  // Set webhook if it is not set yet
503  if (!isEndpointSet) {
504    await bot.api.setWebhook(req.url, {
505      secret_token: SECRET_TOKEN,
506    });

27async function generateConciseWeatherSummary(weatherDay) {
28  try {
29    // Get API key from environment
30    const apiKey = Deno.env.get("ANTHROPIC_API_KEY");
31    if (!apiKey) {
32      console.error("Anthropic API key is not configured.");
33      return null;
34    }
35
36    // Initialize Anthropic client
37    const anthropic = new Anthropic({ apiKey });
38
39    const response = await anthropic.messages.create({

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;

13## Authentication
14
15Login to your SQLite Explorer with [password authentication](https://www.val.town/v/pomdtr/password_auth) with your [Val Town API Token](https://www.val.town/settings/api) as the password.
16
17## Todos / Plans

27      <head>
28        <title>SQLite Explorer</title>
29        <link rel="preconnect" href="https://fonts.googleapis.com" />
30
31        <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
32        <link
33          href="https://fonts.googleapis.com/css2?family=Fira+Code:wght@300..700&family=Source+Sans+3:ital,wght@0,200..900;1,200..900&display=swap"
34          rel="stylesheet"
35        />

3
4// Environment Variables to set in Val.Town for this specific val:
5// - NOTION_KEY: Your Notion API Key
6// - OPENAI_KEY: Your OpenAI API Key
7// - NOTION_USERS_DATABASE_ID: The Database ID for your "Reflection Users" database
8// - NOTION_DATABASE_ID: The Database ID for your "Reflections" database (submissions)
103    };
104
105    const userSearchResponse = await fetch(`https://api.notion.com/v1/databases/${NOTION_USERS_DB_ID}/query`, {
106      method: "POST",
107      headers: {
142
143        const reflectionSearchResponse = await fetch(
144          `https://api.notion.com/v1/databases/${NOTION_REFLECTIONS_DB_ID}/query`,
145          {
146            method: "POST",
206              console.log("getUserReflectionContext: Calling OpenAI for personalized welcome...");
207              try {
208                const openAIResponse = await fetch("https://api.openai.com/v1/chat/completions", {
209                  method: "POST",
210                  headers: { "Content-Type": "application/json", "Authorization": `Bearer ${OPENAI_KEY}` },
214                if (!openAIResponse.ok) {
215                  const errorBody = await openAIResponse.text();
216                  console.error("getUserReflectionContext: OpenAI API Error:", openAIResponse.status, errorBody);
217                  welcomeMessage = DEFAULT_RETURNING_USER_MESSAGE;
218                } else {

4
5// Environment Variables to set in Val.Town:
6// - OPENAI_KEY: Your OpenAI API Key
7// - NOTION_KEY: Your Notion API Key
8// - NOTION_DATABASE_ID: The Database ID for your "Reflections" database (submissions)
9// - NOTION_USERS_DATABASE_ID: The Database ID for your "Reflection Users" database
180    };
181    try {
182      const openAIResponse = await fetch("https://api.openai.com/v1/chat/completions", {
183        method: "POST",
184        headers: { "Content-Type": "application/json", "Authorization": `Bearer ${OPENAI_KEY}` },
187      if (!openAIResponse.ok) {
188        const errorBody = await openAIResponse.text();
189        console.error("Main Submission Handler: OpenAI API Error:", openAIResponse.status, errorBody);
190      }
191      else {
221      }
222    } catch (aiError) {
223      console.error("Main Submission Handler: Error calling OpenAI API:", aiError);
224    }
225
239    if (normalizedUserNumberFromForm) {
240      try {
241        const searchResponse = await fetch(`https://api.intercom.io/contacts/search`, {
242          method: "POST",
243          headers: {
251        if (!searchResponse.ok) {
252          const errorBody = await searchResponse.text();
253          console.error("Main Submission Handler: Intercom Search API Error:", searchResponse.status, errorBody);
254        }
255        else {
307            }
308
309            const eventResponse = await fetch("https://api.intercom.io/events", {
310              method: "POST",
311              headers: {
327            else console.log("Main Submission Handler: Intercom event submitted successfully.");
328
329            const contactDetailsResponse = await fetch(`https://api.intercom.io/contacts/${intercomContactId}`, {
330              headers: {
331                "Authorization": `Bearer ${INTERCOM_KEY}`,
380            // last_notion_reflection_url will be added later after Notion save
381
382            const updateResponse = await fetch(`https://api.intercom.io/contacts/${intercomContactId}`, {
383              method: "PUT",
384              headers: {
411                }
412                try {
413                  const tagResponse = await fetch(`https://api.intercom.io/contacts/${intercomContactId}/tags`, {
414                    method: "POST",
415                    headers: {
434                  }
435                } catch (taggingError) {
436                  console.error("Main Submission Handler: Error during tag application API call:", taggingError);
437                }
438              } else {
475      };
476      console.log("Main Submission Handler: Notion User Query Payload:", JSON.stringify(userQueryPayload, null, 2));
477      const userSearchResponse = await fetch(`https://api.notion.com/v1/databases/${NOTION_USERS_DB_ID}/query`, {
478        method: "POST",
479        headers: {
499          if (intercomProfileUrl && userSearchData.results[0].properties.IntercomProfile?.url !== intercomProfileUrl) {
500            console.log("Main Submission Handler: Attempting to update IntercomProfile URL on existing Notion User.");
501            await fetch(`https://api.notion.com/v1/pages/${notionUserPageId}`, {
502              method: "PATCH",
503              headers: {
528            JSON.stringify(newUserProperties, null, 2),
529          );
530          const createUserResponse = await fetch("https://api.notion.com/v1/pages", {
531            method: "POST",
532            headers: {
592    );
593
594    const reflectionNotionResponse = await fetch("https://api.notion.com/v1/pages", {
595      method: "POST",
596      headers: {
629          },
630        };
631        const updateNotionUrlResponse = await fetch(`https://api.intercom.io/contacts/${intercomContactId}`, {
632          method: "PUT",
633          headers: {