iris-chatbot 0.2.4

package/template/src/app/api/connections/models/route.ts

@@ -0,0 +1,255 @@
+import OpenAI from "openai";
+import type { ChatConnectionPayload } from "../../../../lib/types";
+import { GEMINI_OPENAI_BASE_URL } from "../../../../lib/connections";
+import { getBuiltinModelPresets } from "../../../../lib/model-presets";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+type ModelsRequest = {
+  connection?: ChatConnectionPayload;
+};
+
+type AnthropicModelItem = {
+  id?: string;
+  type?: string;
+};
+
+type AnthropicModelsResponse = {
+  data?: AnthropicModelItem[];
+  has_more?: boolean;
+  last_id?: string;
+};
+
+type GoogleModelItem = {
+  name?: string;
+  supportedGenerationMethods?: string[];
+};
+
+type GoogleModelsResponse = {
+  models?: GoogleModelItem[];
+  nextPageToken?: string;
+};
+
+function normalizeConnection(connection?: ChatConnectionPayload) {
+  if (!connection) {
+    return null;
+  }
+  const kind =
+    connection.kind === "builtin" || connection.kind === "openai_compatible" || connection.kind === "ollama"
+      ? connection.kind
+      : null;
+  if (!kind) {
+    return null;
+  }
+  const provider =
+    connection.provider === "openai" ||
+    connection.provider === "anthropic" ||
+    connection.provider === "google"
+      ? connection.provider
+      : undefined;
+  const headers = Array.isArray(connection.headers)
+    ? Object.fromEntries(
+        connection.headers
+          .filter((item) => item && typeof item.key === "string" && item.key.trim())
+          .map((item) => [item.key.trim(), item.value ?? ""]),
+      )
+    : undefined;
+  return {
+    kind,
+    provider,
+    baseUrl:
+      typeof connection.baseUrl === "string" && connection.baseUrl.trim()
+        ? connection.baseUrl.trim()
+        : kind === "builtin" && provider === "google"
+          ? GEMINI_OPENAI_BASE_URL
+          : kind === "ollama"
+            ? "http://localhost:11434"
+            : undefined,
+    apiKey: typeof connection.apiKey === "string" && connection.apiKey.trim() ? connection.apiKey.trim() : undefined,
+    headers,
+  };
+}
+
+function dedupeSorted(models: string[]): string[] {
+  return [...new Set(models.filter(Boolean))].sort((a, b) => a.localeCompare(b));
+}
+
+async function listAnthropicModels(apiKey: string): Promise<string[]> {
+  const collected: string[] = [];
+  let afterId: string | null = null;
+
+  for (let page = 0; page < 10; page += 1) {
+    const url = new URL("https://api.anthropic.com/v1/models");
+    url.searchParams.set("limit", "100");
+    if (afterId) {
+      url.searchParams.set("after_id", afterId);
+    }
+
+    const response = await fetch(url.toString(), {
+      headers: {
+        "anthropic-version": "2023-06-01",
+        "x-api-key": apiKey,
+      },
+    });
+
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      throw new Error(text || `Anthropic models request failed (${response.status})`);
+    }
+
+    const payload = (await response.json()) as AnthropicModelsResponse;
+    const ids = Array.isArray(payload.data)
+      ? payload.data
+          .map((item) => item.id)
+          .filter((id): id is string => typeof id === "string" && id.trim().length > 0)
+      : [];
+    collected.push(...ids);
+
+    if (!payload.has_more || !payload.last_id) {
+      break;
+    }
+    afterId = payload.last_id;
+  }
+
+  return dedupeSorted(collected);
+}
+
+async function listGoogleModels(apiKey: string): Promise<string[]> {
+  const collected: string[] = [];
+  let pageToken = "";
+
+  for (let page = 0; page < 10; page += 1) {
+    const url = new URL("https://generativelanguage.googleapis.com/v1beta/models");
+    url.searchParams.set("key", apiKey);
+    url.searchParams.set("pageSize", "100");
+    if (pageToken) {
+      url.searchParams.set("pageToken", pageToken);
+    }
+
+    const response = await fetch(url.toString());
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      throw new Error(text || `Google models request failed (${response.status})`);
+    }
+
+    const payload = (await response.json()) as GoogleModelsResponse;
+    const ids = Array.isArray(payload.models)
+      ? payload.models
+          .filter((item) =>
+            Array.isArray(item.supportedGenerationMethods)
+              ? item.supportedGenerationMethods.includes("generateContent")
+              : true,
+          )
+          .map((item) => (typeof item.name === "string" ? item.name.replace(/^models\//, "").trim() : ""))
+          .filter((id): id is string => id.length > 0)
+      : [];
+    collected.push(...ids);
+
+    if (!payload.nextPageToken) {
+      break;
+    }
+    pageToken = payload.nextPageToken;
+  }
+
+  return dedupeSorted(collected);
+}
+
+export async function POST(request: Request) {
+  try {
+    const body = (await request.json()) as ModelsRequest;
+    const connection = normalizeConnection(body.connection);
+    if (!connection) {
+      return new Response(JSON.stringify({ ok: false, error: "Missing connection." }), {
+        status: 400,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+
+    if (connection.kind === "ollama") {
+      const baseUrl = connection.baseUrl ?? "http://localhost:11434";
+      const response = await fetch(`${baseUrl.replace(/\/$/, "")}/api/tags`);
+      if (!response.ok) {
+        const text = await response.text().catch(() => "");
+        throw new Error(text || `Ollama models request failed (${response.status})`);
+      }
+      const payload = (await response.json()) as { models?: Array<{ name?: string }> };
+      const models = Array.isArray(payload.models)
+        ? payload.models.map((model) => model.name).filter((name): name is string => Boolean(name))
+        : [];
+      return new Response(JSON.stringify({ ok: true, models, source: "ollama" }), {
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+
+    if (connection.kind === "builtin" && connection.provider === "anthropic") {
+      if (connection.apiKey) {
+        const models = await listAnthropicModels(connection.apiKey);
+        if (models.length > 0) {
+          return new Response(JSON.stringify({ ok: true, models, source: "anthropic-api" }), {
+            headers: { "Content-Type": "application/json" },
+          });
+        }
+      }
+      return new Response(
+        JSON.stringify({ ok: true, models: getBuiltinModelPresets("anthropic"), source: "builtin-fallback" }),
+        { headers: { "Content-Type": "application/json" } },
+      );
+    }
+
+    if (connection.kind === "builtin" && connection.provider === "google") {
+      if (connection.apiKey) {
+        const models = await listGoogleModels(connection.apiKey);
+        if (models.length > 0) {
+          return new Response(JSON.stringify({ ok: true, models, source: "google-api" }), {
+            headers: { "Content-Type": "application/json" },
+          });
+        }
+      }
+      return new Response(
+        JSON.stringify({ ok: true, models: getBuiltinModelPresets("google"), source: "builtin-fallback" }),
+        { headers: { "Content-Type": "application/json" } },
+      );
+    }
+
+    const client = new OpenAI({
+      apiKey: connection.apiKey ?? "no-key-required",
+      baseURL: connection.baseUrl,
+      defaultHeaders: connection.headers,
+    });
+
+    const listed = await client.models.list();
+    const models = dedupeSorted(
+      listed.data
+      .map((item) => item.id)
+      .filter((value): value is string => typeof value === "string" && value.length > 0),
+    );
+
+    if (models.length > 0) {
+      return new Response(JSON.stringify({ ok: true, models, source: "remote" }), {
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+
+    if (connection.kind === "builtin" && connection.provider) {
+      return new Response(
+        JSON.stringify({
+          ok: true,
+          models: getBuiltinModelPresets(connection.provider),
+          source: "builtin-fallback",
+        }),
+        { headers: { "Content-Type": "application/json" } },
+      );
+    }
+
+    return new Response(JSON.stringify({ ok: true, models: [], source: "empty" }), {
+      headers: { "Content-Type": "application/json" },
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unexpected error.";
+    return new Response(JSON.stringify({ ok: false, error: message }), {
+      status: 500,
+      headers: { "Content-Type": "application/json" },
+    });
+  }
+}

package/template/src/app/api/connections/test/route.ts

@@ -0,0 +1,124 @@
+import OpenAI from "openai";
+import Anthropic from "@anthropic-ai/sdk";
+import type { ChatConnectionPayload } from "../../../../lib/types";
+import { GEMINI_OPENAI_BASE_URL } from "../../../../lib/connections";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+type TestRequest = {
+  connection?: ChatConnectionPayload;
+  model?: string;
+};
+
+function normalizeConnection(connection?: ChatConnectionPayload) {
+  if (!connection) {
+    return null;
+  }
+  const kind =
+    connection.kind === "builtin" || connection.kind === "openai_compatible" || connection.kind === "ollama"
+      ? connection.kind
+      : null;
+  if (!kind) {
+    return null;
+  }
+  const provider =
+    connection.provider === "openai" ||
+    connection.provider === "anthropic" ||
+    connection.provider === "google"
+      ? connection.provider
+      : undefined;
+  const headers = Array.isArray(connection.headers)
+    ? Object.fromEntries(
+        connection.headers
+          .filter((item) => item && typeof item.key === "string" && item.key.trim())
+          .map((item) => [item.key.trim(), item.value ?? ""]),
+      )
+    : undefined;
+  return {
+    id: connection.id || "ad-hoc",
+    name: connection.name || "Connection",
+    kind,
+    provider,
+    baseUrl:
+      typeof connection.baseUrl === "string" && connection.baseUrl.trim()
+        ? connection.baseUrl.trim()
+        : kind === "builtin" && provider === "google"
+          ? GEMINI_OPENAI_BASE_URL
+          : kind === "ollama"
+            ? "http://localhost:11434"
+            : undefined,
+    apiKey: typeof connection.apiKey === "string" && connection.apiKey.trim() ? connection.apiKey.trim() : undefined,
+    headers,
+  };
+}
+
+export async function POST(request: Request) {
+  try {
+    const body = (await request.json()) as TestRequest;
+    const connection = normalizeConnection(body.connection);
+    if (!connection) {
+      return new Response(JSON.stringify({ ok: false, error: "Missing connection." }), {
+        status: 400,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+
+    if (connection.kind === "ollama") {
+      const baseUrl = connection.baseUrl ?? "http://localhost:11434";
+      const response = await fetch(`${baseUrl.replace(/\/$/, "")}/api/tags`);
+      if (!response.ok) {
+        const text = await response.text().catch(() => "");
+        throw new Error(text || `Ollama test failed (${response.status})`);
+      }
+      return new Response(
+        JSON.stringify({ ok: true, provider: "ollama", message: "Connected to Ollama." }),
+        { headers: { "Content-Type": "application/json" } },
+      );
+    }
+
+    if (connection.kind === "builtin" && connection.provider === "anthropic") {
+      if (!connection.apiKey) {
+        throw new Error("Missing Anthropic API key.");
+      }
+      const client = new Anthropic({ apiKey: connection.apiKey });
+      await client.messages.create({
+        model: "claude-haiku-4-5",
+        max_tokens: 8,
+        messages: [{ role: "user", content: "ping" }],
+      });
+      return new Response(
+        JSON.stringify({ ok: true, provider: "anthropic", message: "Connected to Anthropic." }),
+        { headers: { "Content-Type": "application/json" } },
+      );
+    }
+
+    const client = new OpenAI({
+      apiKey: connection.apiKey ?? "no-key-required",
+      baseURL: connection.baseUrl,
+      defaultHeaders: connection.headers,
+    });
+    const pingModel =
+      typeof body.model === "string" && body.model.trim()
+        ? body.model.trim()
+        : connection.kind === "builtin" && connection.provider === "google"
+          ? "gemini-2.5-flash"
+          : "gpt-4o-mini";
+    await client.responses.create({
+      model: pingModel,
+      input: [{ role: "user", content: "ping" }],
+      max_output_tokens: 8,
+    });
+    return new Response(
+      JSON.stringify({ ok: true, provider: connection.provider ?? connection.kind, message: "Connection test succeeded." }),
+      { headers: { "Content-Type": "application/json" } },
+    );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unexpected error.";
+    return new Response(JSON.stringify({ ok: false, error: message }), {
+      status: 500,
+      headers: { "Content-Type": "application/json" },
+    });
+  }
+}
+

package/template/src/app/api/local-sync/route.ts

@@ -0,0 +1,74 @@
+import { NextRequest } from "next/server";
+import { promises as fs } from "fs";
+import path from "path";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+const DATA_DIR = ".zenith-data";
+const STATE_FILE = "state.json";
+
+function getStatePath(): string {
+  return path.join(process.cwd(), DATA_DIR, STATE_FILE);
+}
+
+function getDataDir(): string {
+  return path.join(process.cwd(), DATA_DIR);
+}
+
+const EMPTY_PAYLOAD = {
+  threads: [] as unknown[],
+  messages: [] as unknown[],
+  settings: [] as unknown[],
+  toolEvents: [] as unknown[],
+  toolApprovals: [] as unknown[],
+  memories: [] as unknown[],
+};
+
+export async function GET() {
+  const statePath = getStatePath();
+  try {
+    const raw = await fs.readFile(statePath, "utf-8");
+    const data = JSON.parse(raw);
+    const payload = {
+      threads: Array.isArray(data.threads) ? data.threads : EMPTY_PAYLOAD.threads,
+      messages: Array.isArray(data.messages) ? data.messages : EMPTY_PAYLOAD.messages,
+      settings: Array.isArray(data.settings) ? data.settings : EMPTY_PAYLOAD.settings,
+      toolEvents: Array.isArray(data.toolEvents) ? data.toolEvents : EMPTY_PAYLOAD.toolEvents,
+      toolApprovals: Array.isArray(data.toolApprovals) ? data.toolApprovals : EMPTY_PAYLOAD.toolApprovals,
+      memories: Array.isArray(data.memories) ? data.memories : EMPTY_PAYLOAD.memories,
+    };
+    return Response.json(payload);
+  } catch (err) {
+    const code = err && typeof err === "object" && "code" in err ? (err as NodeJS.ErrnoException).code : null;
+    if (code === "ENOENT") {
+      return Response.json(EMPTY_PAYLOAD);
+    }
+    throw err;
+  }
+}
+
+export async function POST(request: NextRequest) {
+  const statePath = getStatePath();
+  const dir = getDataDir();
+  let body: unknown;
+  try {
+    body = await request.json();
+  } catch {
+    return new Response("Invalid JSON", { status: 400 });
+  }
+  const data = (typeof body === "object" && body !== null ? body : {}) as Record<string, unknown>;
+  const payload = {
+    threads: Array.isArray(data.threads) ? data.threads : EMPTY_PAYLOAD.threads,
+    messages: Array.isArray(data.messages) ? data.messages : EMPTY_PAYLOAD.messages,
+    settings: Array.isArray(data.settings) ? data.settings : EMPTY_PAYLOAD.settings,
+    toolEvents: Array.isArray(data.toolEvents) ? data.toolEvents : EMPTY_PAYLOAD.toolEvents,
+    toolApprovals: Array.isArray(data.toolApprovals) ? data.toolApprovals : EMPTY_PAYLOAD.toolApprovals,
+    memories: Array.isArray(data.memories) ? data.memories : EMPTY_PAYLOAD.memories,
+  };
+  await fs.mkdir(dir, { recursive: true });
+  const tmpPath = path.join(dir, `${STATE_FILE}.${Date.now()}.tmp`);
+  await fs.writeFile(tmpPath, JSON.stringify(payload, null, 2), "utf-8");
+  await fs.rename(tmpPath, statePath);
+  return new Response(null, { status: 200 });
+}

package/template/src/app/api/tool-approval/route.ts

@@ -0,0 +1,47 @@
+import { resolveApprovalDecision } from "../../../lib/tooling/approvals";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+export async function POST(request: Request) {
+  try {
+    const body = (await request.json()) as {
+      approvalId?: unknown;
+      decision?: unknown;
+    };
+
+    if (typeof body.approvalId !== "string" || !body.approvalId.trim()) {
+      return new Response(JSON.stringify({ ok: false, error: "Missing approvalId." }), {
+        status: 400,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+
+    if (body.decision !== "approve" && body.decision !== "deny") {
+      return new Response(JSON.stringify({ ok: false, error: "Invalid decision." }), {
+        status: 400,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+
+    const approvalId = body.approvalId.trim();
+
+    const resolved = resolveApprovalDecision(approvalId, body.decision);
+    if (!resolved) {
+      return new Response(JSON.stringify({ ok: false, error: "Unable to resolve approval." }), {
+        status: 404,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+
+    return new Response(JSON.stringify({ ok: true }), {
+      headers: { "Content-Type": "application/json" },
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unexpected error.";
+    return new Response(JSON.stringify({ ok: false, error: message }), {
+      status: 500,
+      headers: { "Content-Type": "application/json" },
+    });
+  }
+}