iris-chatbot 0.2.4

package/template/src/lib/model-presets.ts

@@ -0,0 +1,251 @@
+import type { BuiltInProvider, ModelConnection } from "./types";
+
+export const OPENAI_FRONTIER_MODEL_PRESETS = [
+  "gpt-5.2",
+  "gpt-5-mini",
+  "gpt-5-nano",
+  "gpt-5.2-pro",
+  "gpt-5",
+  "gpt-4.1",
+];
+
+const OPENAI_FRONTIER_MODEL_SET = new Set(OPENAI_FRONTIER_MODEL_PRESETS);
+
+export const BUILTIN_MODEL_PRESETS: Record<BuiltInProvider, string[]> = {
+  openai: [
+    "gpt-5.2",
+    "gpt-5.2-pro",
+    "gpt-5.2-chat-latest",
+    "gpt-5.2-codex",
+    "gpt-5.1",
+    "gpt-5.1-chat-latest",
+    "gpt-5.1-codex",
+    "gpt-5.1-codex-max",
+    "gpt-5",
+    "gpt-5-chat-latest",
+    "gpt-5-mini",
+    "gpt-5-nano",
+    "gpt-5-codex",
+    "gpt-5-pro",
+    "gpt-4.1",
+    "gpt-4.1-mini",
+    "gpt-4.1-nano",
+    "gpt-4o",
+    "gpt-4o-mini",
+    "o3-pro",
+    "o3",
+    "o4-mini",
+    "o3-mini",
+  ],
+  anthropic: [
+    "claude-opus-4-61",
+    "claude-sonnet-4-51",
+    "claude-haiku-4-51",
+    "claude-opus-4-5-20251101",
+    "claude-opus-4-51",
+    "claude-opus-4-11",
+    "claude-opus-4-1-20250805",
+    "claude-sonnet-4-01",
+    "claude-sonnet-4-20250514",
+    "claude-3-7-sonnet-latest",
+    "claude-3-7-sonnet-20250219",
+    "claude-opus-4-01",
+    "claude-opus-4-20250514",
+    "claude-3-haiku-20240307",
+  ],
+  google: [
+    "gemini-3-pro-preview",
+    "gemini-3-flash-preview",
+    "gemini-3-pro-image-preview",
+    "gemini-2.5-flash",
+    "gemini-2.5-flash-preview-09-2025",
+    "gemini-2.5-pro",
+    "gemini-2.5-flash-lite",
+    "gemini-2.5-flash-lite-preview-09-2025",
+    "gemini-2.5-flash-preview-tts",
+    "gemini-2.5-pro-preview-tts",
+    "gemini-2.0-flash",
+    "gemini-2.0-flash-001",
+    "gemini-2.0-flash-exp",
+    "gemini-2.0-flash-lite",
+    "gemini-flash-latest",
+  ],
+};
+
+export const OPENAI_COMPAT_MODEL_PRESETS = [
+  "gpt-4o-mini",
+  "gpt-4o",
+  "gpt-4.1-mini",
+  "gpt-4.1",
+];
+
+export const OLLAMA_MODEL_PRESETS = [
+  "llama3.2:latest",
+  "qwen2.5:latest",
+  "mistral:latest",
+  "gemma2:latest",
+];
+
+export function getBuiltinModelPresets(provider: BuiltInProvider) {
+  return BUILTIN_MODEL_PRESETS[provider] ?? [];
+}
+
+export function getConnectionModelPresets(connection: ModelConnection | null): string[] {
+  if (!connection) {
+    return [];
+  }
+  if (connection.kind === "builtin") {
+    if (!connection.provider) {
+      return [];
+    }
+    return getBuiltinModelPresets(connection.provider);
+  }
+  if (connection.kind === "ollama") {
+    return OLLAMA_MODEL_PRESETS;
+  }
+  return OPENAI_COMPAT_MODEL_PRESETS;
+}
+
+export function isOpenAIFrontierModel(modelId: string): boolean {
+  return OPENAI_FRONTIER_MODEL_SET.has(modelId);
+}
+
+export function filterModelIdsForConnection(params: {
+  connection: ModelConnection | null;
+  modelIds: string[];
+  includeExtendedOpenAI?: boolean;
+}): string[] {
+  const ids = [...new Set(params.modelIds.filter(Boolean))];
+  if (ids.length === 0) {
+    return ids;
+  }
+
+  if (
+    params.connection?.kind !== "builtin" ||
+    params.connection.provider !== "openai" ||
+    params.includeExtendedOpenAI
+  ) {
+    return ids;
+  }
+
+  const frontierOnly = OPENAI_FRONTIER_MODEL_PRESETS.filter((modelId) => ids.includes(modelId));
+  if (frontierOnly.length > 0) {
+    return frontierOnly;
+  }
+
+  return ids.slice(0, Math.min(ids.length, OPENAI_FRONTIER_MODEL_PRESETS.length));
+}
+
+const ANTHROPIC_MODEL_LABELS: Record<string, string> = {
+  "claude-opus-4-61": "Claude Opus 4.6",
+  "claude-sonnet-4-51": "Claude Sonnet 4.5",
+  "claude-haiku-4-51": "Claude Haiku 4.5",
+  "claude-opus-4-5-20251101": "Claude Opus 4.5",
+  "claude-opus-4-51": "Claude Opus 4.5",
+  "claude-opus-4-11": "Claude Opus 4.1",
+  "claude-opus-4-1-20250805": "Claude Opus 4.1",
+  "claude-sonnet-4-01": "Claude Sonnet 4",
+  "claude-sonnet-4-20250514": "Claude Sonnet 4",
+  "claude-3-7-sonnet-latest": "Claude 3.7 Sonnet (Latest)",
+  "claude-3-7-sonnet-20250219": "Claude 3.7 Sonnet",
+  "claude-opus-4-01": "Claude Opus 4",
+  "claude-opus-4-20250514": "Claude Opus 4",
+  "claude-3-haiku-20240307": "Claude 3 Haiku",
+};
+
+const GOOGLE_MODEL_LABELS: Record<string, string> = {
+  "gemini-3-pro-preview": "Gemini 3 Pro (Preview)",
+  "gemini-3-flash-preview": "Gemini 3 Flash (Preview)",
+  "gemini-3-pro-image-preview": "Gemini 3 Pro Image (Preview)",
+  "gemini-2.5-flash": "Gemini 2.5 Flash",
+  "gemini-2.5-flash-preview-09-2025": "Gemini 2.5 Flash (Preview Sep 2025)",
+  "gemini-2.5-pro": "Gemini 2.5 Pro",
+  "gemini-2.5-flash-lite": "Gemini 2.5 Flash Lite",
+  "gemini-2.5-flash-lite-preview-09-2025": "Gemini 2.5 Flash Lite (Preview Sep 2025)",
+  "gemini-2.5-flash-preview-tts": "Gemini 2.5 Flash TTS (Preview)",
+  "gemini-2.5-pro-preview-tts": "Gemini 2.5 Pro TTS (Preview)",
+  "gemini-2.0-flash": "Gemini 2.0 Flash",
+  "gemini-2.0-flash-001": "Gemini 2.0 Flash 001",
+  "gemini-2.0-flash-exp": "Gemini 2.0 Flash Experimental",
+  "gemini-2.0-flash-lite": "Gemini 2.0 Flash Lite",
+  "gemini-flash-latest": "Gemini Flash (Latest Alias)",
+};
+
+function formatAnthropicMinor(minorToken: string): string {
+  if (/^\d1$/.test(minorToken)) {
+    return minorToken[0];
+  }
+  if (/^\d$/.test(minorToken)) {
+    return minorToken;
+  }
+  return minorToken.replace(/^0+/, "") || "0";
+}
+
+function anthropicLabelFromId(modelId: string): string | null {
+  const base = modelId.replace(/-\d{8}$/g, "");
+  const familyMatch = base.match(/^claude-(opus|sonnet|haiku)-(\d+)-(\d+)$/);
+  if (!familyMatch) {
+    return null;
+  }
+  const family = familyMatch[1];
+  const major = familyMatch[2];
+  const minor = formatAnthropicMinor(familyMatch[3]);
+  const familyTitle = family.charAt(0).toUpperCase() + family.slice(1);
+  return `Claude ${familyTitle} ${major}.${minor}`;
+}
+
+function humanizeModelId(modelId: string): string {
+  const withoutDateSuffix = modelId.replace(/-\d{8}$/g, "");
+  return withoutDateSuffix.replace(/[-_]+/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+}
+
+export function getModelDisplayLabel(modelId: string, connection: ModelConnection | null): string {
+  if (!connection || connection.kind !== "builtin" || !connection.provider) {
+    return modelId;
+  }
+  if (connection.provider === "anthropic") {
+    return ANTHROPIC_MODEL_LABELS[modelId] ?? anthropicLabelFromId(modelId) ?? humanizeModelId(modelId);
+  }
+  if (connection.provider === "google") {
+    return GOOGLE_MODEL_LABELS[modelId] ?? humanizeModelId(modelId);
+  }
+  return modelId;
+}
+
+export function sortModelIdsForConnection(connection: ModelConnection | null, modelIds: string[]): string[] {
+  const ids = [...new Set(modelIds.filter(Boolean))];
+  if (!connection || connection.kind !== "builtin" || connection.provider !== "anthropic") {
+    return ids;
+  }
+
+  const familyRank = (value: string): number => {
+    if (value.includes("-opus-")) return 0;
+    if (value.includes("-sonnet-")) return 1;
+    if (value.includes("-haiku-")) return 2;
+    return 3;
+  };
+
+  const parseVersion = (value: string): { major: number; minor: number } => {
+    const normalized = value.replace(/-\d{8}$/g, "");
+    const match = normalized.match(/^claude-(?:opus|sonnet|haiku)-(\d+)-(\d+)$/);
+    if (!match) {
+      return { major: 0, minor: 0 };
+    }
+    const major = Number(match[1]) || 0;
+    const minor = Number(formatAnthropicMinor(match[2])) || 0;
+    return { major, minor };
+  };
+
+  return ids.sort((a, b) => {
+    const familyDelta = familyRank(a) - familyRank(b);
+    if (familyDelta !== 0) return familyDelta;
+    const va = parseVersion(a);
+    const vb = parseVersion(b);
+    if (va.major !== vb.major) return vb.major - va.major;
+    if (va.minor !== vb.minor) return vb.minor - va.minor;
+    const aHasDate = /-\d{8}$/.test(a);
+    const bHasDate = /-\d{8}$/.test(b);
+    if (aHasDate !== bHasDate) return aHasDate ? 1 : -1;
+    return a.localeCompare(b);
+  });
+}

package/template/src/lib/store.ts

@@ -0,0 +1,36 @@
+import { create } from "zustand";
+export type ViewMode = "chat" | "map";
+
+type UIState = {
+  viewMode: ViewMode;
+  activeThreadId: string | null;
+  focusedMessageId: string | null;
+  settingsOpen: boolean;
+  connectionOverrideId: string | null;
+  modelOverride: string;
+  sidebarCollapsed: boolean;
+  setViewMode: (view: ViewMode) => void;
+  setActiveThreadId: (id: string | null) => void;
+  setFocusedMessageId: (id: string | null) => void;
+  setSettingsOpen: (open: boolean) => void;
+  setConnectionOverrideId: (id: string | null) => void;
+  setModelOverride: (model: string) => void;
+  setSidebarCollapsed: (collapsed: boolean) => void;
+};
+
+export const useUIStore = create<UIState>((set) => ({
+  viewMode: "chat",
+  activeThreadId: null,
+  focusedMessageId: null,
+  settingsOpen: false,
+  connectionOverrideId: null,
+  modelOverride: "",
+  sidebarCollapsed: false,
+  setViewMode: (viewMode) => set({ viewMode }),
+  setActiveThreadId: (activeThreadId) => set({ activeThreadId }),
+  setFocusedMessageId: (focusedMessageId) => set({ focusedMessageId }),
+  setSettingsOpen: (settingsOpen) => set({ settingsOpen }),
+  setConnectionOverrideId: (connectionOverrideId) => set({ connectionOverrideId }),
+  setModelOverride: (modelOverride) => set({ modelOverride }),
+  setSidebarCollapsed: (sidebarCollapsed) => set({ sidebarCollapsed }),
+}));

package/template/src/lib/tooling/approvals.ts

@@ -0,0 +1,78 @@
+import { nanoid } from "nanoid";
+
+export type ApprovalDecision = "approve" | "deny" | "timeout";
+
+type PendingApproval = {
+  resolve: (decision: ApprovalDecision) => void;
+  timeout: NodeJS.Timeout;
+};
+
+type ApprovalStore = {
+  pendingApprovals: Map<string, PendingApproval>;
+};
+
+declare global {
+  var __zenithApprovalStore: ApprovalStore | undefined;
+}
+
+function getApprovalStore(): ApprovalStore {
+  if (!globalThis.__zenithApprovalStore) {
+    globalThis.__zenithApprovalStore = {
+      pendingApprovals: new Map<string, PendingApproval>(),
+    };
+  }
+  return globalThis.__zenithApprovalStore;
+}
+
+export function createApprovalRequest(params?: { timeoutMs?: number }) {
+  const store = getApprovalStore();
+  const approvalId = nanoid();
+  const timeoutMs = params?.timeoutMs ?? 5 * 60_000;
+
+  let resolveRef: ((decision: ApprovalDecision) => void) | null = null;
+  const promise = new Promise<ApprovalDecision>((resolve) => {
+    resolveRef = resolve;
+  });
+
+  const timeout = setTimeout(() => {
+    const pending = store.pendingApprovals.get(approvalId);
+    if (!pending) {
+      return;
+    }
+    store.pendingApprovals.delete(approvalId);
+    pending.resolve("timeout");
+  }, timeoutMs);
+
+  store.pendingApprovals.set(approvalId, {
+    resolve: (decision) => {
+      clearTimeout(timeout);
+      resolveRef?.(decision);
+    },
+    timeout,
+  });
+
+  return {
+    approvalId,
+    promise,
+  };
+}
+
+export function resolveApprovalDecision(
+  approvalId: string,
+  decision: "approve" | "deny",
+): boolean {
+  const store = getApprovalStore();
+  const pending = store.pendingApprovals.get(approvalId);
+  if (!pending) {
+    return false;
+  }
+
+  store.pendingApprovals.delete(approvalId);
+  clearTimeout(pending.timeout);
+  pending.resolve(decision);
+  return true;
+}
+
+export function hasPendingApproval(approvalId: string): boolean {
+  return getApprovalStore().pendingApprovals.has(approvalId);
+}

package/template/src/lib/tooling/providers/anthropic.ts

@@ -0,0 +1,155 @@
+import Anthropic from "@anthropic-ai/sdk";
+import type { ProviderToolSchema } from "../registry";
+import type {
+  CreateProviderSessionArgs,
+  NormalizedToolCall,
+  ProviderStep,
+  ToolLoopMessage,
+  ToolProviderSession,
+} from "./types";
+
+type AnthropicMessage = {
+  role: "user" | "assistant";
+  content: unknown;
+};
+
+function mapMessages(messages: ToolLoopMessage[]): AnthropicMessage[] {
+  const mapped: AnthropicMessage[] = [];
+
+  for (const message of messages) {
+    if (message.role === "system") {
+      continue;
+    }
+
+    if (message.role === "tool") {
+      if (!message.toolCallId) {
+        continue;
+      }
+      mapped.push({
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: message.toolCallId,
+            content: message.content,
+            is_error: false,
+          },
+        ],
+      });
+      continue;
+    }
+
+    mapped.push({
+      role: message.role,
+      content: message.content,
+    });
+  }
+
+  return mapped;
+}
+
+function mapTools(tools: ProviderToolSchema[]) {
+  return tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    input_schema: tool.input_schema,
+  }));
+}
+
+function parseContentBlocks(content: unknown): {
+  text: string;
+  toolCalls: NormalizedToolCall[];
+} {
+  if (!Array.isArray(content)) {
+    return { text: "", toolCalls: [] };
+  }
+
+  let text = "";
+  const toolCalls: NormalizedToolCall[] = [];
+
+  for (const block of content) {
+    if (!block || typeof block !== "object") {
+      continue;
+    }
+
+    const candidate = block as {
+      type?: unknown;
+      text?: unknown;
+      id?: unknown;
+      name?: unknown;
+      input?: unknown;
+    };
+
+    if (candidate.type === "text" && typeof candidate.text === "string") {
+      text += candidate.text;
+    }
+
+    if (
+      candidate.type === "tool_use" &&
+      typeof candidate.id === "string" &&
+      typeof candidate.name === "string"
+    ) {
+      const parsedInput =
+        candidate.input && typeof candidate.input === "object"
+          ? (candidate.input as Record<string, unknown>)
+          : {};
+
+      toolCalls.push({
+        id: candidate.id,
+        name: candidate.name,
+        input: parsedInput,
+      });
+    }
+  }
+
+  return { text, toolCalls };
+}
+
+export function createAnthropicSession(
+  args: CreateProviderSessionArgs,
+): ToolProviderSession {
+  const client = new Anthropic({ apiKey: args.apiKey });
+  const history = mapMessages(args.messages);
+  const tools = mapTools(args.tools);
+  const system = args.system?.trim() || undefined;
+
+  return {
+    async step(signal?: AbortSignal): Promise<ProviderStep> {
+      const response = await client.messages.create(
+        {
+          model: args.model,
+          max_tokens: 1024,
+          system,
+          messages: history as Anthropic.MessageParam[],
+          tools: tools.length > 0 ? (tools as Anthropic.Tool[]) : undefined,
+        },
+        { signal },
+      );
+
+      history.push({
+        role: "assistant",
+        content: response.content,
+      });
+
+      const { text, toolCalls } = parseContentBlocks(response.content);
+      return {
+        text,
+        toolCalls,
+      };
+    },
+
+    addToolResult(params) {
+      history.push({
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: params.callId,
+            content: params.result,
+            is_error: Boolean(params.isError),
+          },
+        ],
+      });
+    },
+  };
+}

