Search

import { streamText } from "npm:hono@4.4.12/streaming";
import type { Context } from "npm:hono@4.4.12";
import { OpenAI } from "https://esm.town/v/std/openai";
import { nanoid } from "npm:nanoid";
// --- CORE AI & HELPER LOGIC ---
const openai = new OpenAI();
const services = {
  async callAI(
      if (isJson) requestPayload.response_format = { type: "json_object" };
      const completion = await openai.chat.completions.create(requestPayload);
      const content = completion.choices?.[0]?.message?.content ?? "";
    onDelta: (delta: string) => Promise<void>,
  ) {
    const completionStream = await openai.chat.completions.create({
      model: "gpt-4o",
      messages: [{ role: "system", content: systemPrompt }, {

## Other todos
- [ ] Get OpenTownie or Gemini or Claude or OpenAI to synthesize the core of these patterns into a prompt we can use to make more ReactRouter apps, such as...
- [ ] Convert this or into the basic react router guest book (and preserve this forum app in another project?)
- [ ] To what extent can these patterns be packaged up into a Val Town Router project? Would be neat to get the version pinning thing all centralized, can this as-a-library be that centralized place?

// @ts-ignore
import { OpenAI } from "https://esm.town/v/std/openai?v=4";
// --- AI BEHAVIORAL GUIDELINES ---
async function handleApiDispatch(req: Request): Promise<Response> {
  try {
    const openai = new OpenAI();
    const body = await req.json();
    }`;
    const completion = await openai.chat.completions.create({
      model: "gpt-4o", // Using a powerful model for complex logic
      messages: [

// @ts-ignore
import { OpenAI } from "https://esm.town/v/std/openai?v=4";
// @ts-ignore
import { blob } from "https://esm.town/v/std/blob?v=11";
// --- CORE AI & ORCHESTRATION LOGIC ---
const openai = new OpenAI();
const INDEX_KEY = "mas_orchestrator_index";
const MAX_ATTEMPTS_PER_STEP = 5;
): Promise<any> {
  try {
    const completion = await openai.chat.completions.create({
      model: "gpt-4o", // Using a powerful model for orchestration
      messages: [

Note: When changing a SQLite table's schema, change the table's name (e.g., add _2 or _3) to create a fresh table.
### OpenAI
```ts
import { OpenAI } from "https://esm.town/v/std/openai";
const openai = new OpenAI();
const completion = await openai.chat.completions.create({
  messages: [
    { role: "user", content: "Say hello in a creative way" },

    // Récupérer la clé API depuis les env variables
    const OPENAI_API_KEY = Deno.env.get("OPENAI_API_KEY");
    if (!OPENAI_API_KEY) {
      return new Response(
        JSON.stringify({ error: "OPENAI_API_KEY not configured" }),
        {
          status: 500,
    }
    // Appeler l'API OpenAI Chat Completions avec vision
    const response = await fetch("https://api.openai.com/v1/chat/completions", {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "Authorization": `Bearer ${OPENAI_API_KEY}`,
      },
      body: JSON.stringify({

  if (req.method === "POST" && url.pathname === "/moderate") {
    try {
      const { OpenAI } = await import("https://esm.town/v/std/openai");
      const openai = new OpenAI();
      const body = await req.json();
      if (body.type === "text") {
        const response = await openai.chat.completions.create({
          model: "gpt-4o",
          messages: [
      } else if (body.type === "image") {
        const base64 = body.content.split(",")[1];
        const response = await openai.chat.completions.create({
          model: "gpt-4o",
          messages: [
  if (req.method === "POST" && url.pathname === "/moderateDoc") {
    try {
      const { OpenAI } = await import("https://esm.town/v/std/openai");
      const openai = new OpenAI();
      const formData = await req.formData();
      const file = formData.get("file") as File;
      const text = await file.text(); // Extracts text for txt/doc/pdf (works if Val Town supports it)
      const response = await openai.chat.completions.create({
        model: "gpt-4o",
        messages: [

const REALTIME_BASE_URL = "https://api.openai.com/v1/realtime";
const OPENAI_API_KEY = Deno.env.get("OPENAI_API_KEY");
if (!OPENAI_API_KEY) {
  throw new Error("🔴 OpenAI API key not configured");
}
export function makeHeaders(contentType?: string) {
  const obj: Record<string, string> = {
    Authorization: `Bearer ${OPENAI_API_KEY}`,
  };
  if (contentType) obj["Content-Type"] = contentType;

sip.post("/", async (c) => {
  // Verify the webhook.
  const OPENAI_SIGNING_SECRET = Deno.env.get("OPENAI_SIGNING_SECRET");
  if (!OPENAI_SIGNING_SECRET) {
    console.error("🔴 webhook secret not configured");
    return c.text("Internal error", 500);
  }
  const webhook = new Webhook(OPENAI_SIGNING_SECRET);
  const bodyStr = await c.req.text();
  let callId: string | undefined;

# hello-realtime
**Hello Realtime** is a OpenAI Realtime app that supports both WebRTC and SIP
(telephone) users. You can access the app via WebRTC at
[hello-realtime.val.run](https://hello-realtime.val.run), or via SIP by calling
server-side websocket interface.
If you remix the app, you'll just need to pop in your own `OPENAI_API_KEY` (from
[platform.openai.com](https://platform.openai.com)), and if you want SIP, the
`OPENAI_SIGNING_SECRET`.
## Architecture
   - Browser connects to frontend
   - creates WebRTC offer
   - `/rtc` endpoint handles SDP negotiation with OpenAI
   - observer established to monitor session
2. **SIP Flow**: