@chat-js/cli 0.4.0 → 0.6.1

package/templates/chat-app/lib/ai/stream-errors.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it } from "vitest";
+import {
+  getStreamErrorMessage,
+  getStreamErrorToastContent,
+} from "./stream-errors";
+
+describe("getStreamErrorMessage", () => {
+  it("returns actionable gateway billing guidance", () => {
+    expect(
+      getStreamErrorMessage(
+        new Error("AI Gateway requires a valid credit card to run this model.")
+      )
+    ).toBe(
+      "AI Gateway requires a valid credit card. Add one in your Vercel dashboard and try again."
+    );
+  });
+
+  it("returns a context-window specific message", () => {
+    expect(
+      getStreamErrorMessage(
+        new Error("This model exceeded its maximum context length.")
+      )
+    ).toBe(
+      "This conversation is too long for the selected model. Start a new chat or shorten the message and try again."
+    );
+  });
+
+  it("falls back to a generic message for unknown errors", () => {
+    expect(getStreamErrorMessage(new Error("Provider exploded"))).toBe(
+      "An error occurred while generating a response. Please try again."
+    );
+  });
+});
+
+describe("getStreamErrorToastContent", () => {
+  it("uses the streamed cause as description when the message is truncated", () => {
+    const error = new Error("O", {
+      cause: "Oops, the provider returned a 429.",
+    });
+
+    expect(getStreamErrorToastContent(error)).toEqual({
+      message:
+        "An error occurred while generating a response. Please try again.",
+      description: "Oops, the provider returned a 429.",
+    });
+  });
+
+  it("extracts message from an Error object used as cause", () => {
+    const error = new Error("An error occurred, please try again!", {
+      cause: new Error("Rate limit exceeded. Try again in 30 seconds."),
+    });
+
+    expect(getStreamErrorToastContent(error)).toEqual({
+      message: "Rate limit exceeded. Please wait a moment and try again.",
+      description: "Rate limit exceeded. Try again in 30 seconds.",
+    });
+  });
+
+  it("keeps a specific message and moves the cause to the description", () => {
+    const error = new Error(
+      "Rate limit exceeded. Please wait a moment and try again.",
+      {
+        cause: "Provider returned HTTP 429",
+      }
+    );
+
+    expect(getStreamErrorToastContent(error)).toEqual({
+      message: "Rate limit exceeded. Please wait a moment and try again.",
+      description: "Provider returned HTTP 429",
+    });
+  });
+});

package/templates/chat-app/lib/ai/stream-errors.ts

@@ -0,0 +1,94 @@
+const FALLBACK_STREAM_ERROR_MESSAGE =
+  "An error occurred while generating a response. Please try again.";
+
+const genericErrorMessages = new Set([
+  "",
+  "An error occurred, please try again!",
+  "Something went wrong. Please try again later.",
+  FALLBACK_STREAM_ERROR_MESSAGE,
+]);
+
+function getErrorText(error: unknown): string | null {
+  if (typeof error === "string") {
+    const trimmed = error.trim();
+    return trimmed.length > 0 ? trimmed : null;
+  }
+
+  if (
+    typeof error === "object" &&
+    error !== null &&
+    "message" in error &&
+    typeof error.message === "string"
+  ) {
+    const trimmed = error.message.trim();
+    return trimmed.length > 0 ? trimmed : null;
+  }
+
+  return null;
+}
+
+function mapKnownStreamErrorMessage(message: string): string {
+  const normalized = message.toLowerCase();
+
+  if (
+    normalized.includes("ai gateway requires a valid credit card") ||
+    (normalized.includes("credit card") && normalized.includes("gateway"))
+  ) {
+    return "AI Gateway requires a valid credit card. Add one in your Vercel dashboard and try again.";
+  }
+
+  if (
+    normalized.includes("context window") ||
+    normalized.includes("maximum context length") ||
+    normalized.includes("prompt is too long") ||
+    normalized.includes("too many tokens")
+  ) {
+    return "This conversation is too long for the selected model. Start a new chat or shorten the message and try again.";
+  }
+
+  if (
+    normalized.includes("rate limit") ||
+    normalized.includes("too many requests")
+  ) {
+    return "Rate limit exceeded. Please wait a moment and try again.";
+  }
+
+  if (
+    normalized.includes("model not found") ||
+    normalized.includes("model is not available") ||
+    normalized.includes("no such model")
+  ) {
+    return "The selected model is not available right now. Choose another model and try again.";
+  }
+
+  return FALLBACK_STREAM_ERROR_MESSAGE;
+}
+
+export function getStreamErrorMessage(error: unknown): string {
+  return mapKnownStreamErrorMessage(
+    getErrorText(error) ?? FALLBACK_STREAM_ERROR_MESSAGE
+  );
+}
+
+export function getStreamErrorToastContent(error: Error): {
+  description?: string;
+  message: string;
+} {
+  const rawMessage =
+    typeof error.message === "string" ? error.message.trim() : "";
+  const rawCause =
+    error.cause == null ? undefined : (getErrorText(error.cause) ?? undefined);
+
+  const rawResolved =
+    (rawMessage.length <= 1 || genericErrorMessages.has(rawMessage)) && rawCause
+      ? rawCause
+      : rawMessage || rawCause || FALLBACK_STREAM_ERROR_MESSAGE;
+
+  const message = mapKnownStreamErrorMessage(rawResolved);
+
+  if (rawCause && rawCause !== message && !genericErrorMessages.has(rawCause)) {
+    return { message, description: rawCause };
+  }
+
+  return { message };
+}

