Search

if (!YOUTUBE_API_KEY) {

console.warn("YouTube API key (YOUTUBE_API_KEY2) is not set. Falling back to search URL method.");

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

const regenerateKey = request.headers.get("Regenerate-Key") || "0";

const openai = new OpenAI();

const { sport, skillLevel, ageGroup, groupSize, selectedTopics, sessionDuration } = await request.json();

// ... (previous code remains unchanged)

Supports: checkbox, date, multi_select, number, rich_text, select, status, title, url, email

- Uses `NOTION_API_KEY`, `OPENAI_API_KEY` stored in env variables and uses [Valtown blob storage](https://esm.town/v/std/blob) to store information about the database.

- Use `get_notion_db_info` to use the stored blob if exists or create one, use `get_and_save_notion_db_info` to create a new blob (and replace an existing one if exists).

import { Client } from "npm:@notionhq/client";

import OpenAI from "npm:openai";

import { z } from "npm:zod";

"email": "string_email",

const oai = new OpenAI({

apiKey: process.env.OPENAI_API_KEY ?? undefined,

const client = Instructor({

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

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

const KEY = new URL(import.meta.url).pathname.split("/").at(-1);

const SCHEMA_VERSION = 1;

const openai = new OpenAI();

async function generateEmbedding(text: string): Promise<number[]> {

const response = await openai.embeddings.create({

model: "text-embedding-ada-002",

import { api } from "https://esm.town/v/pomdtr/api";

import { email } from "https://esm.town/v/std/email?v=12";

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

async function getValByAlias({ author, name }: { author: string; name: string }) {

const { id, code, readme } = await api(`/v1/alias/${author}/${name}`, {

type: "string";

export function askAI(content: string) {

const client = new OpenAI();

const runner = client.beta.chat.completions.runTools({

model: "gpt-3.5-turbo",

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

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

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

import { Hono } from "npm:hono@3";

function esmTown(url) {

export const rateArticleRelevance = async (interests: string, article: any) => {

const { default: OpenAI } = await import("npm:openai");

const openai = new OpenAI({ apiKey: process.env.OPENAI_KEY });

try {

Give a score from 0 to 10. Why did you give this score? Respond with the score only.

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

messages: [

* Make a folder for the temporary vals that get generated, take the ID from the URL, and put it in `tempValsParentFolderId`.

* If you want to use OpenAI models you need to set the `OPENAI_API_KEY` [env var](https://www.val.town/settings/environment-variables).

* If you want to use Anthropic models you need to set the `ANTHROPIC_API_KEY` [env var](https://www.val.town/settings/environment-variables).

This val provides a class `ReadmeWriter` for generating readmes for vals with OpenAI. It can both draft readmes and update them directly

- `apiKey` (optional): An OpenAI API key. Defaults to `Deno.env.get("OPENAI_API_KEY")`.

- [ ] Additional options to pass to the OpenAI model

import OpenAI, { type ClientOptions } from "npm:openai";

openai: OpenAI;

const { model, ...openaiOptions } = options;

this.openai = new OpenAI(openaiOptions);

private async performOpenAICall(prompt: string) {

const response = await this.openai.chat.completions.create({

throw new Error("No response from OpenAI");

throw new Error("No readme returned by OpenAI. Try again.");

const readme = await this.performOpenAICall(prompt);

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

// Update your token in https://val.town/settings/secrets

Authorization: `Bearer ${token || process.env.openaiKey}`,

const getCompelitoins = async (data) => {

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

method: "POST",

headers: {

"Emphasize a morbid sense of humor.",

].join("\n"),

openAiKey: process.env.openai_key,

import { OpenAI } from "https://esm.town/v/std/openai?v=2";

import { sqlite } from "https://esm.town/v/std/sqlite?v=5";

import { Hono } from "npm:hono@3";

Demonstrated how to use assistants and threads with the OpenAI SDK and how to stream the response with Server-Sent Events

import OpenAI from "npm:openai";

import { renderToString } from "npm:react-dom/server";

const openai = new OpenAI();

import { Hono } from "npm:hono@3";

app.get("/", async (c) => {

const thread = await openai.beta.threads.create();

const assistant = await openai.beta.assistants.create({

name: "",

const message = c.req.query("message");

await openai.beta.threads.messages.create(

threadId,

"data: " + JSON.stringify(str) + "\n\n",

const run = openai.beta.threads.runs.stream(threadId, {

assistant_id: assistantId,

import { email } from "https://esm.town/v/std/email?v=11";

import { OpenAI } from "npm:openai";

let location = "Asia, Taipei";

).then(r => r.json());

const openai = new OpenAI();

let chatCompletion = await openai.chat.completions.create({

messages: [{

import { email } from "https://esm.town/v/std/email?v=12";

import { OpenAI } from "https://esm.town/v/std/openai?v=4";

import { z } from "npm:zod";

.describe("Top 5 stories on Hacker News"),

// we create a OpenAI Tool that takes our schema as argument

const extractContentTool: any = {

parameters: zodToJsonSchema(schema),

const openai = new OpenAI();

// We ask OpenAI to extract the content from the given web page.

// The model will reach out to our `extract_content` tool and

// the requirement of `extract_content`s argument.

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

model: "gpt-4-turbo",

tool_choice: "auto",

// we retrieve the serialized arguments generated by OpenAI

const result = completion.choices[0].message.tool_calls![0].function.arguments;

const parsed = schema.parse(JSON.parse(result));

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

model: "gpt-4-turbo",

import process from "node:process";

import OpenAI from "npm:openai";

const openai = new OpenAI({ apiKey: process.env.openai });

export async function emojiSearchBot({ lastRunAt }: Interval) {

if (attachment.type !== "photo") return;

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

model: "gpt-4-vision-preview",