Search

import { OpenAI } from "npm:openai";

const openai = new OpenAI();

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

"functions": [

console.log(functionExpression);

let args = functionExpression.choices[0].message.function_call.arguments;

let functionCallResult = { "temperature": "22", "unit": "celsius", "description": "Sunny" };

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

"function_call": { "name": "get_current_weather", "arguments": "{ \"location\": \"Boston, MA\"}" },

async function calculateEmbeddings(text) {

import { createOpenAI } from "npm:@ai-sdk/openai";

const openai = createOpenAI({

// apiKey = Deno.env.get("OPENAI_API_KEY");

apiKey: Deno.env.get("OPENAI_API_KEY_COVERSHEET")

const groq = createOpenAI({

baseURL: 'https://api.groq.com/openai/v1',

const perplexity = createOpenAI({

this.defaultProvider = options.provider || 'openai';

case 'openai':

result = await this.generateOpenAIResponse({ model, prompt, maxTokens, temperature, streaming, schema, system, messages, tools, ...additionalSettings });

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

const openai = new OpenAI();

async function runConversation() {

const inputWord = "almond latte";

`.replaceAll(/\s+/g, "");

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

messages: [

// for (let i = 0; i < message.tool_calls.length; i++) {

// console.log("[CALLING]", message.tool_calls[i].function);

// const tool = toolbox[message.tool_calls[i].function.name];

// if (tool) {

// const result = await tool.call(JSON.parse(message.tool_calls[i].function.arguments));

// console.log("[RESULT]", truncate(result));

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

const openai = new OpenAI();

openAiTool: {

type: "function",

function: {

openAiTool: {

type: "function",

function: {

openAiTool: {

type: "function",

export let openaiOpenAPI = `

openapi: 3.0.0

description: |

The Val Town API provides services to evaluate JavaScript and TypeScript expressions, run vals as APIs, either as functions or Express handlers.

Learn more at [https://docs.val.town](https://docs.val.town)

The JavaScript or TypeScript expression to be evaluated.

This should be a single expression, like a single function

call, assignment operation, or calculation. If you need

to execute multiple expressions, wrap them in a function.

schema:

summary: Simple addition

functionCall:

value: "@stevekrouse.addOne(@stevekrouse.example1)"

summary: Calling a user's val function

handle:

description: |

This val is a function that returns its arguments. It is useful for testing how the API handles the arguments passed to it.

View the val at [https://val.town/v/stevekrouse.id](https://val.town/v/stevekrouse.id)

summary: Simple addition result

functionCall:

value: 42

summary: Calling a function result

security:

You can chat with llms over email, the email thread functions as memory. The biggest thing is that you can instantly create a chat

like interface with llms. Pair that with back end data and functions and you got something really powerful.

* Llms can uses [tools](https://platform.openai.com/docs/guides/function-calling), meaning you can make this an agent and a whole lot more useful.

import { zodResponseFormat } from "https://esm.sh/openai/helpers/zod";

import { z } from "https://esm.sh/zod";

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

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

export default async function(e: Email) {

const client = new OpenAI();

const Messages = z.object({

Use Cerebras for AI on the backend like so:

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

const client = new OpenAI({

apiKey: Deno.env.get("CEREBRAS_API_KEY"),

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

function App() {

const [messages, setMessages] = useState([]);

</div>

function client() {

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

client();

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

if (request.method === "POST" && new URL(request.url).pathname === "/chat") {

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

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

// Cerebras Inference

// Keep these comments so we remember not to change this

const client = new OpenAI({

apiKey: Deno.env.get("CEREBRAS_API_KEY"),

} catch (error) {

console.error("Error calling Cerebras API:", error);

if (error.status === 429) {

Using OpenAI chat completion (GPT3) with function calls to [SMHI](https://en.wikipedia.org/wiki/Swedish_Meteorological_and_Hydrological_Institute) api

The API is instructed to use the current time in Europe/Stockholm timezone.

* [SMHI, forecast documentation](https://opendata.smhi.se/apidocs/metfcst/get-forecast.html)

* [OPEN AI, GPT function calling documentation](https://platform.openai.com/docs/guides/gpt/function-calling)

* zod: for describing the SMHI API response and function API input

* zod-to-json-schema: Transform the zod schema to json schema (readable by the GPT API)

import { callWeatherGPT } from "https://esm.town/v/ljus/callWeatherGPT";

export async function weatherGPT(message: string) {

return callWeatherGPT(message);

* We use the WebRTC API for camera access, the OpenAI API for image analysis,

function App() {

function client() {

console.log("Document is defined, calling client()");

console.log("Document is undefined, not calling client()");

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

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

const openai = new OpenAI();

console.log("Sending request to OpenAI");

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

Use Cerebras for AI on the backend like so:

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

const client = new OpenAI({

apiKey: "YOUR_CEREBRAS_API_KEY",

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

function App() {

const [messages, setMessages] = useState([]);

</div>

function client() {

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

client();

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

if (request.method === "POST" && new URL(request.url).pathname === "/chat") {

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

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

const client = new OpenAI({

apiKey: Deno.env.get("CEREBRAS_API_KEY"),

} catch (error) {

console.error("Error calling Cerebras API:", error);

if (error.status === 429) {

Use Cerebras for AI on the backend like so:

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

const client = new OpenAI({

apiKey: "YOUR_CEREBRAS_API_KEY",

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

function App() {

const [messages, setMessages] = useState([]);

</div>

function client() {

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

client();

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

if (request.method === "POST" && new URL(request.url).pathname === "/chat") {

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

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

// Cerebras Inference

// Keep these comments so we remember not to change this

const client = new OpenAI({

apiKey: Deno.env.get("CEREBRAS_API_KEY"),

} catch (error) {

console.error("Error calling Cerebras API:", error);

if (error.status === 429) {

Use Cerebras for AI on the backend like so:

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

const client = new OpenAI({

apiKey: "YOUR_CEREBRAS_API_KEY",

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

function App() {

const [messages, setMessages] = useState([]);

</div>

function client() {

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

client();

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

if (request.method === "POST" && new URL(request.url).pathname === "/chat") {

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

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

const client = new OpenAI({

apiKey: Deno.env.get("CEREBRAS_API_KEY"),

} catch (error) {

console.error("Error calling Cerebras API:", error);

if (error.status === 429) {

Use Cerebras for AI on the backend like so:

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

const client = new OpenAI({

apiKey: "YOUR_CEREBRAS_API_KEY",

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

function App() {

const [messages, setMessages] = useState([]);

</div>

function client() {

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

client();

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

if (request.method === "POST" && new URL(request.url).pathname === "/chat") {

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

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

const openai = new OpenAI();

try {

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

model: "gpt-4o-mini",

} catch (error) {

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

if (error.status === 429) {

Use OpenAI's chat completion API with [`std/openai`](https://www.val.town/v/std/openai). This integration enables access to OpenAI's language models without needing to acquire API keys.

For free Val Town users, [all calls are sent to `gpt-4o-mini`](https://www.val.town/v/std/openaiproxy?v=12#L85).

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

* API Client for interfacing with the OpenAI API. Uses Val Town credentials.

export class OpenAI {

private rawOpenAIClient: RawOpenAI;

* API Client for interfacing with the OpenAI API. Uses Val Town credentials.

* @param {Core.Fetch} [opts.fetch] - Specify a custom `fetch` function implementation.

this.rawOpenAIClient = new RawOpenAI({

baseURL: "https://std-openaiproxy.web.val.run/v1",

return this.rawOpenAIClient.chat;

chat: this.rawOpenAIClient.beta.chat,

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(