package/template/src/lib/tooling/providers/ollama.ts

@@ -0,0 +1,73 @@
+import type { ChatMessageInput } from "../../types";
+
+type OllamaStreamEvent = {
+  model?: string;
+  created_at?: string;
+  message?: { role?: string; content?: string };
+  done?: boolean;
+  error?: string;
+};
+
+export async function streamOllamaChat(params: {
+  baseUrl: string;
+  model: string;
+  messages: ChatMessageInput[];
+  signal?: AbortSignal;
+  onToken: (value: string) => void;
+}): Promise<void> {
+  const response = await fetch(`${params.baseUrl.replace(/\/$/, "")}/api/chat`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      model: params.model,
+      messages: params.messages.map((message) => ({
+        role: message.role === "system" ? "user" : message.role,
+        content: message.content,
+      })),
+      stream: true,
+    }),
+    signal: params.signal,
+  });
+
+  if (!response.ok || !response.body) {
+    const text = await response.text().catch(() => "");
+    throw new Error(text || `Ollama request failed (${response.status})`);
+  }
+
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) {
+        continue;
+      }
+      let event: OllamaStreamEvent;
+      try {
+        event = JSON.parse(trimmed) as OllamaStreamEvent;
+      } catch {
+        continue;
+      }
+      if (event.error) {
+        throw new Error(event.error);
+      }
+      const content = event.message?.content;
+      if (typeof content === "string" && content.length > 0) {
+        params.onToken(content);
+      }
+    }
+  }
+}
+