@yancyyu/openhermit 1.5.8

package/src/renderer/utils/teamRuntimeSummary.ts

@@ -0,0 +1,53 @@
+import {
+  doesTeamModelCarryProviderBrand,
+  getTeamModelLabel,
+  getTeamProviderLabel,
+} from './teamModelCatalog';
+
+import type { TeamProviderId } from '@shared/types';
+
+export function getTeamRuntimeModelLabel(model: string | undefined): string | undefined {
+  return getTeamModelLabel(model);
+}
+
+export function getTeamRuntimeProviderLabel(
+  providerId: TeamProviderId | undefined
+): string | undefined {
+  return getTeamProviderLabel(providerId);
+}
+
+export function getTeamRuntimeEffortLabel(effort: string | undefined): string | undefined {
+  const trimmed = effort?.trim();
+  if (!trimmed) return undefined;
+  if (trimmed === 'low') return '低';
+  if (trimmed === 'medium') return '中';
+  if (trimmed === 'high') return '高';
+  return trimmed.charAt(0).toUpperCase() + trimmed.slice(1);
+}
+
+export function formatTeamRuntimeSummary(
+  providerId: TeamProviderId | undefined,
+  model: string | undefined,
+  effort?: string
+): string | undefined {
+  const providerLabel = getTeamRuntimeProviderLabel(providerId);
+  const modelLabel = getTeamRuntimeModelLabel(model);
+  const effortLabel = getTeamRuntimeEffortLabel(effort);
+
+  if (!providerLabel && !modelLabel && !effortLabel) {
+    return undefined;
+  }
+
+  const modelAlreadyCarriesProviderBrand = doesTeamModelCarryProviderBrand(providerId, modelLabel);
+
+  const providerActsAsBackendOnly =
+    providerId !== 'anthropic' && Boolean(modelLabel) && !modelAlreadyCarriesProviderBrand;
+
+  const parts = modelAlreadyCarriesProviderBrand
+    ? [modelLabel, effortLabel]
+    : providerActsAsBackendOnly
+      ? [modelLabel, `经由 ${providerLabel}`, effortLabel]
+      : [providerLabel, providerLabel && !modelLabel ? '默认' : modelLabel, effortLabel];
+
+  return parts.filter(Boolean).join(' · ');
+}

package/src/renderer/utils/toolLinkingEngine.ts

