Search

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

const openai = new OpenAI();

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

"messages": [

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

export async function openaiUploadFile({ key, data, purpose = "assistants" }: {

key: string;

formData.append("file", file, "data.json");

let result = await fetch("https://api.openai.com/v1/files", {

method: "POST",

if (result.error)

throw new Error("OpenAI Upload Error: " + result.error.message);

else

export const langchainEx = (async () => {

const { OpenAI } = await import("https://esm.sh/langchain/llms/openai");

const { PromptTemplate } = await import("https://esm.sh/langchain/prompts");

const { LLMChain } = await import("https://esm.sh/langchain/chains");

const model = new OpenAI({

temperature: 0.9,

openAIApiKey: process.env.openai,

maxTokens: 100,

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";

document.getElementById("input").addEventListener("submit", function(event) {

eventSource.onmessage = function(event) {

eventSource.onerror = function() {

const openai = new OpenAI();

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

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

await openai.beta.threads.messages.create(

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

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

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

if (req.method === "OPTIONS") {

status: 204,

const openai = new OpenAI();

try {

model: "gpt-4-turbo",

const stream = await openai.chat.completions.create(body);

if (!body.stream) {

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

const openai = new OpenAI();

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

messages: [

This val uses your OpenAI token if you have one, and the @std/openai if not, so it provides limited OpenAI usage for free.

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

import type { ChatCompletion, ChatCompletionCreateParamsNonStreaming, Message } from "npm:@types/openai";

async function getOpenAI() {

if (Deno.env.get("OPENAI_API_KEY") === undefined) {

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

return new OpenAI();

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

return new OpenAI();

* Initiates a chat conversation with OpenAI's GPT model and retrieves the content of the first response.

* This function can handle both single string inputs and arrays of message objects.

export async function chat(

options = {},

// Initialize OpenAI API stub

const { OpenAI } = await import(

"https://esm.sh/openai"

const openai = new OpenAI();

const messages = typeof prompt === "string"

: prompt;

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

messages: messages,

Use GPT to return JIT personalization for client side applications.

If you fork this, you'll need to set `OPENAI_API_KEY` in your [Val Town Secrets](https://www.val.town/settings/secrets).

import { Hono } from "npm:hono";

import { OpenAI } from "npm:openai";

const defaultUser = {

const personalizationGPT = async (user: UserObject) => {

const openai = new OpenAI();

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

messages: [

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

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

let game = new Chess(position)

function onDragStart(source, piece, position, orientation) {

// do not pick up pieces if the game is over

return false

function onDrop(source: string, target: string) {

// see if the move is legal

// for castling, en passant, pawn promotion

function onSnapEnd() {

board.position(game.fen())

function updateStatus() {

var status = ""

<div class='p-4'>

<h2 class='font-bold'>OpenAI Chess</h2>

<p class='pb-4'>Play chess against ChatGPT-4</p>

chess.move(san)

const openai = new OpenAI()

let messages = []

args: [c.req.param().id, `Requesting response to ${san}`],

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

messages: [

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";

const openai = new OpenAI();

document.getElementById("input").addEventListener("submit", async function(event) {

// Setup the SSE connection and stream back the response. OpenAI handles determining

eventSource.onmessage = function(event) {

eventSource.onerror = function() {

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

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

await openai.beta.threads.messages.create(

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

export async function openaiUploadFile({ key, data, purpose = "assistants" }: {

key: string;

formData.append("file", file, "data.json");

let result = await fetch("https://api.openai.com/v1/files", {

method: "POST",

if (result.error)

throw new Error("OpenAI Upload Error: " + result.error.message);

else

structure containing the properties "SystemMessage" and "UserMessage". These

message are then used to run an OpenAI chat completion and produce an "assistant

message" which is sent back to the client as plain text.

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

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

if (req.method !== "POST") {

return new Response("Bad Request: Invalid input", { status: 400 });

const openai = new OpenAI();

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

model: "gpt-4o-mini",

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

import { OpenAI } from "npm:openai";

let location = "brooklyn ny";

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

const openai = new OpenAI();

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

messages: [{

console.log(text);

export async function weatherGPT() {

await email({ subject: "Weather Today", text });

export const chatSampleFunctionSingle = (async () => {

// Example dummy function hard coded to return the same weather

// Step 1: send the conversation and available functions to GPT

const functions = [schemasWeather[0]];

functions,

function_call: "auto", // auto is default, but we'll be explicit

// Step 2: Check if GPT wanted to call a function

// Step 3: Call the function

if (!functions)

// Step 4: Send the info on the function call and function response to GPT