package/templates/chat-app/lib/ai/tools/code-execution.javascript.ts

@@ -0,0 +1,171 @@
+import type {
+  CodeExecutionContext,
+  CodeExecutionResult,
+} from "./code-execution.types";
+
+const EXECUTION_STATUS_PREFIX = "__EXECUTION_STATUS__:";
+
+function createWrappedCode(code: string): string {
+  // Inject user code as a string literal so backticks / ${} in user code
+  // cannot break out of the wrapper template.
+  const userCodeLiteral = JSON.stringify(code);
+  return `
+import { inspect } from "node:util";
+
+const __formatOutput = (value) => {
+  if (typeof value === "string") {
+    return value;
+  }
+
+  return inspect(value, {
+    depth: 4,
+    colors: false,
+    maxArrayLength: 100,
+    breakLength: 120,
+  });
+};
+
+const __run = async () => {
+  try {
+    const __userCode = ${userCodeLiteral};
+    const __execution = await (0, eval)(
+      "(async () => {\\n" +
+      __userCode + "\\n" +
+      "return { __kind: \\"locals\\"," +
+      " result: typeof result !== \\"undefined\\" ? result : undefined," +
+      " results: typeof results !== \\"undefined\\" ? results : undefined };\\n" +
+      "})()"
+    );
+
+    const __result =
+      __execution &&
+      typeof __execution === "object" &&
+      __execution.__kind === "locals"
+        ? typeof __execution.result !== "undefined"
+          ? __execution.result
+          : typeof __execution.results !== "undefined"
+            ? __execution.results
+            : undefined
+        : __execution;
+
+    if (typeof __result !== "undefined") {
+      console.log(__formatOutput(__result));
+    }
+
+    console.log("${EXECUTION_STATUS_PREFIX}" + JSON.stringify({ success: true }));
+  } catch (error) {
+    const execError = error instanceof Error ? error : new Error(String(error));
+    console.log(
+      "${EXECUTION_STATUS_PREFIX}" +
+        JSON.stringify({
+          success: false,
+          error: {
+            name: execError.name,
+            value: execError.message,
+            traceback: execError.stack ?? execError.message,
+          },
+        })
+    );
+    process.exitCode = 1;
+  }
+};
+
+await __run();
+`;
+}
+
+type JsExecInfo = {
+  success: boolean;
+  error?: { name: string; value: string; traceback: string };
+};
+
+function execInfoFromExitCode(exitCode: number): JsExecInfo {
+  if (exitCode === 0) {
+    return { success: true };
+  }
+  return {
+    success: false,
+    error: {
+      name: "SandboxExecutionError",
+      value: "Execution completed without a valid status trailer",
+      traceback: "",
+    },
+  };
+}
+
+async function parseExecutionOutput(execResult: {
+  stdout: () => Promise<string>;
+  exitCode: number;
+}): Promise<{
+  outputText: string;
+  execInfo: JsExecInfo;
+}> {
+  const stdout = await execResult.stdout();
+  const lines = (stdout ?? "").split("\n");
+  // Search from the end so a user console.log of the prefix cannot be
+  // mistaken for the real status trailer emitted last by the wrapper.
+  const statusLineIndex = lines.findLastIndex((line) =>
+    line.startsWith(EXECUTION_STATUS_PREFIX)
+  );
+
+  if (statusLineIndex === -1) {
+    return {
+      outputText: stdout ?? "",
+      execInfo: execInfoFromExitCode(execResult.exitCode),
+    };
+  }
+
+  const execInfoRaw = lines[statusLineIndex].slice(
+    EXECUTION_STATUS_PREFIX.length
+  );
+  let execInfo: JsExecInfo;
+  try {
+    execInfo = JSON.parse(execInfoRaw) as JsExecInfo;
+  } catch {
+    return {
+      outputText: stdout ?? "",
+      execInfo: execInfoFromExitCode(execResult.exitCode),
+    };
+  }
+  lines.splice(statusLineIndex, 1);
+
+  return {
+    outputText: lines.join("\n").trim(),
+    execInfo,
+  };
+}
+
+export async function executeJavaScriptInSandbox({
+  sandbox,
+  code,
+  log,
+  requestId,
+}: CodeExecutionContext): Promise<CodeExecutionResult> {
+  const execResult = await sandbox.runCommand({
+    cmd: "node",
+    args: ["--input-type=module", "-e", createWrappedCode(code)],
+  });
+
+  const { outputText, execInfo } = await parseExecutionOutput(execResult);
+  const stderrTrimmed = (await execResult.stderr())?.trim();
+  let message = "";
+
+  if (outputText) {
+    message += `${outputText}\n`;
+  }
+  if (stderrTrimmed) {
+    message += `${stderrTrimmed}\n`;
+  }
+  if (execInfo.error) {
+    message += `Error: ${execInfo.error.name}: ${execInfo.error.value}\n`;
+    log.error(
+      { requestId, error: execInfo.error },
+      "javascript execution error"
+    );
+  }
+
+  return {
+    message: message.trim(),
+    chart: "",
+  };
+}

