Search

export default function OutfitCard() {
  // @ts-ignore
  const sc = (globalThis as any).openai?.toolOutput?.structuredContent;
  const { top, bottom } = sc ?? {};
  if (!top || !bottom) return null;

export default function MultiItemCard() {
  // @ts-ignore
  const items = (globalThis as any).openai?.toolOutput?.structuredContent?.items ?? [];
  if (!items.length) return null;

export default function ItemCard() {
  // @ts-ignore: ChatGPT injects toolOutput
  const sc = (globalThis as any).openai?.toolOutput?.structuredContent;
  const item = sc?.item;
  if (!item) return null;

import type { WeatherOutput } from "../../../shared/types.ts";
import { useTheme, useToolOutput } from "../hooks.ts";
import { getOpenAI } from "../openai-types.ts";
export function WeatherWidget() {
  async function handleRefresh() {
    await getOpenAI()?.sendFollowUpMessage({
      prompt: `Refresh weather for ${location}`,
    });
  async function handleChangeLocation() {
    await getOpenAI()?.sendFollowUpMessage({
      prompt: "Change weather location",
    });

import type { TodoListOutput, Todo } from "../../../shared/types.ts";
import { useTheme, useToolOutput } from "../hooks.ts";
import { getOpenAI } from "../openai-types.ts";
export function TodoWidget() {
  async function handleAddTodo() {
    await getOpenAI()?.sendFollowUpMessage({
      prompt: "Add a new todo item",
    });
  async function handleToggleTodo(todo: Todo) {
    await getOpenAI()?.sendFollowUpMessage({
      prompt: `${todo.completed ? "Mark as incomplete" : "Mark as complete"}: ${todo.text}`,
    });
  async function handleDeleteTodo(todo: Todo) {
    await getOpenAI()?.sendFollowUpMessage({
      prompt: `Delete todo: ${todo.text}`,
    });

import type { CounterOutput } from "../../../shared/types.ts";
import { useTheme, useToolOutput } from "../hooks.ts";
import { getOpenAI } from "../openai-types.ts";
export function CounterWidget() {
  async function handleIncrement() {
    await getOpenAI()?.sendFollowUpMessage({
      prompt: `Increment counter by ${step}`,
    });
  async function handleDecrement() {
    await getOpenAI()?.sendFollowUpMessage({
      prompt: `Decrement counter by ${step}`,
    });
  async function handleReset() {
    await getOpenAI()?.sendFollowUpMessage({
      prompt: "Reset counter to 0",
    });

type UnknownObject = Record<string, unknown>;
export interface OpenAiGlobals<
  ToolInput extends UnknownObject = UnknownObject,
  ToolOutput extends UnknownObject = UnknownObject,
}
export interface OpenAIWidgetAPI<
  ToolInput extends UnknownObject = UnknownObject,
  ToolOutput extends UnknownObject = UnknownObject,
  ToolResponseMetadata extends UnknownObject = UnknownObject,
  WidgetState extends UnknownObject = UnknownObject,
> extends OpenAiGlobals<
    ToolInput,
    ToolOutput,
}
export const SET_GLOBALS_EVENT_TYPE = "openai:set_globals";
export interface SetGlobalsEvent
  extends CustomEvent<{ globals: Partial<OpenAiGlobals> }> {
  type: typeof SET_GLOBALS_EVENT_TYPE;
}
declare global {
  interface Window {
    openai: OpenAIWidgetAPI;
  }
}
export function getOpenAI(): OpenAIWidgetAPI | undefined {
  return window.openai;
}

import type { MessageListOutput } from "../../../shared/types.ts";
import { useTheme, useToolOutput } from "../hooks.ts";
import { getOpenAI } from "../openai-types.ts";
export function MessageListWidget() {
  async function handleAddMessage() {
    await getOpenAI()?.sendFollowUpMessage({
      prompt: "Add a new message",
    });

import type { MessageDetailOutput } from "../../../shared/types.ts";
import { useTheme, useToolOutput } from "../hooks.ts";
import { getOpenAI } from "../openai-types.ts";
export function MessageDetailWidget() {
  async function handleBackToList() {
    await getOpenAI()?.sendFollowUpMessage({
      prompt: "Show me all messages",
    });

/** @jsxImportSource https://esm.sh/react@19 */
import { useCallback, useEffect, useState, useSyncExternalStore } from "https://esm.sh/react@19";
import type { OpenAiGlobals, SetGlobalsEvent } from "./openai-types.ts";
import { getOpenAI, SET_GLOBALS_EVENT_TYPE } from "./openai-types.ts";
type UnknownObject = Record<string, unknown>;
export function useOpenAiGlobal<K extends keyof OpenAiGlobals>(
  key: K,
): OpenAiGlobals[K] {
  return useSyncExternalStore(
    (onChange) => {
      };
    },
    () => window.openai[key],
  );
}
export function useToolOutput<T = UnknownObject>(): T | null {
  return useOpenAiGlobal("toolOutput") as T | null;
}
export function useTheme(): "light" | "dark" {
  return useOpenAiGlobal("theme");
}
  defaultState: T | (() => T),
): readonly [T, (state: React.SetStateAction<T>) => void] {
  const widgetStateFromWindow = useOpenAiGlobal("widgetState") as T | null;
  const [widgetState, _setWidgetState] = useState<T>(() => {
            : stateOrUpdater;
        getOpenAI()?.setWidgetState(newState);
        return newState;
      });