Radio Starlight — Official User Guide

Design, generate, and publish living radio programs from the web’s freshest content. This guide walks you through setup, content preparation, program design (Basic or Custom), generation, playback, and publishing.

Note: UI labels may vary slightly by platform and version. Where you see Library → X, read it as navigating within the app’s sidebar and panels.

Table of contents

1. Quick start
2. Before you begin
3. Prepare your Library
   3.1 Personalities · 3.2 Sound Sets · 3.3 Feeds · 3.4 APIs · 3.5 Pages · 3.6 Generative AIs · 3.7 Credentials
4. Build a Program
   4.1 Basic Program · 4.2 Custom Program
5. Generate & Play
6. Publish (optional)
7. Prompt mini‑guide
8. Troubleshooting
9. Glossary

Quick start

Import a starter Catalog

1. In the app, open Library → Catalogs → Import → URL...
2. Paste the following URL.

https://catalog.radio-starlight.com/Catalogs/Featured/Starter-Catalog/

3. Click Import, and confirm.

What this does: Imports starter Personalities, Sound Sets, source definitions, and program templates so you can try Radio Starlight immediately.

Before you begin

Voices for speech (recommended)

Download high‑quality system voices used by the Pre‑defined personalities for natural narration.

• Nathan (Enhanced)
• Samantha (Enhanced)
• Zoe (Enhanced)
• Ava (Enhanced)

How to download

• iOS / iPadOS: Settings → Accessibility → Spoken Content (or Read & Speak*) → Voices → English → [select a voice] → Download`
• macOS: System Settings → Accessibility → Spoken Content (or Read & Speak*) → System Voice → English → [select a voice] → Download`

After downloading, return to the Personality view; the notice will clear automatically. Note: Voice availability can vary by device and OS version.

Music playback (optional):

Apple Music playback requires an active subscription and authorization in the app.

Model access:

If you plan to use cloud models (e.g., OpenAI, Gemini), have your API keys ready. For on‑device generation on Apple hardware, ensure your device supports Apple Foundation Models / Image Playground.

Prepare your Library

Your Library holds everything programs reference: Personalities, Sound Sets, Feeds, APIs, Pages, Generative AIs, and Credentials.

Personalities

Use a predefined personality (fastest):

1. Open Library → Personalities.
2. Ensure a high‑quality system voice is downloaded (see Before you begin).

Create a new personality:

1. Library → Personalities → Add (top‑right).
2. Fill out fields.
3. Save.

Roles

• DJ and Sidekick speak in talk segments.
• Newsreader speaks in news segments.
• System provides openings, transitions, or guidance.
• You specify personality for specific segment in Custom Program.

Description

• The description informs the script generator and keeps the on‑air persona consistent across segments and episodes. Write it as if you’re briefing talent (e.g., “Warm, witty, keeps segments tight. Loves local culture facts.”).

Sound Sets

Create the sound of your station—beds, bumpers.

1. Library → Sound Sets → Add.
2. Name the set, then add sound elements (BGM, Jingle).
3. Save.

Tip: Keep names descriptive so it’s easy to target from programs.

Feeds

Connect RSS/Atom/JSON feeds for headlines and updates.

1. Library → Feeds → Add.
2. Import From Website (recommended)
   • Enter the Site Home URL and click Fetch feed info.
   • Click Use These to auto‑populate if a feed is advertised.
3. Or fill fields manually.
4. Click Test Load to verify.
5. Save.

Preview

• Use Preview This Feed to inspect actual items before using them in a program.

Details panel

• Original content extraction: If a feed item is thin, enable loading the item’s webpage and extract the main article body.
• Summarization: If items are long, enable summarization before passing to the LLM.
• Translation: Optionally translate to your program language.

Model note: Extraction, summarization, and translation require a generative model with a sufficiently large model with large context window. Assign an appropriate model in Generative AIs.

APIs

Use any accessible API that returns JSON.

1. Library → APIs → Add API Content.
2. Fill fields as needed.
3. Define Prompt Arguments (see below) so segments can reference returned data.
4. Save

Prompt Arguments

• Map JSON fields to named arguments that your prompts can reference.

• Example JSON:

  {
    "contents": [
      { "article": "content 1" },
      { "article": "content 2" }
    ]
  }
  

• To pass "content 1" under the name article, use the data path:

  ["contents"][0]["article"]
  

Special argument keys

• link — URL for attribution in the player during the related segment.
• image — Image URL shown in the player during the related segment.

