Val Town Code SearchReturn to Val Town

24## Data Store REST
25
26SAP Customer Data Cloud's Data Store (DS) API consists of the methods listed below.
27
28```
167```
168scenario). This parameter may
169not be used with REST APIs.
170```
171```
186## Authorization Parameters
187
188Each REST API request must contain identication and authorization parameters.
189
190Some REST APIs may function without these authorization parameters, however, when that occurs, these calls are treated as
191
192client-side calls and all client-side rate limits will apply. In order to not reach client-side IP rate limits that may impact your
194implementation when using server-to-server REST calls, it is Recommended Best Practice to always use an application key and
195
196secret or a bearer token when sending requests. A non-exhaustive list of REST APIs that this may apply to are as follows:
197
198```
231```
232```
233apiVersion integer Denes the API version that returned the
234response and may not always be returned.
235```
388registration completion
389scenario). This parameter may
390not be used with REST APIs.
391```
392```
416## Authorization Parameters
417
418Each REST API request must contain identication and authorization parameters.
419
420Some REST APIs may function without these authorization parameters, however, when that occurs, these calls are treated as
421
422client-side calls and all client-side rate limits will apply. In order to not reach client-side IP rate limits that may impact your
424implementation when using server-to-server REST calls, it is Recommended Best Practice to always use an application key and
425
426secret or a bearer token when sending requests. A non-exhaustive list of REST APIs that this may apply to are as follows:
427
428```
461```
462```
463apiVersion integer Denes the API version that returned the
464response and may not always be returned.
465```
645registration completion
646scenario). This parameter may
647not be used with REST APIs.
648```
649```
664## Authorization Parameters
665
666Each REST API request must contain identication and authorization parameters.
667
668Some REST APIs may function without these authorization parameters, however, when that occurs, these calls are treated as
669
670client-side calls and all client-side rate limits will apply. In order to not reach client-side IP rate limits that may impact your
672implementation when using server-to-server REST calls, it is Recommended Best Practice to always use an application key and
673
674secret or a bearer token when sending requests. A non-exhaustive list of REST APIs that this may apply to are as follows:
675
676```
709```
710```
711apiVersion integer Denes the API version that returned the
712response and may not always be returned.
713```
938registration completion
939scenario). This parameter may
940not be used with REST APIs.
941```
942```
969## Authorization Parameters
970
971Each REST API request must contain identication and authorization parameters.
972
973Some REST APIs may function without these authorization parameters, however, when that occurs, these calls are treated as
974
975client-side calls and all client-side rate limits will apply. In order to not reach client-side IP rate limits that may impact your
977implementation when using server-to-server REST calls, it is Recommended Best Practice to always use an application key and
978
979secret or a bearer token when sending requests. A non-exhaustive list of REST APIs that this may apply to are as follows:
980
981```
1014```
1015```
1016apiVersion integer Denes the API version that returned the
1017response and may not always be returned.
1018```
1135## Authorization Parameters
1136
1137Each REST API request must contain identication and authorization parameters.
1138
1139Some REST APIs may function without these authorization parameters, however, when that occurs, these calls are treated as
1140
1141client-side calls and all client-side rate limits will apply. In order to not reach client-side IP rate limits that may impact your
1143implementation when using server-to-server REST calls, it is Recommended Best Practice to always use an application key and
1144
1145secret or a bearer token when sending requests. A non-exhaustive list of REST APIs that this may apply to are as follows:
1146
1147```
1192```
1193```
1194apiVersion integer Denes the API version that returned the
1195response and may not always be returned.
1196```
1718registration completion
1719scenario). This parameter may
1720not be used with REST APIs.
1721```
1722```
1737## Authorization Parameters
1738
1739Each REST API request must contain identication and authorization parameters.
1740
1741Some REST APIs may function without these authorization parameters, however, when that occurs, these calls are treated as
1742
1743client-side calls and all client-side rate limits will apply. In order to not reach client-side IP rate limits that may impact your
1745implementation when using server-to-server REST calls, it is Recommended Best Practice to always use an application key and
1746
1747secret or a bearer token when sending requests. A non-exhaustive list of REST APIs that this may apply to are as follows:
1748
1749```
1776```
1777```
1778apiVersion integer Denes the API version that returned the
1779response and may not always be returned.
1780```
1962## Description
1963
1964This page shows examples using the ds.search REST API.
1965
1966## Examples
2284## Authorization Parameters
2285
2286Each REST API request must contain identication and authorization parameters.
2287
2288Some REST APIs may function without these authorization parameters, however, when that occurs, these calls are treated as
2289
2290client-side calls and all client-side rate limits will apply. In order to not reach client-side IP rate limits that may impact your
2292implementation when using server-to-server REST calls, it is Recommended Best Practice to always use an application key and
2293
2294secret or a bearer token when sending requests. A non-exhaustive list of REST APIs that this may apply to are as follows:
2295
2296```
2527```
2528```
2529apiVersion integer Denes the API version that returned the
2530response and may not always be returned.
2531```
2795```
2796"arrayPush" (default) - will cause
2797arrays data provided with this API
2798call to be appended to existing
2799arrays data in the DB.
2803of existing arrays data in the DB
2804with the values of arrays data
2805provided with this API call.
2806```
2807```
2828in a registration completion scenario). This
2829parameter may not be used with REST
2830APIs.
2831```
2832```
2845
2846
2847Each REST API request must contain identication and authorization parameters.
2848
2849Some REST APIs may function without these authorization parameters, however, when that occurs, these calls are treated as
2850
2851client-side calls and all client-side rate limits will apply. In order to not reach client-side IP rate limits that may impact your
2853implementation when using server-to-server REST calls, it is Recommended Best Practice to always use an application key and
2854
2855secret or a bearer token when sending requests. A non-exhaustive list of REST APIs that this may apply to are as follows:
2856
2857```
2890```
2891```
2892apiVersion integer Denes the API version that returned the
2893response and may not always be returned.
2894```
2952oid string The object's unique identier. The value is
2953either the oid parameter that you specied
2954in the API call or a unique string generated
2955by SAP Customer Data Cloud (if you have
2956set the parameter to be "auto").

97
98export async function sendDailyBriefing(chatId?: string, today?: DateTime) {
99  // Get API keys from environment
100  const apiKey = Deno.env.get("ANTHROPIC_API_KEY");
101  const telegramToken = Deno.env.get("TELEGRAM_TOKEN");
102
106  }
107
108  if (!apiKey) {
109    console.error("Anthropic API key is not configured.");
110    return;
111  }
122
123  // Initialize Anthropic client
124  const anthropic = new Anthropic({ apiKey });
125
126  // Initialize Telegram bot
162
163  // disabled title for now, it seemes unnecessary...
164  // await bot.api.sendMessage(chatId, `*${title}*`, { parse_mode: "Markdown" });
165
166  // Then send the main content
169
170  if (content.length <= MAX_LENGTH) {
171    await bot.api.sendMessage(chatId, content, { parse_mode: "Markdown" });
172    // Store the briefing in chat history
173    await storeChatMessage(
198    // Send each chunk as a separate message and store in chat history
199    for (const chunk of chunks) {
200      await bot.api.sendMessage(chatId, chunk, { parse_mode: "Markdown" });
201      // Store each chunk in chat history
202      await storeChatMessage(

53You'll need to set up some environment variables to make it run.
54
55- `ANTHROPIC_API_KEY` for LLM calls
56- You'll need to follow [these instructions](https://docs.val.town/integrations/telegram/) to make a telegram bot, and set `TELEGRAM_TOKEN`. You'll also need to get a `TELEGRAM_CHAT_ID` in order to have the bot remember chat contents.
57- For the Google Calendar integration you'll need `GOOGLE_CALENDAR_ACCOUNT_ID` and `GOOGLE_CALENDAR_CALENDAR_ID`. See [these instuctions](https://www.val.town/v/stevekrouse/pipedream) for details.

8## Hono
9
10This app uses [Hono](https://hono.dev/) as the API framework. You can think of Hono as a replacement for [ExpressJS](https://expressjs.com/) that works in serverless environments like Val Town or Cloudflare Workers. If you come from Python or Ruby, Hono is also a lot like [Flask](https://github.com/pallets/flask) or [Sinatra](https://github.com/sinatra/sinatra), respectively.
11
12## Serving assets to the frontend
20### `index.html`
21
22The most complicated part of this backend API is serving index.html. In this app (like most apps) we serve it at the root, ie `GET /`. 
23
24We *bootstrap* `index.html` with some initial data from the server, so that it gets dynamically injected JSON data without having to make another round-trip request to the server to get that data on the frontend. This is a common pattern for client-side rendered apps.
25
26## CRUD API Routes
27
28This app has two CRUD API routes: for reading and inserting into the messages table. They both speak JSON, which is standard. They import their functions from `/backend/database/queries.ts`. These routes are called from the React app to refresh and update data.
29
30## Errors
31
32Hono and other API frameworks have a habit of swallowing up Errors. We turn off this default behavior by re-throwing errors, because we think most of the time you'll want to see the full stack trace instead of merely "Internal Server Error". You can customize how you want errors to appear.

8import { type Memory } from "../../shared/types.ts";
9
10const API_BASE = "/api/memories";
11const MEMORIES_PER_PAGE = 20;
12
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}`);
100
101    try {
102      const response = await fetch(API_BASE, {
103        method: "POST",
104        headers: { "Content-Type": "application/json" },
123
124    try {
125      const response = await fetch(`${API_BASE}/${id}`, {
126        method: "DELETE",
127      });
155
156    try {
157      const response = await fetch(`${API_BASE}/${editingMemory.id}`, {
158        method: "PUT",
159        headers: { "Content-Type": "application/json" },

18});
19
20// --- API Routes for Memories ---
21
22// GET /api/memories - Retrieve all memories
23app.get("/api/memories", async (c) => {
24  const memories = await getAllMemories();
25  return c.json(memories);
26});
27
28// POST /api/memories - Create a new memory
29app.post("/api/memories", async (c) => {
30  const body = await c.req.json<Omit<Memory, "id">>();
31  if (!body.text) {
36});
37
38// PUT /api/memories/:id - Update an existing memory
39app.put("/api/memories/:id", async (c) => {
40  const id = c.req.param("id");
41  const body = await c.req.json<Partial<Omit<Memory, "id">>>();
58});
59
60// DELETE /api/memories/:id - Delete a memory
61app.delete("/api/memories/:id", async (c) => {
62  const id = c.req.param("id");
63  try {
75// --- Blob Image Serving Routes ---
76
77// GET /api/images/:filename - Serve images from blob storage
78app.get("/api/images/:filename", async (c) => {
79  const filename = c.req.param("filename");
80

12      type="image/svg+xml"
13    />
14    <link rel="preconnect" href="https://fonts.googleapis.com" />
15    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
16    <link
17      href="https://fonts.googleapis.com/css2?family=Pixelify+Sans:wght@400..700&display=swap"
18      rel="stylesheet"
19    />

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({