@@ -0,0 +1,117 @@
+/**
+ * Tool Linking Engine - Link tool calls to their results
+ *
+ * Matches tool_call steps with their corresponding tool_result steps
+ * and builds LinkedToolItem structures for display.
+ */
+
+import { estimateTokens, formatToolInput, formatToolResult, toDate } from './aiGroupHelpers';
+
+import type { ParsedMessage, SemanticStep } from '../types/data';
+import type { LinkedToolItem } from '../types/groups';
+
+/**
+ * Link tool calls to their results and build a map of LinkedToolItems.
+ *
+ * Strategy:
+ * 1. Iterate through steps to find all tool_call steps
+ * 2. For each tool call, search for matching tool_result by ID
+ *    - Tool result step IDs are set to the tool_use_id, matching the call's ID
+ * 3. Build LinkedToolItem with preview text
+ * 4. Include orphaned calls (calls without results)
+ * 5. For Skill tool calls, extract skill instructions from responses
+ *
+ * @param steps - Semantic steps from the AI Group
+ * @param responses - Optional raw messages for extracting skill instructions
+ * @returns Map of tool call ID to LinkedToolItem
+ */
+export function linkToolCallsToResults(
+  steps: SemanticStep[],
+  responses?: ParsedMessage[]
+): Map<string, LinkedToolItem> {
+  const linkedTools = new Map<string, LinkedToolItem>();
+
+  // First pass: collect all tool calls
+  const toolCalls = steps.filter((step) => step.type === 'tool_call');
+
+  // Build a map of result steps by their ID for fast lookup
+  const resultStepsById = new Map<string, SemanticStep>();
+  for (const step of steps) {
+    if (step.type === 'tool_result') {
+      resultStepsById.set(step.id, step);
+    }
+  }
+
+  // Build a map of skill instructions by source tool use ID
+  // Skill tools have follow-up isMeta:true messages with instructions starting with "Base directory for this skill:"
+  const skillInstructionsById = new Map<string, string>();
+
+  if (responses) {
+    for (const msg of responses) {
+      // Extract skill instructions
+      if (msg.type === 'user' && msg.isMeta && msg.sourceToolUseID && Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          if (block.type === 'text' && block.text) {
+            const text = block.text;
+            if (text.startsWith('Base directory for this skill:')) {
+              skillInstructionsById.set(msg.sourceToolUseID, text);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  for (const callStep of toolCalls) {
+    const toolCallId = callStep.id;
+    const toolName = callStep.content.toolName ?? 'Unknown';
+    const toolInput = callStep.content.toolInput ?? {};
+
+    // Search for matching tool result by ID
+    // Tool result steps have their ID set to the tool_use_id (same as call ID)
+    const resultStep = resultStepsById.get(toolCallId);
+
+    // Convert timestamps to proper Date objects (handles IPC serialization)
+    const callStartTime = toDate(callStep.startTime);
+    const resultStartTime = resultStep ? toDate(resultStep.startTime) : undefined;
+
+    // Get skill instructions for Skill tool calls
+    const skillInstructions =
+      toolName === 'Skill' ? skillInstructionsById.get(toolCallId) : undefined;
+
+    // Calculate callTokens directly from tool name + input
+    // This reflects what actually enters the context window (not proportioned output_tokens)
+    const callTokens = estimateTokens(toolName + JSON.stringify(toolInput));
+
+    const linkedItem: LinkedToolItem = {
+      id: toolCallId,
+      name: toolName,
+      input: toolInput as Record<string, unknown>,
+      callTokens, // Token count for tool call (what Claude generated)
+      result: resultStep
+        ? {
+            content: resultStep.content.toolResultContent ?? '',
+            isError: resultStep.content.isError ?? false,
+            toolUseResult: resultStep.content.toolUseResult,
+            tokenCount: resultStep.content.tokenCount, // Pre-computed token count for result
+          }
+        : undefined,
+      inputPreview: formatToolInput(toolInput as Record<string, unknown>),
+      outputPreview: resultStep
+        ? formatToolResult(resultStep.content.toolResultContent ?? '')
+        : undefined,
+      startTime: callStartTime,
+      endTime: resultStartTime,
+      durationMs: resultStartTime ? resultStartTime.getTime() - callStartTime.getTime() : undefined,
+      isOrphaned: !resultStep,
+      skillInstructions,
+      skillInstructionsTokenCount: skillInstructions
+        ? estimateTokens(skillInstructions)
+        : undefined,
+    };
+
+    linkedTools.set(toolCallId, linkedItem);
+  }
+
+  return linkedTools;
+}

package/src/renderer/utils/toolRendering/index.ts

@@ -0,0 +1,14 @@
+/**
+ * Tool Rendering Utilities
+ *
+ * Exports all tool rendering helper functions.
+ */
+
+export {
+  hasEditContent,
+  hasReadContent,
+  hasSkillInstructions,
+  hasWriteContent,
+} from './toolContentChecks';
+export { getToolSummary } from './toolSummaryHelpers';
+export { getToolContextTokens, getToolStatus } from './toolTokens';

package/src/renderer/utils/toolRendering/toolContentChecks.ts

@@ -0,0 +1,58 @@
+/**
+ * Tool Content Check Helpers
+ *
+ * Utilities for checking if tool items have specific types of content.
+ */
+
+import type { LinkedToolItem } from '@renderer/types/groups';
+
+/**
+ * Checks if a Skill tool has skill instructions.
+ */
+export function hasSkillInstructions(linkedTool: LinkedToolItem): boolean {
+  return !!linkedTool.skillInstructions;
+}
+
+/**
+ * Checks if a Read tool has content to display.
+ */
+export function hasReadContent(linkedTool: LinkedToolItem): boolean {
+  if (!linkedTool.result) return false;
+
+  const toolUseResult = linkedTool.result.toolUseResult as Record<string, unknown> | undefined;
+  const fileData = toolUseResult?.file as { content?: string } | undefined;
+  if (fileData?.content) return true;
+
+  if (linkedTool.result.content != null) {
+    if (typeof linkedTool.result.content === 'string' && linkedTool.result.content.length > 0)
+      return true;
+    if (Array.isArray(linkedTool.result.content) && linkedTool.result.content.length > 0)
+      return true;
+  }
+
+  return false;
+}
+
+/**
+ * Checks if an Edit tool has content to display.
+ */
+export function hasEditContent(linkedTool: LinkedToolItem): boolean {
+  if (linkedTool.input.old_string != null) return true;
+
+  const toolUseResult = linkedTool.result?.toolUseResult as Record<string, unknown> | undefined;
+  if (toolUseResult?.oldString != null || toolUseResult?.newString != null) return true;
+
+  return false;
+}
+
+/**
+ * Checks if a Write tool has content to display.
+ */
+export function hasWriteContent(linkedTool: LinkedToolItem): boolean {
+  if (linkedTool.input.content != null || linkedTool.input.file_path != null) return true;
+
+  const toolUseResult = linkedTool.result?.toolUseResult as Record<string, unknown> | undefined;
+  if (toolUseResult?.content != null || toolUseResult?.filePath != null) return true;
+
+  return false;
+}

package/src/renderer/utils/toolRendering/toolSummaryHelpers.ts

@@ -0,0 +1,276 @@
+/**
+ * Tool Summary Helpers
+ *
+ * Utilities for generating human-readable summaries for tool calls.
+ */
+
+import { getBaseName } from '@renderer/utils/pathUtils';
+import { summarizeAgentToolInput } from '@shared/utils/toolSummary';
+
+/**
+ * Truncates a string to a maximum length with ellipsis.
+ */
+function truncate(str: string, maxLength: number): string {
+  if (str.length <= maxLength) return str;
+  return str.slice(0, maxLength) + '...';
+}
+
+/**
+ * Generates a human-readable summary for a tool call.
+ */
+export function getToolSummary(toolName: string, input: Record<string, unknown>): string {
+  switch (toolName) {
+    case 'Edit': {
+      const filePath = input.file_path as string | undefined;
+      const oldString = input.old_string as string | undefined;
+      const newString = input.new_string as string | undefined;
+
+      if (!filePath) return 'Edit';
+
+      const fileName = getBaseName(filePath);
+
+      // Count line changes if we have old/new strings
+      if (oldString && newString) {
+        const oldLines = oldString.split('\n').length;
+        const newLines = newString.split('\n').length;
+        if (oldLines === newLines) {
+          return `${fileName} - ${oldLines} line${oldLines > 1 ? 's' : ''}`;
+        }
+        return `${fileName} - ${oldLines} -> ${newLines} lines`;
+      }
+
+      return fileName;
+    }
+
+    case 'Read': {
+      const filePath = input.file_path as string | undefined;
+      const limit = input.limit as number | undefined;
+      const offset = input.offset as number | undefined;
+
+      if (!filePath) return 'Read';
+
+      const fileName = getBaseName(filePath);
+
+      if (limit) {
+        const start = offset ?? 1;
+        return `${fileName} - lines ${start}-${start + limit - 1}`;
+      }
+
+      return fileName;
+    }
+
+    case 'Write': {
+      const filePath = input.file_path as string | undefined;
+      const content = input.content as string | undefined;
+
+      if (!filePath) return 'Write';
+
+      const fileName = getBaseName(filePath);
+
+      if (content) {
+        const lineCount = content.split('\n').length;
+        return `${fileName} - ${lineCount} lines`;
+      }
+
+      return fileName;
+    }
+
+    case 'Bash': {
+      const command = input.command as string | undefined;
+      const description = input.description as string | undefined;
+
+      // Prefer description if available
+      if (description) {
+        return truncate(description, 50);
+      }
+
+      if (command) {
+        return truncate(command, 50);
+      }
+
+      return 'Bash';
+    }
+
+    case 'Grep': {
+      const pattern = input.pattern as string | undefined;
+      const path = input.path as string | undefined;
+      const glob = input.glob as string | undefined;
+
+      if (!pattern) return 'Grep';
+
+      const patternStr = `"${truncate(pattern, 30)}"`;
+
+      if (glob) {
+        return `${patternStr} in ${glob}`;
+      }
+      if (path) {
+        return `${patternStr} in ${getBaseName(path)}`;
+      }
+
+      return patternStr;
+    }
+
+    case 'Glob': {
+      const pattern = input.pattern as string | undefined;
+      const path = input.path as string | undefined;
+
+      if (!pattern) return 'Glob';
+
+      const patternStr = `"${truncate(pattern, 30)}"`;
+
+      if (path) {
+        return `${patternStr} in ${getBaseName(path)}`;
+      }
+
+      return patternStr;
+    }
+
+    case 'Task': {
+      const prompt = input.prompt as string | undefined;
+      const subagentType = input.subagentType as string | undefined;
+      const description = input.description as string | undefined;
+
+      const desc = description ?? prompt;
+      const typeStr = subagentType ? `${subagentType} - ` : '';
+
+      if (desc) {
+        return `${typeStr}${truncate(desc, 40)}`;
+      }
+
+      return subagentType ?? 'Task';
+    }
+
+    case 'LSP': {
+      const operation = input.operation as string | undefined;
+      const filePath = input.filePath as string | undefined;
+
+      if (!operation) return 'LSP';
+
+      if (filePath) {
+        return `${operation} - ${getBaseName(filePath)}`;
+      }
+
+      return operation;
+    }
+
+    case 'WebFetch': {
+      const url = input.url as string | undefined;
+
+      if (url) {
+        try {
+          const urlObj = new URL(url);
+          return truncate(urlObj.hostname + urlObj.pathname, 50);
+        } catch {
+          return truncate(url, 50);
+        }
+      }
+
+      return 'WebFetch';
+    }
+
+    case 'WebSearch': {
+      const query = input.query as string | undefined;
+
+      if (query) {
+        return `"${truncate(query, 40)}"`;
+      }
+
+      return 'WebSearch';
+    }
+
+    case 'TodoWrite': {
+      const todos = input.todos as unknown[] | undefined;
+
+      if (todos && Array.isArray(todos)) {
+        return `${todos.length} item${todos.length !== 1 ? 's' : ''}`;
+      }
+
+      return 'TodoWrite';
+    }
+
+    case 'NotebookEdit': {
+      const notebookPath = input.notebook_path as string | undefined;
+      const editMode = input.edit_mode as string | undefined;
+
+      if (notebookPath) {
+        const fileName = getBaseName(notebookPath);
+        return editMode ? `${editMode} - ${fileName}` : fileName;
+      }
+
+      return 'NotebookEdit';
+    }
+
+    // =========================================================================
+    // Team Tools
+    // =========================================================================
+
+    case 'TeamCreate': {
+      const teamName = input.team_name as string | undefined;
+      const desc = input.description as string | undefined;
+      if (teamName) return `${teamName}${desc ? ' - ' + truncate(desc, 30) : ''}`;
+      return 'Create team';
+    }
+
+    case 'TaskCreate': {
+      const subject = input.subject as string | undefined;
+      return subject ? truncate(subject, 50) : 'Create task';
+    }
+
+    case 'TaskUpdate': {
+      const taskId = input.taskId as string | undefined;
+      const status = input.status as string | undefined;
+      const owner = input.owner as string | undefined;
+      const parts: string[] = [];
+      if (taskId) parts.push(`#${taskId}`);
+      if (status) parts.push(status);
+      if (owner) parts.push(`-> ${owner}`);
+      return parts.length > 0 ? parts.join(' ') : 'Update task';
+    }
+
+    case 'TaskList':
+      return 'List tasks';
+
+    case 'TaskGet': {
+      const taskId = input.taskId as string | undefined;
+      return taskId ? `Get task #${taskId}` : 'Get task';
+    }
+
+    case 'SendMessage': {
+      const msgType = input.type as string | undefined;
+      const recipient = input.recipient as string | undefined;
+      const summary = input.summary as string | undefined;
+      if (msgType === 'shutdown_request' && recipient) return `Shutdown ${recipient}`;
+      if (msgType === 'shutdown_response') return 'Shutdown response';
+      if (msgType === 'broadcast') return `Broadcast: ${truncate(summary ?? '', 30)}`;
+      if (recipient) return `To ${recipient}: ${truncate(summary ?? '', 30)}`;
+      return 'Send message';
+    }
+
+    case 'TeamDelete':
+      return 'Delete team';
+
+    case 'Agent': {
+      return summarizeAgentToolInput(input, 60);
+    }
+
+    default: {
+      // For unknown tools, try to extract a meaningful summary
+      const keys = Object.keys(input);
+      if (keys.length === 0) return toolName;
+
+      // Try common parameter names
+      const nameField = input.name ?? input.path ?? input.file ?? input.query ?? input.command;
+      if (typeof nameField === 'string') {
+        return truncate(nameField, 50);
+      }
+
+      // Fallback to showing first parameter
+      const firstValue = input[keys[0]];
+      if (typeof firstValue === 'string') {
+        return truncate(firstValue, 40);
+      }
+
+      return toolName;
+    }
+  }
+}

package/src/renderer/utils/toolRendering/toolTokens.ts

@@ -0,0 +1,57 @@
+/**
+ * Tool Token Utilities
+ *
+ * Functions for estimating and calculating token counts for tool operations.
+ */
+
+import { estimateTokens } from '@shared/utils/tokenFormatting';
+
+import type { ItemStatus } from '@renderer/components/chat/items/BaseItem';
+import type { LinkedToolItem } from '@renderer/types/groups';
+
+/**
+ * Calculates total context tokens consumed by a tool operation.
+ */
+export function getToolContextTokens(linkedTool: LinkedToolItem): number {
+  let totalTokens = 0;
+
+  // Tool CALL tokens (what Claude generated)
+  if (linkedTool.callTokens !== undefined) {
+    totalTokens += linkedTool.callTokens;
+  } else {
+    // Fallback: estimate from input
+    totalTokens += estimateTokens(JSON.stringify(linkedTool.input));
+  }
+
+  // Tool RESULT tokens (what Claude reads back)
+  if (linkedTool.result?.tokenCount !== undefined) {
+    totalTokens += linkedTool.result.tokenCount;
+  } else if (linkedTool.result?.content) {
+    const content = linkedTool.result.content;
+    if (typeof content === 'string') {
+      totalTokens += estimateTokens(content);
+    } else if (Array.isArray(content)) {
+      totalTokens += estimateTokens(JSON.stringify(content));
+    }
+  }
+
+  // For Skill tools, also add skill instructions tokens
+  if (linkedTool.name === 'Skill') {
+    if (linkedTool.skillInstructionsTokenCount !== undefined) {
+      totalTokens += linkedTool.skillInstructionsTokenCount;
+    } else if (linkedTool.skillInstructions) {
+      totalTokens += estimateTokens(linkedTool.skillInstructions);
+    }
+  }
+
+  return totalTokens;
+}
+
+/**
+ * Gets the status of a tool execution.
+ */
+export function getToolStatus(linkedTool: LinkedToolItem): ItemStatus {
+  if (linkedTool.isOrphaned) return 'orphaned';
+  if (linkedTool.result?.isError) return 'error';
+  return 'ok';
+}

package/src/renderer/utils/unwrapIpc.ts

@@ -0,0 +1,31 @@
+import { createLogger } from '@shared/utils/logger';
+
+const logger = createLogger('Renderer:unwrapIpc');
+
+export class IpcError extends Error {
+  constructor(
+    public readonly operation: string,
+    message: string,
+    public readonly causeError?: unknown
+  ) {
+    super(message);
+    this.name = 'IpcError';
+  }
+}
+
+/** Error messages that represent expected transient states, not real failures. */
+const EXPECTED_IPC_SIGNALS = ['TEAM_PROVISIONING', 'TEAM_DRAFT'];
+
+export async function unwrapIpc<T>(operation: string, fn: () => Promise<T>): Promise<T> {
+  try {
+    return await fn();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (EXPECTED_IPC_SIGNALS.some((sig) => message.includes(sig))) {
+      logger.debug(`[${operation}] ${message}`);
+    } else {
+      logger.error(`[${operation}] ${message}`);
+    }
+    throw new IpcError(operation, message, error);
+  }
+}

package/src/renderer/utils/urlMatchUtils.ts

@@ -0,0 +1,45 @@
+export interface TextMatch {
+  start: number;
+  end: number;
+  value: string;
+}
+
+const URL_REGEX = /https?:\/\/\S+/g;
+
+function trimUrlMatch(rawUrl: string): string {
+  // eslint-disable-next-line sonarjs/slow-regex -- trailing punctuation only, input bounded
+  return rawUrl.replace(/[),.!?;:]+$/g, '');
+}
+
+export function findUrlMatches(text: string): TextMatch[] {
+  if (!text) return [];
+
+  const matches: TextMatch[] = [];
+  for (const match of text.matchAll(URL_REGEX)) {
+    const rawValue = match[0];
+    const start = match.index ?? -1;
+    if (start < 0) continue;
+
+    const trimmedValue = trimUrlMatch(rawValue);
+    if (!trimmedValue) continue;
+
+    matches.push({
+      start,
+      end: start + trimmedValue.length,
+      value: trimmedValue,
+    });
+  }
+
+  return matches;
+}
+
+export function findUrlBoundary(text: string, cursorPos: number): TextMatch | null {
+  return (
+    findUrlMatches(text).find((match) => cursorPos >= match.start && cursorPos <= match.end) ?? null
+  );
+}
+
+export function removeUrlMatchFromText(text: string, match: TextMatch): string {
+  const removeEnd = match.end < text.length && text[match.end] === '\n' ? match.end + 1 : match.end;
+  return text.slice(0, match.start) + text.slice(removeEnd);
+}

package/src/renderer/vite-env.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="vite/client" />
+
+declare const __APP_VERSION__: string;
+
+declare module '*.png' {
+  const src: string;
+  // eslint-disable-next-line import/no-default-export -- Vite asset modules require default exports
+  export default src;
+}
+
+declare module '*.jpg' {
+  const src: string;
+  // eslint-disable-next-line import/no-default-export -- Vite asset modules require default exports
+  export default src;
+}
+
+declare module '*.svg' {
+  const src: string;
+  // eslint-disable-next-line import/no-default-export -- Vite asset modules require default exports
+  export default src;
+}