Tip: Name arguments clearly. Your prompt reads better and is easier to maintain.

Pages

Turn any public webpage into segment input.

1. Library → Pages → Add Page Content.
2. Fill fields as needed.
3. Choose content processing:
   • Extract main content (boilerplate removal)
   • Summarize
   • Translate to target language
4. Save

Model note: Extraction, summarize and translate also require a large model with a larger context window and multilingual capability.

Generative AIs

Declare the text and image engines you plan to use.

1. Library → Generative AIs → Add.
2. Fill fields as needed.
3. For cloud services needing auth, use placeholders for credentials (see below).
4. Save.

Tip: Create multiple entries (e.g., a long‑context model for content processing and a fast model for small segment), then assign per phase in Program Settings.

Credentials

Store secrets in the system Keychain and reference them safely.

• Never paste API keys directly into headers or body.
• Use the credentials placeholder anywhere a secret belongs:

Authorization: Bearer <credentials:ServiceApiKey>

How to set

1. Add your API (or Page) with the placeholder as shown above and Save.
2. Reopen it: the placeholder appears highlighted in pink with a status badge (Missing / Available).
3. Click the badge to open the Credential sheet and create or link the keychain entry.

You can also manage all secrets in App Settings → Credentials.

Recommendation: Prefer adding credentials from the placeholder workflow to avoid typos and ensure correct binding.

Build a Program

Choose Basic for an instant auto‑generated show, or Custom for segment‑by‑segment control.

Basic Program

Automates most choices while letting you pick sources.

1. Library → Programs → Add → Basic Program.
2. Fill the General panel.
3. Contents panel:
   • (Optional) Select Apple Music playlists to include music interludes. (Your Apple Music subscription required.)
   • Add Feeds, API Content, and Page Content from your Library—or create new ones inline.
4. Settings panel:
   • Playback options.
   • Select Generative AIs for each phase (content processing, script generation, image generation).

     Defaults inherit from App Settings; override here if needed.

5. Save.

Result: A ready‑to‑generate show that cites sources and uses your default personality and sound.

Custom Program

Design your format, segment order, prompts.

1. Library → Programs → Add → Custom Program.
2. Fill the General panel.
3. Segments panel: Add and arrange segments.
   • Static Segment: A selected personality reads predefined text (great for intros/outros, sponsor reads).
   • Custom Segment: One or more personalities discuss selected content (Feeds/APIs/Pages). Attach a prompt to guide generation.
   • Templates: Start from reusable segment templates (the same ones Basic uses under the hood) and tweak.
4. Settings panel:
   • Playback options.
   • Select Generative AIs for each phase (content processing, script generation, image generation).
5. Save.

See more about prompt design in Using API Templates with Placeholders and Edit Prompts.

Generate & Play

1. Open your Program and tap Generate.
   • If prerequisites are missing, a Readiness Checklist appears. Complete all items.
2. After generation, a Broadcast (the generated show) appears under the program.
3. Open the broadcast and tap Play.
   • If Autoplay is enabled, playback starts automatically.
4. During playback, the player shows:
   • The live script
   • Related images
   • Source links and attribution
   • (If provided) per‑item link and image metadata from your API arguments

Publish (optional)

Exoprt your designed program, generated broadcast, sources, personalities, and Sound Sets then share it.

1. Open a entity you want to export.
2. Choose Export.

You can publish your data set for your listener with Starlight Catalog Service. User can register your catalog in Library → Catalogs → Import.

See also StarlightCatalogService.

Troubleshooting

I don’t hear speech / the voice sounds robotic

• Ensure a high‑quality system voice is downloaded (see Before you begin).
• Check to select the correct voice.

A feed won’t load or is empty

• Use Import From Website again to detect the correct feed URL.
• Click Preview This Feed to verify items exist.
• If items are short, enable Deep load in Details.

Generation fails or truncates

• Assign a model with a larger context window in Program → Settings → Generative AIs for content processing and script generation.
• Reduce the number/length of source items or enable Summarization.

Credentials show “Missing”

• Open the source, click the status badge, and add the key in the Credential sheet.
• Or manage secrets in App Settings → Credentials.

Apple Music tracks don’t play

• Confirm your Apple Music subscription and that the app has playback authorization.
• Re‑select playlists in Program → Contents.

Attribution isn’t appearing in the player

• For APIs, map link and (optionally) image in Prompt Arguments.
• For Pages and Feeds, ensure the source item has a valid URL after extraction.

Glossary

