Skip to content

The Open Standard for Generative UI

4.6 KB
Raw Blame
import type { Library } from "@openuidev/react-lang";
import { FlaskConical } from "lucide-react";
import { useMemo, useState } from "react";
import type { LibraryLike } from "../../lib";
import {
  createMockToolProvider,
  type LangModule,
  type MockToolCall,
  type OpenUIError,
} from "../lib";
import { useDebugStyles } from "../styles";

const TOOL_CALL_LOG_CAP = 20;

function safeDescribe(event: unknown): string {
  try {
    return JSON.stringify(event);
  } catch {
    return String(event);
  }
}

function isOpenUIError(error: unknown): error is OpenUIError {
  return !!error && typeof error === "object";
}

function ErrorRow({ error }: { error: unknown }) {
  const s = useDebugStyles();
  if (isOpenUIError(error) && (error.message || error.code)) {
    return (
      <li style={s.errorRow}>
        <div style={s.errHead}>
          {error.code ? <code style={s.errComponent}>{error.code}</code> : null}
          {error.component ? <code style={s.errPath}>{error.component}</code> : null}
          {error.path ? <code style={s.errPath}>{error.path}</code> : null}
          {error.statementId ? <span style={s.tag}>{error.statementId}</span> : null}
        </div>
        {error.message ? <p style={s.errMessage}>{error.message}</p> : null}
        {error.hint ? <p style={s.errHint}>{error.hint}</p> : null}
      </li>
    );
  }
  return <li style={s.errorRow}>{safeDescribe(error)}</li>;
}

export function RenderPanel({
  Renderer,
  library,
  code,
  isStreaming,
}: {
  Renderer: LangModule["Renderer"];
  library: LibraryLike;
  code: string;
  isStreaming: boolean;
}) {
  const s = useDebugStyles();
  const [runtimeErrors, setRuntimeErrors] = useState<OpenUIError[]>([]);
  const [formState, setFormState] = useState<Record<string, unknown>>({});
  const [actionLog, setActionLog] = useState<string[]>([]);
  const [toolCalls, setToolCalls] = useState<MockToolCall[]>([]);
  const [lastCode, setLastCode] = useState(code);
  if (code !== lastCode && !isStreaming) {
    setLastCode(code);
    setToolCalls([]);
    setActionLog([]);
  }

  const toolProvider = useMemo(
    () =>
      createMockToolProvider((call) =>
        setToolCalls((log) => [...log.slice(-(TOOL_CALL_LOG_CAP - 1)), call]),
      ),
    [],
  );

  const usesTools = /\b(Query|Mutation)\s*\(/.test(code);
  // Whitespace-only input has nothing to render. Handing it to the Renderer anyway
  // reports a "parse-failed" error that then sticks around, since an empty editor
  // never produces another report to replace it. runValidation() guards the same way.
  const source = code.trim() ? code : null;

  return (
    <div style={s.renderPanel}>
      {usesTools ? (
        <p style={s.mockNote}>
          <FlaskConical size={13} aria-hidden />
          <span>
            <code>Query()</code> and <code>Mutation()</code> run against a mock tool provider. Calls
            are logged below the canvas.
          </span>
        </p>
      ) : null}
      <div style={s.renderCanvas}>
        <Renderer
          response={source}
          library={library as Library}
          isStreaming={isStreaming}
          publishObservability={false}
          toolProvider={toolProvider}
          onError={setRuntimeErrors}
          onStateUpdate={setFormState}
          onAction={(event) => setActionLog((log) => [...log.slice(-19), safeDescribe(event)])}
        />
      </div>
      {toolCalls.length > 0 ? (
        <details style={s.renderDetails} open>
          <summary>Mock tool calls ({toolCalls.length})</summary>
          <ul style={s.errorList}>
            {toolCalls.map((call, index) => (
              <li key={`${call.at}-${index}`} style={s.errorRow}>
                <code>{call.tool}</code>({safeDescribe(call.args)}) → sample data
              </li>
            ))}
          </ul>
        </details>
      ) : null}
      {source && runtimeErrors.length > 0 ? (
        <details style={s.renderDetails} open>
          <summary>Runtime errors ({runtimeErrors.length})</summary>
          <ul style={s.errorList}>
            {runtimeErrors.map((error, index) => (
              <ErrorRow key={index} error={error} />
            ))}
          </ul>
        </details>
      ) : null}
      {actionLog.length > 0 ? (
        <details style={s.renderDetails}>
          <summary>Actions ({actionLog.length})</summary>
          <pre style={s.treeJson}>{actionLog.join("\n")}</pre>
        </details>
      ) : null}
      {Object.keys(formState).length > 0 ? (
        <details style={s.renderDetails}>
          <summary>Form state</summary>
          <pre style={s.treeJson}>{JSON.stringify(formState, null, 2)}</pre>
        </details>
      ) : null}
    </div>
  );
}