agentel 0.2.0

package/src/importers/gemini.js

@@ -0,0 +1,795 @@
+"use strict";
+
+const { toIso } = require("../archive");
+
+const PROVIDER = "gemini_cli";
+
+function parseGeminiCliJsonl(text, options = {}) {
+  const events = [];
+  for (const line of String(text || "").split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    try {
+      events.push(JSON.parse(line));
+    } catch {
+      // Ignore malformed partial lines in append-only history files.
+    }
+  }
+  return parseGeminiCliEvents(events, options);
+}
+
+function parseGeminiCliJson(data, options = {}) {
+  return parseGeminiCliEvents(geminiEventList(data), { ...options, root: data });
+}
+
+function parseGeminiCliEvents(events, options = {}) {
+  const root = options.root && typeof options.root === "object" ? options.root : {};
+  const normalizedEvents = coalesceGeminiIncrementalEvents(events);
+  const fallbackTime = toIso(options.fallbackTime) || new Date(0).toISOString();
+  const context = {
+    model: firstString(options.model, geminiModel(root)),
+    lastTimestamp: fallbackTime
+  };
+  let sessionId = firstString(options.sessionId, geminiSessionId(root));
+  let title = firstString(options.title, geminiTitle(root));
+  let cwd = firstString(options.cwd, geminiCwd(root));
+  const messages = [];
+
+  for (let index = 0; index < normalizedEvents.length; index++) {
+    const event = normalizedEvents[index];
+    if (!event || typeof event !== "object") continue;
+    context.model = firstString(geminiModel(event), context.model);
+    sessionId ||= geminiSessionId(event);
+    title ||= geminiTitle(event);
+    cwd ||= geminiCwd(event);
+    const timestamp = eventTimestamp(event, fallbackTime, index);
+    context.lastTimestamp = timestamp;
+    const usage = geminiUsage(event);
+
+    const checkpoint = geminiCheckpointMessage(event, timestamp);
+    if (checkpoint) {
+      messages.push(checkpoint);
+      continue;
+    }
+
+    const extracted = geminiMessagesFromEvent(event, { ...context, timestamp, usage });
+    if (extracted.length) {
+      messages.push(...extracted);
+      continue;
+    }
+
+    if (usage) applyUsageToLastAssistant(messages, usage);
+  }
+
+  const sorted = messages
+    .map((message, index) => ({ ...message, _ordinal: index }))
+    .sort((a, b) => {
+      const byTime = String(a.timestamp || "").localeCompare(String(b.timestamp || ""));
+      return byTime || a._ordinal - b._ordinal;
+    })
+    .map(({ _ordinal, ...message }) => message);
+
+  return {
+    sessionId,
+    title,
+    cwd,
+    model: context.model,
+    messages: sorted,
+    startedAt: sorted[0]?.timestamp || "",
+    endedAt: sorted[sorted.length - 1]?.timestamp || ""
+  };
+}
+
+function geminiEventList(data) {
+  if (Array.isArray(data)) return data;
+  if (!data || typeof data !== "object") return [];
+  const candidates = [
+    data.history,
+    data.messages,
+    data.turns,
+    data.events,
+    data.records,
+    data.contents,
+    data.conversation?.messages,
+    data.conversation?.turns,
+    data.session?.messages,
+    data.session?.history,
+    data.data?.messages,
+    data.data?.history
+  ];
+  const arrays = candidates.filter((item) => Array.isArray(item));
+  if (arrays.length) return arrays.flat();
+  return [data];
+}
+
+function coalesceGeminiIncrementalEvents(events) {
+  const output = [];
+  const indexes = new Map();
+  for (const event of events || []) {
+    if (!event || typeof event !== "object") {
+      output.push(event);
+      continue;
+    }
+    const id = geminiEventId(event);
+    if (!id) {
+      output.push(event);
+      continue;
+    }
+    const existingIndex = indexes.get(id);
+    if (existingIndex === undefined) {
+      indexes.set(id, output.length);
+      output.push(event);
+      continue;
+    }
+    output[existingIndex] = mergeGeminiEvent(output[existingIndex], event);
+  }
+  return output;
+}
+
+function mergeGeminiEvent(previous, next) {
+  const merged = { ...(previous && typeof previous === "object" ? previous : {}) };
+  for (const [key, value] of Object.entries(next || {})) {
+    if (value === undefined || value === null) continue;
+    if (typeof value === "string" && !value && merged[key]) continue;
+    if (Array.isArray(value)) {
+      if (value.length || !Array.isArray(merged[key])) merged[key] = value;
+      continue;
+    }
+    if (value && typeof value === "object" && merged[key] && typeof merged[key] === "object" && !Array.isArray(merged[key])) {
+      merged[key] = mergeGeminiEvent(merged[key], value);
+      continue;
+    }
+    merged[key] = value;
+  }
+  return merged;
+}
+
+function geminiMessagesFromEvent(event, context = {}) {
+  const messages = [];
+  const directCallNodes = directToolCallNodes(event);
+  const directCalls = directCallNodes.map((node) => normalizeGeminiToolCall(node, { event, context })).filter(Boolean);
+  if (directCalls.length) {
+    messages.push({
+      role: "assistant",
+      content: textFromGeminiParts(partsFromContent(event)),
+      timestamp: context.timestamp,
+      metadata: compactMetadata({
+        provider: PROVIDER,
+        eventType: eventType(event),
+        providerMessageId: geminiEventId(event),
+        model: context.model,
+        usage: context.usage,
+        thoughts: geminiThoughts(event),
+        toolCalls: directCalls
+      })
+    });
+    messages.push(...toolResultsFromToolCallNodes(directCallNodes, event, context));
+  }
+
+  const directResults = directToolResults(event, context);
+  if (directResults.length) messages.push(...directResults);
+  if (messages.length) return messages;
+
+  for (const node of contentNodesFromEvent(event)) {
+    const role = normalizeGeminiRole(firstString(node.role, node.author?.role, event.role, event.sender, event.type, event.kind));
+    const parts = partsFromContent(node);
+    const toolResults = toolResultsFromParts(parts, event, context);
+    if (role === "tool" || toolResults.length) {
+      messages.push(...toolResults);
+      continue;
+    }
+
+    const content = textFromGeminiParts(parts);
+    const toolCalls = toolCallsFromParts(parts, event, context);
+    if (!role && !content && !toolCalls.length) continue;
+    const messageRole = role || (toolCalls.length ? "assistant" : "");
+    if (!messageRole) continue;
+    messages.push({
+      role: messageRole,
+      content,
+      timestamp: timestampForNode(node, event, context.timestamp),
+      metadata: compactMetadata({
+        provider: PROVIDER,
+        eventType: eventType(event),
+        providerMessageId: geminiEventId(event),
+        model: messageRole === "assistant" ? context.model : undefined,
+        usage: messageRole === "assistant" ? context.usage : undefined,
+        thoughts: messageRole === "assistant" ? geminiThoughts(event) : undefined,
+        toolCalls: toolCalls.length ? toolCalls : undefined
+      })
+    });
+  }
+  return messages;
+}
+
+function contentNodesFromEvent(event) {
+  const nodes = [];
+  const add = (node) => {
+    if (node && typeof node === "object" && looksLikeGeminiContent(node)) nodes.push(node);
+  };
+  add(event);
+  add(event.message);
+  add(event.content);
+  add(event.item);
+  add(event.payload);
+  add(event.data);
+  add(event.response?.content);
+  if (Array.isArray(event.candidates)) {
+    for (const candidate of event.candidates) add(candidate.content || candidate.message || candidate);
+  }
+  if (Array.isArray(event.response?.candidates)) {
+    for (const candidate of event.response.candidates) add(candidate.content || candidate.message || candidate);
+  }
+  return uniqueObjects(nodes);
+}
+
+function looksLikeGeminiContent(node) {
+  if (!node || typeof node !== "object") return false;
+  if (Array.isArray(node.parts)) return true;
+  if (Array.isArray(node.content)) return true;
+  if (Array.isArray(node.content?.parts)) return true;
+  if (typeof node.text === "string" || typeof node.message === "string") return true;
+  if (typeof node.content === "string" && normalizeGeminiRole(firstString(node.role, node.type, node.kind))) return true;
+  if (node.functionCall || node.function_call || node.functionResponse || node.function_response) return true;
+  if (node.executableCode || node.executable_code || node.codeExecutionResult || node.code_execution_result) return true;
+  return Boolean(node.role && (node.content || node.parts || node.text));
+}
+
+function partsFromContent(node) {
+  if (!node || typeof node !== "object") return [];
+  const value = node.parts ?? node.content?.parts ?? node.message?.parts ?? node.content;
+  if (Array.isArray(value)) return value;
+  if (value && typeof value === "object") return [value];
+  if (typeof value === "string") return [{ text: value }];
+  if (typeof node.text === "string") return [{ text: node.text }];
+  if (typeof node.message === "string") return [{ text: node.message }];
+  return [node];
+}
+
+function directToolCalls(event, context) {
+  return directToolCallNodes(event).map((node) => normalizeGeminiToolCall(node, { event, context })).filter(Boolean);
+}
+
+function directToolCallNodes(event) {
+  const nodes = []
+    .concat(asArray(event.tool_calls))
+    .concat(asArray(event.toolCalls))
+    .concat(asArray(event.functionCalls))
+    .concat(asArray(event.function_calls));
+  if (event.functionCall || event.function_call) nodes.push(event.functionCall || event.function_call);
+  if (event.toolCall || event.tool_call) nodes.push(event.toolCall || event.tool_call);
+  if (event.type && /function[_-]?call|tool[_-]?call|tool[_-]?use/i.test(event.type)) nodes.push(event);
+  return nodes.filter((node) => node && typeof node === "object");
+}
+
+function directToolResults(event, context) {
+  const nodes = []
+    .concat(asArray(event.tool_results))
+    .concat(asArray(event.toolResults))
+    .concat(asArray(event.functionResponses))
+    .concat(asArray(event.function_responses));
+  if (event.functionResponse || event.function_response) nodes.push(event.functionResponse || event.function_response);
+  if (event.toolResult || event.tool_result) nodes.push(event.toolResult || event.tool_result);
+  if (event.type && /function[_-]?response|function[_-]?call[_-]?output|tool[_-]?(result|output)/i.test(event.type)) nodes.push(event);
+  return nodes.map((node) => toolResultMessage(normalizeGeminiToolResult(node, { event, context }), context.timestamp, event)).filter(Boolean);
+}
+
+function toolResultsFromToolCallNodes(nodes, event, context) {
+  const messages = [];
+  for (const node of nodes) {
+    const resultNodes = []
+      .concat(asArray(node.result))
+      .concat(asArray(node.results))
+      .concat(asArray(node.toolResult))
+      .concat(asArray(node.tool_result))
+      .concat(asArray(node.functionResponse))
+      .concat(asArray(node.function_response));
+    if (!resultNodes.length && firstString(node.resultDisplay, node.output)) {
+      resultNodes.push({ response: { output: firstString(node.resultDisplay, node.output) } });
+    }
+    for (const resultNode of resultNodes) {
+      const unwrapped = unwrapGeminiToolResult(resultNode);
+      const normalized = normalizeGeminiToolResult(
+        {
+          ...unwrapped,
+          id: firstString(unwrapped.id, unwrapped.callId, unwrapped.call_id, node.id, node.callId, node.call_id),
+          name: firstString(unwrapped.name, unwrapped.toolName, unwrapped.tool_name, node.name, node.toolName, node.tool_name),
+          status: firstString(unwrapped.status, node.status),
+          response: unwrapped.response ?? unwrapped.output ?? unwrapped.result ?? unwrapped.content ?? unwrapped.text
+        },
+        { event, context, part: node }
+      );
+      const timestamp = toIso(unwrapped.timestamp || node.timestamp) || context.timestamp;
+      const message = toolResultMessage(normalized, timestamp, event);
+      if (message) messages.push(message);
+    }
+  }
+  return messages;
+}
+
+function unwrapGeminiToolResult(value) {
+  if (!value || typeof value !== "object") return { response: { output: value } };
+  return value.functionResponse || value.function_response || value.toolResult || value.tool_result || value;
+}
+
+function toolCallsFromParts(parts, event, context) {
+  const calls = [];
+  for (const part of parts) {
+    const call =
+      part?.functionCall ||
+      part?.function_call ||
+      part?.toolCall ||
+      part?.tool_call ||
+      (part?.executableCode || part?.executable_code ? executableCodeCall(part) : null);
+    const normalized = normalizeGeminiToolCall(call, { event, context, part });
+    if (normalized) calls.push(normalized);
+  }
+  return calls;
+}
+
+function toolResultsFromParts(parts, event, context) {
+  const results = [];
+  for (const part of parts) {
+    const result =
+      part?.functionResponse ||
+      part?.function_response ||
+      part?.toolResult ||
+      part?.tool_result ||
+      (part?.codeExecutionResult || part?.code_execution_result ? codeExecutionResult(part) : null);
+    const normalized = normalizeGeminiToolResult(result, { event, context, part });
+    if (normalized) results.push(toolResultMessage(normalized, context.timestamp, event));
+  }
+  return results;
+}
+
+function normalizeGeminiToolCall(node, { event, part } = {}) {
+  if (!node || typeof node !== "object") return null;
+  const name = firstString(
+    node.name,
+    node.toolName,
+    node.tool_name,
+    node.function?.name,
+    event?.toolName,
+    event?.tool_name,
+    node.language === "bash" ? "run_shell_command" : "",
+    node.code ? "code_execution" : ""
+  );
+  if (!name) return null;
+  const args = parseToolArgsValue(
+    node.args ??
+      node.arguments ??
+      node.input ??
+      node.parameters ??
+      node.function?.arguments ??
+      (node.code ? { language: node.language, code: node.code } : undefined)
+  );
+  const summary = summarizeToolArguments(args);
+  return {
+    id: firstString(node.id, node.callId, node.call_id, event?.callId, event?.call_id, part?.id) || undefined,
+    name,
+    displayName: firstString(node.displayName, node.display_name, toolDisplayName(name)),
+    rawCategory: firstString(eventType(event), node.type, node.kind, "function_call"),
+    category: toolCategory(name, eventType(event)),
+    title: firstString(node.title, node.label, node.description, node.displayName, node.display_name, toolDisplayName(name)),
+    status: firstString(node.status, event?.status, "tool_call"),
+    argument: summary,
+    rawInputSummary: summary,
+    inputPreview: summary,
+    target: toolTarget(args) || undefined,
+    arguments: args && typeof args === "object" && !Array.isArray(args) ? args : undefined,
+    provider: PROVIDER
+  };
+}
+
+function normalizeGeminiToolResult(node, { event, part } = {}) {
+  if (!node || typeof node !== "object") return null;
+  const name = firstString(
+    node.name,
+    node.toolName,
+    node.tool_name,
+    node.function?.name,
+    event?.toolName,
+    event?.tool_name,
+    event?.name,
+    node.outcome ? "code_execution" : "",
+    "Tool output"
+  );
+  const output = toolOutputText(
+    node.response ??
+      node.output ??
+      node.result ??
+      node.content ??
+      node.text ??
+      node.stdout ??
+      node.stderr ??
+      node.error ??
+      (node.outcome ? { outcome: node.outcome, output: node.output } : undefined)
+  );
+  if (!output) return null;
+  const category = toolCategory(name, eventType(event));
+  const lineCount = output.split(/\r?\n/).length;
+  return {
+    provider: PROVIDER,
+    id: firstString(node.id, node.callId, node.call_id, event?.callId, event?.call_id, part?.id) || undefined,
+    kind: toolDisplayName(name),
+    title: node.error || node.stderr || /error|fail/i.test(String(node.outcome || "")) ? "Tool error" : "Tool result",
+    rawCategory: firstString(eventType(event), node.type, node.kind, "function_response"),
+    category,
+    categoryLabel: toolDisplayName(category),
+    summary: firstLine(output),
+    output,
+    lineCount,
+    collapsed: lineCount > 18,
+    status: firstString(node.status, event?.status, node.outcome, "completed"),
+    exitCode: numberValue(
+      node.exit_code ?? node.exitCode ?? node.response?.exit_code ?? node.response?.exitCode ?? node.output?.exit_code ?? node.output?.exitCode
+    )
+  };
+}
+
+function toolResultMessage(toolResult, timestamp, event) {
+  if (!toolResult) return null;
+  return {
+    role: "tool",
+    content: toolResult.output,
+    timestamp,
+    metadata: compactMetadata({
+      provider: PROVIDER,
+      eventType: toolResult.rawCategory,
+      providerMessageId: geminiEventId(event),
+      toolResult
+    })
+  };
+}
+
+function executableCodeCall(part) {
+  const value = part.executableCode || part.executable_code;
+  if (!value || typeof value !== "object") return null;
+  return {
+    name: value.language === "bash" || value.language === "shell" ? "run_shell_command" : "code_execution",
+    args: { language: value.language, code: value.code }
+  };
+}
+
+function codeExecutionResult(part) {
+  const value = part.codeExecutionResult || part.code_execution_result;
+  if (!value || typeof value !== "object") return null;
+  return {
+    name: "code_execution",
+    response: {
+      outcome: value.outcome,
+      output: value.output
+    }
+  };
+}
+
+function textFromGeminiParts(parts) {
+  return (parts || [])
+    .map((part) => {
+      if (typeof part === "string") return part;
+      if (!part || typeof part !== "object") return "";
+      if (typeof part.text === "string") return part.text;
+      if (typeof part.content === "string") return part.content;
+      if (part.inlineData || part.inline_data || part.fileData || part.file_data) return attachmentLabel(part);
+      return "";
+    })
+    .filter(Boolean)
+    .join("\n")
+    .trim();
+}
+
+function attachmentLabel(part) {
+  const data = part.inlineData || part.inline_data || part.fileData || part.file_data || {};
+  const mime = firstString(data.mimeType, data.mime_type);
+  const uri = firstString(data.fileUri, data.file_uri, data.uri);
+  if (uri && mime) return `[Attachment: ${mime} ${uri}]`;
+  if (uri) return `[Attachment: ${uri}]`;
+  if (mime) return `[Attachment: ${mime}]`;
+  return "[Attachment]";
+}
+
+function geminiCheckpointMessage(event, timestamp) {
+  const type = eventType(event);
+  if (!/(checkpoint|snapshot|restore)/i.test(type) && !event.checkpoint && !event.checkpointId && !event.checkpoint_id) return null;
+  const checkpoint = event.checkpoint && typeof event.checkpoint === "object" ? event.checkpoint : event;
+  const checkpointId = firstString(checkpoint.id, checkpoint.checkpointId, checkpoint.checkpoint_id, event.checkpointId, event.checkpoint_id);
+  const files = asArray(checkpoint.files || checkpoint.changedFiles || checkpoint.changed_files).filter(Boolean);
+  const label = /restore/i.test(type) ? "Checkpoint restored" : "Checkpoint saved";
+  return {
+    role: "system",
+    content: files.length ? `${label}: ${files.join(", ")}` : label,
+    timestamp,
+    metadata: compactMetadata({
+      provider: PROVIDER,
+      eventType: type || "checkpoint",
+      providerGenerated: true,
+      contextKind: "checkpoint",
+      contextSource: "gemini-checkpoint-event",
+      checkpointId,
+      files: files.length ? files : undefined,
+      gitSha: firstString(checkpoint.gitSha, checkpoint.git_sha, checkpoint.sha, checkpoint.commit)
+    })
+  };
+}
+
+function geminiUsage(value) {
+  if (!value || typeof value !== "object") return null;
+  const usage =
+    value.usageMetadata ||
+    value.usage_metadata ||
+    value.usage ||
+    value.tokens ||
+    value.tokenUsage ||
+    value.token_usage ||
+    value.response?.usageMetadata ||
+    value.response?.usage_metadata ||
+    value.response?.tokens;
+  if (!usage || typeof usage !== "object") return null;
+  const inputTokens = numberValue(
+    usage.promptTokenCount ?? usage.prompt_token_count ?? usage.inputTokens ?? usage.input_tokens ?? usage.prompt_tokens ?? usage.input
+  );
+  const outputTokens = numberValue(
+    usage.candidatesTokenCount ??
+      usage.candidates_token_count ??
+      usage.outputTokens ??
+      usage.output_tokens ??
+      usage.completion_tokens ??
+      usage.output
+  );
+  const totalTokens = numberValue(usage.totalTokenCount ?? usage.total_token_count ?? usage.totalTokens ?? usage.total_tokens ?? usage.total);
+  const thoughtsTokens = numberValue(usage.thoughtsTokenCount ?? usage.thoughts_token_count ?? usage.thoughts);
+  const cacheReadTokens = numberValue(usage.cachedContentTokenCount ?? usage.cached_content_token_count ?? usage.cacheReadTokens ?? usage.cached);
+  const toolUsePromptTokens = numberValue(usage.toolUsePromptTokenCount ?? usage.tool_use_prompt_token_count ?? usage.tool);
+  const normalized = compactMetadata({
+    inputTokens,
+    outputTokens,
+    totalTokens,
+    thoughtsTokens,
+    cacheReadTokens,
+    toolUsePromptTokens
+  });
+  return Object.keys(normalized).length ? normalized : null;
+}
+
+function geminiThoughts(value) {
+  const thoughts = asArray(value?.thoughts || value?.reasoning || value?.thinking)
+    .map((thought) => {
+      if (!thought || typeof thought !== "object") return null;
+      return compactMetadata({
+        subject: firstString(thought.subject, thought.title, thought.name),
+        description: firstString(thought.description, thought.summary, thought.text, thought.content),
+        timestamp: toIso(thought.timestamp || thought.createdAt || thought.created_at)
+      });
+    })
+    .filter((thought) => thought && Object.keys(thought).length);
+  return thoughts.length ? thoughts : undefined;
+}
+
+function applyUsageToLastAssistant(messages, usage) {
+  if (!usage) return;
+  const target = [...messages].reverse().find((message) => message.role === "assistant");
+  if (!target) return;
+  target.metadata = { ...(target.metadata || {}), usage };
+}
+
+function geminiSessionId(value) {
+  return firstString(
+    value?.sessionId,
+    value?.session_id,
+    value?.conversationId,
+    value?.conversation_id,
+    value?.chatId,
+    value?.chat_id,
+    value?.id,
+    value?.session?.id,
+    value?.metadata?.sessionId,
+    value?.metadata?.session_id
+  );
+}
+
+function geminiTitle(value) {
+  return firstString(value?.title, value?.name, value?.summary, value?.metadata?.title, value?.session?.title);
+}
+
+function geminiCwd(value) {
+  return firstString(
+    value?.cwd,
+    value?.workingDirectory,
+    value?.working_directory,
+    value?.workspace,
+    value?.workspaceFolder,
+    value?.projectRoot,
+    value?.project_root,
+    value?.context?.cwd,
+    value?.metadata?.cwd,
+    value?.session?.cwd
+  );
+}
+
+function geminiModel(value) {
+  return firstString(
+    value?.model,
+    value?.modelName,
+    value?.model_name,
+    value?.modelVersion,
+    value?.model_version,
+    value?.metadata?.model,
+    value?.response?.model
+  );
+}
+
+function eventTimestamp(event, fallbackTime, index) {
+  const explicit = toIso(
+    event.timestamp ||
+      event.createdAt ||
+      event.created_at ||
+      event.time ||
+      event.startTime ||
+      event.start_time ||
+      event.metadata?.timestamp
+  );
+  if (explicit) return explicit;
+  return new Date(new Date(fallbackTime).getTime() + index).toISOString();
+}
+
+function timestampForNode(node, event, fallback) {
+  return toIso(node.timestamp || node.createdAt || node.created_at || event.timestamp || event.createdAt || event.created_at) || fallback;
+}
+
+function eventType(event) {
+  return firstString(event?.type, event?.kind, event?.eventType, event?.event_type, event?.name);
+}
+
+function geminiEventId(event) {
+  return firstString(event?.id, event?.messageId, event?.message_id, event?.eventId, event?.event_id);
+}
+
+function normalizeGeminiRole(role) {
+  const value = String(role || "").toLowerCase();
+  if (value === "model" || value === "assistant" || value === "gemini") return "assistant";
+  if (value === "human" || value === "user") return "user";
+  if (value === "function" || value === "tool" || value === "functionresponse") return "tool";
+  if (value === "system") return "system";
+  if (value.includes("model")) return "assistant";
+  if (value.includes("assistant")) return "assistant";
+  if (value.includes("user")) return "user";
+  if (value.includes("tool") || value.includes("function_response")) return "tool";
+  return "";
+}
+
+function toolCategory(name, type = "") {
+  const text = `${name || ""} ${type || ""}`;
+  if (/shell|bash|command|terminal|exec|npm|yarn|pnpm/i.test(text)) return "shell";
+  if (/web|fetch|browser|url|http/i.test(text)) return "web";
+  if (/edit|write|patch|replace|insert|update/i.test(text)) return "edit";
+  if (/read|open|view|cat|ls|list/i.test(text)) return "read";
+  if (/grep|glob|find|search|rg/i.test(text)) return "search";
+  if (/mcp/i.test(text)) return "mcp";
+  return /function/i.test(type) ? "function" : "tool";
+}
+
+function parseToolArgsValue(value) {
+  if (value == null) return null;
+  if (typeof value === "string") {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+  return value;
+}
+
+function summarizeToolArguments(value) {
+  if (value == null) return "";
+  if (typeof value === "string") return value.slice(0, 240);
+  if (typeof value !== "object") return String(value).slice(0, 240);
+  for (const key of ["query", "pattern", "command", "cmd", "code", "path", "file", "file_path", "dir_path"]) {
+    if (value[key]) return String(value[key]).slice(0, 240);
+  }
+  return Object.entries(value)
+    .slice(0, 3)
+    .map(([key, item]) => `${key}: ${typeof item === "string" ? item : JSON.stringify(item)}`)
+    .join(", ")
+    .slice(0, 240);
+}
+
+function toolOutputText(value) {
+  if (value == null) return "";
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) return "";
+    try {
+      const parsed = JSON.parse(trimmed);
+      const nested = toolOutputText(parsed.output ?? parsed.content ?? parsed.result ?? parsed.text ?? parsed.stdout ?? parsed.stderr);
+      if (nested) return nested;
+    } catch {
+      // Keep raw text.
+    }
+    return trimmed.replace(/^Output:\s*\n?/i, "").trim();
+  }
+  if (Array.isArray(value)) return value.map(toolOutputText).filter(Boolean).join("\n");
+  if (typeof value === "object") {
+    if (value.functionResponse || value.function_response) return toolOutputText(value.functionResponse || value.function_response);
+    if (value.toolResult || value.tool_result) return toolOutputText(value.toolResult || value.tool_result);
+    const preferred = value.output ?? value.stdout ?? value.stderr ?? value.error ?? value.result ?? value.content ?? value.text ?? value.message;
+    if (preferred != null) return toolOutputText(preferred);
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+
+function toolTarget(args) {
+  if (!args || typeof args !== "object") return "";
+  return firstString(
+    args.path,
+    args.file,
+    args.filename,
+    args.file_path,
+    args.filePath,
+    args.dir_path,
+    args.dirPath,
+    args.directory,
+    args.folder,
+    args.cwd,
+    args.root,
+    args.url
+  );
+}
+
+function firstLine(value) {
+  return String(value || "").split(/\r?\n/).find((line) => line.trim())?.trim() || "";
+}
+
+function toolDisplayName(value) {
+  const text = String(value || "tool").trim();
+  return text
+    .split(/_+|(?=[A-Z])/g)
+    .filter(Boolean)
+    .map((part) => part.replace(/(^|[-\s])([a-z])/g, (_, prefix, char) => `${prefix}${char.toUpperCase()}`))
+    .join(" ");
+}
+
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) return value.trim();
+    if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  }
+  return "";
+}
+
+function numberValue(value) {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : undefined;
+}
+
+function asArray(value) {
+  if (Array.isArray(value)) return value;
+  return value == null ? [] : [value];
+}
+
+function compactMetadata(value) {
+  const output = {};
+  for (const [key, item] of Object.entries(value || {})) {
+    if (item === undefined || item === null || item === "") continue;
+    if (Array.isArray(item) && !item.length) continue;
+    output[key] = item;
+  }
+  return output;
+}
+
+function uniqueObjects(values) {
+  const seen = new Set();
+  const result = [];
+  for (const value of values) {
+    if (seen.has(value)) continue;
+    seen.add(value);
+    result.push(value);
+  }
+  return result;
+}
+
+module.exports = {
+  parseGeminiCliEvents,
+  parseGeminiCliJson,
+  parseGeminiCliJsonl
+};