• Broadcast: A generated, playable show (an instance of a Program).
• Catalog: A portable collection of programs, sources, personalities, and sound assets.
• Custom Program: A fully designed format with per‑segment prompts, sources, and roles.
• Basic Program: Quick, auto‑generated format built from your chosen sources.
• Details panel: Advanced feed/page processing options: extraction, summarization, translation.
• Generative AIs: Configured text/image engines (cloud or on‑device) referenced by Programs.
• Personality: On‑air voice definition (role, tone, quirks) used by segments.
• Sound Set: Music beds, stingers used throughout your show.
• Sources: Feeds, APIs, and Pages that supply content to segments.

You’re ready to broadcast

Build your first show in minutes:

• Use Basic to go fast.
• Use Custom to craft your signature format. Generate, play, and (optionally) publish to the open catalog.

Edit Prompts for your scripting

There are two ways to generate programs:

• Basic Program (no prompt editing): The app writes the prompt behind the scenes and aggregates attached API Content, Page Content, and Feed. You still provide content. For API items, define the system‑recognized keys in the API Content Editor.
• Custom Program (prompt editing): Full control. Each segment uses one source item (API, Page, Feed or Music). No aggregation in Custom.

This guide covers:

• What you can (and can’t) edit
• System‑recognized keys (Core vs Display; who sets them)
• Editing prompts (Custom Program only): types, placeholders, conditionals, templates
• How Basic Program uses your aggregated content (internal behavior)
• Tips & troubleshooting

0) What you can (and can’t) edit

1) System‑recognized keys (Core + Display)

These keys have special meaning to the app and are also available as prompt placeholders in Custom Program. In Basic Program, the engine consumes the same keys internally (no visible prompt).

API Content — user‑defined in API Content Editor

• Core → feed the script/prompt title, text → Custom: <source.api.title>, <source.api.text>; Basic (internal aggregation): <apiContent.title>, <apiContent.text>.
• Display → power the visual card/UI image, link → Custom: <source.api.image>, <source.api.link>; Basic (internal): <apiContent.image>, <apiContent.link>.

Important (Basic): When you attach API content to a Basic program, you must set title and text (and optionally image, link) for each API item in the API Content Editor. The app does not infer these.

Page Content — app‑defined

• Core → pageTitle (fallback title), content Custom: <source.page.title>, <source.page.text>; Basic (internal): <pageContent.title>, <pageContent.text>.
• Display → ogimage, finalUrl Custom: <source.page.ogimage>, <source.page.finalUrl>; Basic (internal): <pageContent.ogimage>, <pageContent.finalUrl>.

Indexing (Basic aggregation only): append .1, .2, … to target a specific attached item (e.g., <apiContent.image.2>). Concatenated (Basic only): <apiContent.concatenated>, <pageContent.concatenated> join each item as title\ntext blocks.

Feed

• Basic (aggregated): internal values like newsEnabled, news.feedNames, news.headline.
• Custom (single source): placeholders available in prompts: <source.feed.title>, <source.feed.text>, <source.feed.headline>.

2) Editing prompts (Custom Program only)

In Custom Program you can open a segment and edit its prompt. Basic segments never show a prompt editor.

Where to edit (Custom)

1. Open the segment (Custom Program).

2. Tap Edit Prompt.

3. You’ll see:

   • Prompt Type (System / User / Duo / Solo / Multilang)
   • Prompt Content (text editor)
   • Insert Placeholder (a + menu)

Pick the right Prompt Type (Custom)

• System – Rules & style (tone, do/don’t, persona notes).
• User – The main instructions/content for this segment.
• Duo Talk / Duo Talk Multilang – Dialogue for two speakers.
• Solo Talk / Solo Talk Multilang – Monologue for one speaker.

Runtime selection If the app needs Duo or Solo, it prefers the matching type; otherwise it falls back to User.

Writing your prompt (Custom)

Use <source.*> and other placeholders. The editor highlights placeholders and auto‑pairs conditionals.

Inline defaults

Now playing: <source.songTitle|Unknown title>

Conditionals

<#source.api.title>
API: <source.api.title> — <source.api.text>
</source.api.title>

Allowed in tag names: letters, digits, ., _, - Truthiness: empty/false/no/0/off/disabled → false; anything else → true.

3) Placeholder reference (Custom Program)

In Custom, each segment has one source. Only placeholders for that source type will resolve.

Program

• <program.name>, <program.generationTime>, <program.lang>

Weather (when available)