package/templates/chat-app/lib/ai/tools/code-execution.python.ts

@@ -0,0 +1,336 @@
+import type { Sandbox } from "@vercel/sandbox";
+import type {
+  CodeExecutionContext,
+  CodeExecutionResult,
+} from "./code-execution.types";
+
+const WHITESPACE_REGEX = /\s+/;
+const PACKAGE_SPEC_SPLIT_RE = /[=<>![\s]/;
+const CHART_JSON_PREFIX = "__CHART_JSON__:";
+
+function packageName(spec: string): string {
+  return spec.split(PACKAGE_SPEC_SPLIT_RE)[0].toLowerCase();
+}
+
+async function installBasePackages(
+  sandbox: Sandbox,
+  basePackages: readonly string[],
+  requestId: string,
+  log: CodeExecutionContext["log"]
+): Promise<{
+  success: boolean;
+  result?: CodeExecutionResult;
+}> {
+  const installStep = await sandbox.runCommand({
+    cmd: "pip",
+    args: ["install", ...basePackages],
+  });
+  if (installStep.exitCode !== 0) {
+    const installStderr = await installStep.stderr();
+    log.error(
+      { requestId, stderr: installStderr },
+      "base package installation failed"
+    );
+    return {
+      success: false,
+      result: {
+        message: `Failed to install base packages: ${installStderr}`,
+        chart: "",
+      },
+    };
+  }
+  log.info({ requestId }, "base packages installed");
+  return { success: true };
+}
+
+async function processExtraPackages(
+  code: string,
+  basePackages: readonly string[],
+  sandbox: Sandbox,
+  requestId: string,
+  log: CodeExecutionContext["log"]
+): Promise<{
+  codeToRun: string;
+  installResult: {
+    success: boolean;
+    result?: CodeExecutionResult;
+  };
+}> {
+  const basePackageNames = new Set(basePackages.map((p) => p.toLowerCase()));
+  const lines = code.split("\n");
+  const pipLines = lines.filter((line) =>
+    line.trim().startsWith("!pip install ")
+  );
+  const extraPackages = pipLines
+    .flatMap((line) =>
+      line
+        .trim()
+        .slice("!pip install ".length)
+        .split(WHITESPACE_REGEX)
+        .filter(Boolean)
+    )
+    .filter((spec) => !basePackageNames.has(packageName(spec)));
+
+  const codeWithoutPipLines = lines
+    .filter((line) => !line.trim().startsWith("!pip install "))
+    .join("\n");
+
+  if (extraPackages.length === 0) {
+    return { codeToRun: codeWithoutPipLines, installResult: { success: true } };
+  }
+
+  log.info({ requestId, extraPackages }, "installing extra packages");
+  const dynamicInstall = await sandbox.runCommand({
+    cmd: "pip",
+    args: ["install", ...extraPackages],
+  });
+  if (dynamicInstall.exitCode !== 0) {
+    const stderr = await dynamicInstall.stderr();
+    log.error({ requestId, stderr }, "dynamic package installation failed");
+    return {
+      codeToRun: code,
+      installResult: {
+        success: false,
+        result: {
+          message: `Failed to install packages: ${stderr}`,
+          chart: "",
+        },
+      },
+    };
+  }
+
+  return {
+    codeToRun: codeWithoutPipLines,
+    installResult: { success: true },
+  };
+}
+
+function createWrappedCode(codeToRun: string, chartPath: string): string {
+  return `
+import sys
+import json
+import traceback
+
+try:
+    import matplotlib.pyplot as _plt_module
+    _orig_savefig = _plt_module.savefig
+    def _intercepted_savefig(*args, **kwargs):
+        _orig_savefig('${chartPath}', format='png', bbox_inches='tight', dpi=100)
+        _user_target = args[0] if args else kwargs.get('fname')
+        if _user_target not in (None, '${chartPath}'):
+            return _orig_savefig(*args, **kwargs)
+    _plt_module.savefig = _intercepted_savefig
+except ImportError:
+    pass
+
+try:
+    exec(${JSON.stringify(codeToRun)})
+    try:
+        _locals = locals()
+        _globals = globals()
+        _chart_var = _locals.get("chart") or _globals.get("chart")
+        if (isinstance(_chart_var, dict)
+                and isinstance(_chart_var.get("type"), str)
+                and isinstance(_chart_var.get("elements"), list)):
+            print("__CHART_JSON__:" + json.dumps(_chart_var))
+        else:
+            if "result" in _locals:
+                print(_locals["result"])
+            elif "result" in _globals:
+                print(_globals["result"])
+            elif "results" in _locals:
+                print(_locals["results"])
+            elif "results" in _globals:
+                print(_globals["results"])
+    except Exception:
+        pass
+    try:
+        import matplotlib.pyplot as plt
+        if plt.get_fignums():
+            plt.savefig('${chartPath}', format='png', bbox_inches='tight', dpi=100)
+            plt.close('all')
+    except ImportError:
+        pass
+    print(json.dumps({"success": True}))
+except Exception as e:
+    error_info = {"success": False, "error": {"name": type(e).__name__, "value": str(e), "traceback": traceback.format_exc()}}
+    print(json.dumps(error_info))
+    sys.exit(1)
+`;
+}
+
+async function parseExecutionOutput(execResult: {
+  stdout: () => Promise<string>;
+  exitCode: number;
+}): Promise<{
+  outputText: string;
+  chartData: Record<string, unknown> | null;
+  execInfo: {
+    success: boolean;
+    error?: { name: string; value: string; traceback: string };
+  };
+}> {
+  const stdout = await execResult.stdout();
+  let execInfo: {
+    success: boolean;
+    error?: { name: string; value: string; traceback: string };
+  } = { success: true };
+  let outputText = "";
+  let chartData: Record<string, unknown> | null = null;
+
+  try {
+    const outLines = (stdout ?? "").trim().split("\n");
+    const lastLine = outLines.at(-1);
+    execInfo = JSON.parse(lastLine ?? "{}");
+    outLines.pop();
+
+    const chartLineIdx = outLines.findIndex((line) =>
+      line.startsWith(CHART_JSON_PREFIX)
+    );
+    if (chartLineIdx !== -1) {
+      const raw = outLines[chartLineIdx].slice(CHART_JSON_PREFIX.length);
+      try {
+        chartData = JSON.parse(raw) as Record<string, unknown>;
+      } catch {
+        // Ignore malformed chart JSON from the sandboxed snippet.
+      }
+      outLines.splice(chartLineIdx, 1);
+    }
+
+    outputText = outLines.join("\n");
+  } catch {
+    outputText = stdout ?? "";
+    if (execResult.exitCode !== 0) {
+      execInfo = {
+        success: false,
+        error: {
+          name: "SandboxExecutionError",
+          value: "Execution completed without a parsable status trailer",
+          traceback: "",
+        },
+      };
+    }
+  }
+
+  return { outputText, chartData, execInfo };
+}
+
+async function checkForChart(
+  sandbox: Sandbox,
+  chartPath: string,
+  requestId: string,
+  log: CodeExecutionContext["log"]
+): Promise<{ base64: string; format: string } | undefined> {
+  const chartCheck = await sandbox.runCommand({
+    cmd: "test",
+    args: ["-f", chartPath],
+  });
+  if (chartCheck.exitCode === 0) {
+    const b64 = await (
+      await sandbox.runCommand({
+        cmd: "base64",
+        args: ["-w", "0", chartPath],
+      })
+    ).stdout();
+    log.info({ requestId }, "chart generated");
+    return { base64: (b64 ?? "").trim(), format: "png" };
+  }
+  return;
+}
+
+function buildResponseMessage({
+  outputText,
+  stderr,
+  execInfo,
+  log,
+  requestId,
+}: {
+  outputText: string;
+  stderr: string;
+  execInfo: {
+    success: boolean;
+    error?: { name: string; value: string; traceback: string };
+  };
+  log: CodeExecutionContext["log"];
+  requestId: string;
+}): string {
+  let message = "";
+
+  if (outputText) {
+    message += `${outputText}\n`;
+  }
+  if (stderr && stderr.trim().length > 0) {
+    message += `${stderr}\n`;
+  }
+  if (execInfo.error) {
+    message += `Error: ${execInfo.error.name}: ${execInfo.error.value}\n`;
+    log.error({ requestId, error: execInfo.error }, "python execution error");
+  }
+
+  return message;
+}
+
+export async function executePythonInSandbox({
+  sandbox,
+  code,
+  log,
+  requestId,
+}: CodeExecutionContext): Promise<CodeExecutionResult> {
+  const basePackages = [
+    "matplotlib",
+    "pandas",
+    "numpy",
+    "sympy",
+    "yfinance",
+  ] as const;
+  const chartPath = "/tmp/chart.png";
+
+  const baseInstallResult = await installBasePackages(
+    sandbox,
+    basePackages,
+    requestId,
+    log
+  );
+  if (!baseInstallResult.success) {
+    return baseInstallResult.result ?? { message: "Unknown error", chart: "" };
+  }
+
+  const { codeToRun, installResult } = await processExtraPackages(
+    code,
+    basePackages,
+    sandbox,
+    requestId,
+    log
+  );
+  if (!installResult.success) {
+    return installResult.result ?? { message: "Unknown error", chart: "" };
+  }
+
+  const wrappedCode = createWrappedCode(codeToRun, chartPath);
+  const execResult = await sandbox.runCommand({
+    cmd: "python3",
+    args: ["-c", wrappedCode],
+  });
+
+  const { outputText, chartData, execInfo } =
+    await parseExecutionOutput(execResult);
+
+  const message = buildResponseMessage({
+    outputText,
+    stderr: await execResult.stderr(),
+    execInfo,
+    log,
+    requestId,
+  });
+
+  if (chartData) {
+    log.info({ requestId }, "interactive chart data returned");
+    return { message: message.trim(), chart: chartData };
+  }
+
+  const chartOut = await checkForChart(sandbox, chartPath, requestId, log);
+  return {
+    message: message.trim(),
+    chart: chartOut ?? "",
+  };
+}