Search

import OpenAI from "npm:openai";

unless strictly necessary, for example use APIs that don't require a key, prefer internal function

functions where possible. Unless specified, don't add error handling,

The val should create a "export default async function main" which is the main function that gets

function write(text) {

const callback = function (mutationsList, observer) {

const openai = new OpenAI();

const stream = await openai.chat.completions.create({

import { verfiedCalls } from "https://esm.town/v/stevekrouse/verfiedCalls";

import { verifyAPIAuth } from "https://esm.town/v/stevekrouse/verifyAPIAuth";

export async function exampleAuthApi(arg1, arg2, auth) {

let { handle } = await verifyAPIAuth(auth);

if (handle) {

This val hosts an [HTTP server](https://janpaul123-valtownsemanticsearch.web.val.run/) that lets you search all vals based on vibes. If you search for "discord bot" it shows all vals that have "discord bot" vibes.

It does this by comparing [embeddings from OpenAI](https://platform.openai.com/docs/guides/embeddings) generated for the code of all public vals, to an embedding of your search query.

This is an experiment to see if and how we want to incorporate semantic search in the actual Val Town search page.

const githubQuery = (query: string) => encodeURIComponent(`${query} repo:pomdtr/val-town-mirror path:vals/`);

async function handler(req: Request) {

const url = new URL(req.url);

"Content-Type": "application/opensearchdescription+xml",

function form(query, type) {

return (

import { runVal } from "https://esm.town/v/std/runVal";

export async function nodejs() {

const token =

(await runVal("easrng.nodejsInternals", {

import React, { useEffect, useRef, useState } from "https://esm.sh/react@18.2.0";

function ChatGPTClone() {

const [messages, setMessages] = useState([

</div>

function client() {

createRoot(document.getElementById("root")).render(<ChatGPTClone />);

if (typeof document !== "undefined") { client(); }

export default async function server(request: Request): Promise<Response> {

// Handle chat completion route

try {

const { OpenAI } = await import("https://esm.town/v/std/openai");

const openai = new OpenAI();

const { messages } = await request.json();

const completion = await openai.chat.completions.create({

messages: messages,

} catch (error) {

console.error("OpenAI Error:", error);

return new Response(

export async function val_5OBYpMAcsJ(req) {

try {

const body = await req.text();

// Create a function from the provided code and execute it

const userFunction = async () => {

const findPrimes = (n) => {

// Execute and capture the result

const result = await userFunction();

// Handle different types of results

CEREBRAS_API_KEY: "csk-ht6t8f48e4epnwxwh3c6pex6ekw2eyw2nm9knfm33f4pcetv"

async function generateCode(prompt: string, currentCode: string) {

const client = new Cerebras({ apiKey: CONFIG.CEREBRAS_API_KEY });

// Rest of the function remains the same

export default async function server(request: Request): Promise<Response> {

try {

import OpenAI from "npm:openai";

unless strictly necessary, for example use APIs that don't require a key, prefer internal function

functions where possible. Unless specified, don't add error handling,

The val should create a "export default async function main" which is the main function that gets

function write(text) {

const callback = function (mutationsList, observer) {

const openai = new OpenAI();

const stream = await openai.chat.completions.create({

export function myApi(name) {

return "hi " + name;

import { fetchJSON } from "https://esm.town/v/stevekrouse/fetchJSON?v=41";

export async function testPostCall() {

const result = await fetchJSON(

"https://api.val.town/express/@stevekrouse.postWebhook1",

"Rewrite this fact about cats as if it was written for 3 year old:\n\n" +

fact;

const story = await fetch("https://api.openai.com/v1/chat/completions", {

method: "POST",

body: JSON.stringify({

temperature: 0.7,

headers: {

"Authorization": `Bearer ${process.env.OPENAI}`,

"Content-Type": "application/json",

}).then(async (response) => {

import { fetch } from "https://esm.town/v/std/fetch";

export const valEval = async function (

expr: string | TemplateStringsArray

): Promise<[value: any, error: undefined | string]> {

{ name: "Netlify", icon: "🎛️", explanation: "An all-in-one platform for automating modern web projects", complexity: 1 },

{ name: "Vercel", icon: "🏁", explanation: "A cloud platform for static sites and Serverless Functions", complexity: 2 },

function client() {

const root = document.getElementById("root");

const { useState, useEffect, useRef } = React;

function App() {

const [step, setStep] = useState(0);

client();

async function server(request: Request): Promise<Response> {

const html = `

import OpenAI from "npm:openai";

unless strictly necessary, for example use APIs that don't require a key, prefer internal function

functions where possible. Unless specified, don't add error handling,

The val should create a "export default async function main" which is the main function that gets

function write(text) {

const callback = function (mutationsList, observer) {

const openai = new OpenAI();

const stream = await openai.chat.completions.create({

import { falProxyRequest } from "https://esm.town/v/stevekrouse/falProxyRequest";

function App() {

const [prompt, setPrompt] = useState("");

</div>

function client() {

createRoot(document.getElementById("root")).render(<App />);

if (typeof document !== "undefined") { client(); }

export default async function server(req: Request): Promise<Response> {

const url = new URL(req.url);