• <weather.temperature>, <weather.condition>, <weather.forecast>
• You can also type <weather.locationName> manually.

Feed source (Custom)

• <source.feed.title> — feed item title in context
• <source.feed.text> — description/body in context
• <source.feed.headline> — computed headline string

API source (Custom) — requires that you defined these on the API item

• Core: <source.api.title>, <source.api.text>
• Display: <source.api.image>, <source.api.link>
• Your custom keys: <source.api.author>, <source.api.category>, …

Page source (Custom) — app defines these

• Core: <source.page.title>, <source.page.text>
• Display: <source.page.ogimage>, <source.page.finalUrl>

Music

• <source.songTitle>, <source.albumTitle>, <source.artistName>

4) How Basic Program uses your content (no prompt editing)

Basic segments don’t expose a prompt editor. The engine composes using your attached content:

• API Content (you must define):

  • Keys per item: title, text (recommended), optional image, link
  • Internally available as: apiContent.title / .title.1…, apiContent.text / .text.1…, apiContent.image / .image.1…, apiContent.link / .link.1…, apiContent.concatenated
  • Convenience flag: apiContentEnabled (true when any text exists)

• Page Content (app defines):

  • Keys per item: pageTitle (fallback title), content, ogimage, finalUrl
  • Internally available as: pageContent.title(.1…), pageContent.text(.1…), pageContent.ogimage(.1…), pageContent.finalUrl(.1…), pageContent.concatenated
  • Convenience flag: pageContentEnabled (true when any content exists)

• Feed (aggregated in Basic):

  • Internally aggregated values: newsEnabled, news.feedNames, news.headline

• Weather (when available):

  • Internals such as weatherEnabled, weather.condition, weather.temperature, weather.forecast

Why still set API arguments in Basic? The Basic engine can’t create meaningful text without title/text. Define them per API item in the API Content Editor so the auto‑prompt has high‑quality inputs.

5) Ready‑to‑use templates (Custom Program)

These assume your segment’s source is API or Page or Feed (single source). Remove blocks for source types you aren’t using.

A. Duo Talk — Custom Program

You are co‑hosts <personality.djName> and <personality.assistantName>. Keep it lively but concise.

<#weather.temperature>
Quick weather: <weather.condition|->, <weather.temperature|-->° now.
</weather.temperature>

<#source.feed.title>
Top story: <source.feed.title>
<source.feed.text>
</source.feed.title>

<#source.api.title>
API: <source.api.title> — <source.api.text>
</source.api.title>

<#source.page.title>
Page: <source.page.title> — <source.page.text>
</source.page.title>

Close with a handoff to the next segment.

Ensure the result contains only dialogue. Prefix each line with the speaker’s name.

<personality.djName>: Hello everyone!
<personality.assistantName>: Hi everyone!

B. Solo Talk — Custom Program

Voice: <personality.djName>. Style: warm, clear, 2–3 short paragraphs.

<#source.feed.title>
Feed: <source.feed.title> — <source.feed.text>
</source.feed.title>

<#source.api.title>
API: <source.api.title> — <source.api.text>
</source.api.title>

<#source.page.title>
Page: <source.page.title> — <source.page.text>
</source.page.title>

<#weather.temperature>
Weather flash: <weather.condition|n/a>, <weather.temperature|-->°.
</weather.temperature>

Ensure the result is only dialogue text (prefix each line with the speaker’s name).

<personality.djName>: Hello everyone!

C. System (Custom Program)

You must follow these rules:
- Respect the host persona(s) below.
- Keep output under 120 words unless told otherwise.
- Avoid repeating placeholders literally.

Persona notes:
- DJ: <personality.djDescription|professional, friendly>.
- Assistant: <personality.assistantDescription|insightful, witty>.

6) Tips & good practices

• Choosing program type: Use Basic for speed and automatic aggregation (API/Page/Feed). Use Custom when you need precise control; each segment picks one source type.
• API Content (both types): In the API Content Editor, define title, text (required) and image, link (optional). These are user‑provided and power the UI and (in Custom) your prompt placeholders.
• Page Content (both types): The app supplies pageTitle, content, ogimage, finalUrl. You can reference them directly in Custom prompts.
• Feed in Custom: Select Feed as the segment’s source to use <source.feed.title>, <source.feed.text>, <source.feed.headline>.
• Conditions: In Custom, use real variables as conditions (e.g., <#source.api.title>…</source.api.title>). In Basic, the engine uses convenience flags internally.

7) Troubleshooting

• Where is the prompt for my Basic segment? Basic segments don’t expose a prompt editor. Switch to a Custom Program if you need to edit prompts.
• My Basic segment sounds empty. Ensure your attached API Content items have title and text. Without them, the auto‑prompt has little to say.
• <source.api.image> / <source.page.finalUrl> are empty in Custom. For API, confirm you set image/link in the API Content Editor. For Page, ogimage/finalUrl are app‑provided—verify the page exposes OG data.

8) One‑page cheat sheet

Custom Program (single source per segment)

Program: <program.name> | <program.lang> | <program.generationTime>

Weather: <weather.condition>, <weather.temperature>°, <weather.forecast>

Feed: <#source.feed.title><source.feed.title> — <source.feed.text></source.feed.title>
      Headline: <source.feed.headline>

API:  <#source.api.title><source.api.title> — <source.api.text></source.api.title>
      (Display) <source.api.image>, <source.api.link>
      (Custom)  <source.api.author>, <source.api.category>

Page: <#source.page.title><source.page.title> — <source.page.text></source.page.title>
      (Display) <source.page.ogimage>, <source.page.finalUrl>
      (Custom)  <source.page.author>, <source.page.section>

Music: <source.songTitle> by <source.artistName>

Conditionals: <#some.key>…</some.key>    Defaults: <key|fallback>

Basic Program (internal; no prompt editing)

Aggregates: API Content + Page Content + Feed

API internals:  apiContent.title(.1…), apiContent.text(.1…),
                apiContent.image(.1…), apiContent.link(.1…),
                apiContent.concatenated
Page internals: pageContent.title(.1…), pageContent.text(.1…),
                pageContent.ogimage(.1…), pageContent.finalUrl(.1…),
                pageContent.concatenated
Feed internals: newsEnabled, news.feedNames, news.headline
Convenience:    apiContentEnabled, pageContentEnabled, weatherEnabled

Requirement:    Set API keys (title, text, [image], [link]) in API Content Editor.

Release note (what changed)

• Basic Program: Aggregates API/Page/Feed and does not provide the prompt editor.
• Custom Program: Uses a single source per segment; Feed/API/Page/Music. No aggregation.
• System‑recognized keys: API keys are user‑defined; Page keys are app‑defined. All are usable in Custom prompts; the same keys drive Basic internally.

Create and Edit API Templates with Placeholders

A guide to prompts, credentials, date/location context, for your Generativ AI, API and Page Content and Catalog setting

This feature lets you design simple API templates that include placeholders. When you run a request, the app fills those placeholders with your runtime data, your saved credentials (API keys), today’s date, and—if you allow it—your current location.

What you can do

• Write once, reuse forever: Save an API request template with placeholders.
• Drop in your prompts: Fill <userPrompt>, <systemPrompt>, <positivePrompt>, and <negativePrompt> just before sending.
• Auto‑insert credentials: Use <credentials:Name> to inject the API key you’ve saved under “Name”.
• Use today’s date & your location: Place <yyyy>, <mm>, <dd>, <lat>, <lon> anywhere in the endpoint or JSON body.

Quick start

1. Create a template

   • Add placeholders where you want dynamic values:

     • Prompts: <userPrompt>, <systemPrompt>, <positivePrompt>, <negativePrompt>
     • Credentials: <credentials:MyServiceKey>
     • Date: <yyyy>, <mm>, <dd>
     • Location: <lat>, <lon>

   • Example endpoint and body:

     Endpoint:
     https://api.example.com/v1/search?on=<yyyy>-<mm>-<dd>&lat=<lat>&lon=<lon>
     
     Headers:
     Authorization: Bearer <credentials:ExampleKey>
     
     Body:
     {
       "system": "<systemPrompt>",
       "user": "<userPrompt>",
       "filters": { "near": "<lat>,<lon>" }
     }
     

2. Save your credential

   • In Settings → Credentials, save your API key with the exact Name used in your placeholder (e.g., ExampleKey).
   • You’ll reference it as <credentials:ExampleKey>.

3. Run the template

   • Enter your prompts (you can provide any subset—user, system, positive, negative).
   • If grant Location permission, <lat> and <lon> can be filled.
   • Send the request.

Placeholders you can use

Prompts (request body only)

• <userPrompt>
• <systemPrompt>
• <positivePrompt>
• <negativePrompt>

These are replaced everywhere they appear inside the JSON body strings.

Credentials (headers and body)

• <credentials:Name>

  • Name can contain letters and digits only (A–Z, a–z, 0–9).
  • Example: Authorization: Bearer <credentials:ExampleKey>
  • Make sure you’ve saved a credential with the exact name ExampleKey.

Credentials are replaced inside header values and anywhere in the body strings. (They are not used in the endpoint URL.)

Date (endpoint and body)

• <yyyy> – 4‑digit year (e.g., 2025)
• <mm> – 2‑digit month (e.g., 08)
• <dd> – 2‑digit day (e.g., 30)

Location (endpoint and body)

• <lat> – latitude from your device (if permission granted)
• <lon> – longitude from your device (if permission granted)

If location isn’t available or permission is denied, <lat>/<lon> are n/a.

Example: before → after

Before (your template):

Endpoint:
https://api.example.com/search?on=<yyyy>-<mm>-<dd>&lat=<lat>&lon=<lon>

Headers:
Authorization: Bearer <credentials:WeatherKey>

Body:
{
  "system": "<systemPrompt>",
  "user": "<userPrompt>",
  "radiusKm": 25.0,
  "location": { "lat": "<lat>", "lon": "<lon>" }
}

After (what the app sends on Aug 30, 2025 in Paris with saved key):

Endpoint:
https://api.example.com/search?on=2025-08-30&lat=48.8566&lon=2.3522

Headers:
Authorization: Bearer sk-live-••••••••

Body (pretty-printed):
{
  "system" : "You are a nice script writer.",
  "user" : "Find outdoor events today, and create talk between DJ and sidekick.",
  "radiusKm" : 25,
  "location" : {
    "lat" : "48.8566",
    "lon" : "2.3522"
  }
}

How replacement works (so you don’t get surprised)

• Recursive & thorough: Placeholders are searched and replaced everywhere inside strings in your JSON body and in the endpoint URL (for date and location).
• Case‑sensitive: <userPrompt> is not the same as <UserPrompt>.
• Exact tokens: Include the angle brackets exactly as shown, e.g., <yyyy>, not yyyy.
• Where each type works:
  • Prompts: body only
  • Credentials: headers and body
  • Date & Location: body and endpoint
• Location permission: If denied or unavailable, <lat>/<lon> remain unreplaced.
• Endpoint credentials: Credentials are not read or replaced in the endpoint; put them in headers or the body.

Best practices

• Name your credentials simply: Use letters/numbers only (e.g., ServiceAIKey, MyMaps2).
• Keep secrets in headers: Prefer Authorization: Bearer <credentials:Name> rather than placing secrets in URLs.
• Avoid partial tokens: Don’t wrap placeholders inside other characters (e.g., id-<yyyy> is fine, but the placeholder must appear exactly as shown).
• Validate your JSON: If your body isn’t valid JSON, replacements can’t run.
• Grant location only if needed: If your template doesn’t use <lat>/<lon>, you can deny the permission.

FAQ

Do I have to use all four prompt placeholders? No. Provide any subset. The app will only replace what you use.

Can I use placeholders inside arrays or deeply nested objects? Yes. Replacement is recursive: it works at any depth in your JSON.

Can I put credentials in the endpoint URL? Not supported. Credentials are replaced in headers and body only.

What date/time is used? The device’s current date (year, month, day) at the moment you run the template.

Example templates you can copy

1) Text generation

Endpoint:
https://api.example.ai/v1/chat

Headers:
Authorization: Bearer <credentials:GenAIKey>
Content-Type: application/json

Body:
{
  "system": "<systemPrompt>",
  "messages": [
    { "role": "user", "content": "<userPrompt>" }
  ]
}

2) Weather near me today

Endpoint:
https://api.weather.example/v2/forecast?date=<yyyy>-<mm>-<dd>&lat=<lat>&lon=<lon>

Headers:
Authorization: Bearer <credentials:WeatherKey>

Body:
{
  "units": "metric",
  "notes": "User asked: <userPrompt>"
}

3) Search with date filter

Endpoint:
https://api.search.example/v1/query?on=<yyyy>-<mm>-<dd>

Headers:
X-API-Key: <credentials:SearchKey>

Body:
{
  "q": "<userPrompt>",
  "boost": "<positivePrompt>"
}

Safety & privacy

• Credentials are read from your device’s Keychain just before a request is built and are never shown in logs.
• Location is optional and only read if you’ve granted permission. You can revoke it at any time in system settings.

That’s it! Save a template for your Generative AI, API/Page Content or Catalog. Keep your API keys in Credentials, and let the app do the rest.