BuzzbeeSCD/openchamber
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore: remove dead code (59 unused files + ~125 unused exports) (#1835)

Browse Source 
* chore: remove dead/unreferenced files across ui, vscode

Remove 59 unused source files (components, hooks, lib utils, stores,
barrels, and orphaned vscode github modules) that are not imported by
any entry-reachable code. Also drop a stale test mock for the removed
execCommands module.

Co-authored-by: Serhii Dziupin <makeittech@users.noreply.github.com>

* refactor: remove unused exported symbols (types, functions, consts, hooks)

Remove exported symbols whose identifier is referenced nowhere in the
repository (verified via repo-wide search), across ui types/contracts,
lib utilities, sync layer, stores, and components. Also drop the few
imports/private helpers orphaned by these removals.

Co-authored-by: Serhii Dziupin <makeittech@users.noreply.github.com>

* refactor: remove more unused exports (desktop, shortcuts, worktree, vscode)

Continue removing repo-wide unreferenced exported functions, consts and
types across lib/desktop, shortcuts, worktreeSessionCreator, sync, and
vscode gitService, with cascading orphaned helpers/imports cleaned up.

Co-authored-by: Serhii Dziupin <makeittech@users.noreply.github.com>

* chore: add dead-code cleanup tooling

* refactor: checkpoint dead-code cleanup

* refactor: remove dead-code suppressions

---------

Co-authored-by: Serhii Dziupin <makeittech@users.noreply.github.com>
Co-authored-by: Bohdan Triapitsyn <artmore@protonmail.com>
This commit is contained in:
Serhii Dziupin
2026-06-26 19:27:53 +03:00
committed by GitHub
co-authored by Serhii Dziupin Bohdan Triapitsyn
parent 4a37b9a005
commit 00821700de
324 changed files with 444 additions and 14876 deletions
Download Patch File Download Diff File Expand all files Collapse all files
packages/ui/src/components/chat/message/TextSelectionMenu.tsx
-2
View File
@@ -717,5 +717,3 @@ export const TextSelectionMenu: React.FC<TextSelectionMenuProps> = ({ containerR
document.body
);
};
export default TextSelectionMenu;
packages/ui/src/components/chat/message/partUtils.ts
+1 -11
View File
@@ -2,7 +2,7 @@ import type { Part } from '@opencode-ai/sdk/v2';
type PartWithText = Part & { text?: string; content?: string; value?: string };
export const isValidPart = (part: unknown): part is Part => {
const isValidPart = (part: unknown): part is Part => {
return Boolean(part && typeof part === 'object' && typeof (part as { type?: unknown }).type === 'string');
};
@@ -67,13 +67,3 @@ export const filterVisibleParts = (parts: Part[], options: VisibleFilterOptions
return !isPatchPart;
});
};
type PartWithTime = Part & { time?: { start?: number; end?: number } };
export const isFinalizedTextPart = (part: Part): boolean => {
if (part.type !== 'text') {
return false;
}
const time = (part as PartWithTime).time;
return Boolean(time && typeof time.end !== 'undefined');
};
packages/ui/src/components/chat/message/parts/MigratingPart.tsx
-31
View File
@@ -1,31 +0,0 @@
import React from 'react';
import { cn } from '@/lib/utils';
interface MigratingPartProps {
isMigrating: boolean;
children: React.ReactNode;
className?: string;
}
const MigratingPart: React.FC<MigratingPartProps> = ({
isMigrating,
children,
className,
}) => {
return (
<div
className={cn(
'w-full overflow-hidden',
isMigrating && 'pointer-events-none',
className
)}
style={isMigrating ? { animation: 'oc-migrate-up 220ms ease-out forwards' } : undefined}
>
{children}
</div>
);
};
export default React.memo(MigratingPart);
packages/ui/src/components/chat/message/parts/ReasoningPart.tsx
+1 -4
View File
@@ -18,7 +18,7 @@ const TOOL_ROW_DESCRIPTION_CLASS = cn('typography-meta', TOOL_ROW_TEXT_CLASS);
type PartWithText = Part & { text?: string; content?: string; time?: { start?: number; end?: number } };
export type ReasoningVariant = 'thinking' | 'justification';
type ReasoningVariant = 'thinking' | 'justification';
const cleanReasoningText = (text: string): string => {
if (typeof text !== 'string' || text.trim().length === 0) {
@@ -536,7 +536,4 @@ export const MergedReasoningPart = React.memo(({
);
});
// eslint-disable-next-line react-refresh/only-export-components
export const formatReasoningText = (text: string): string => cleanReasoningText(text);
export default ReasoningPart;
packages/ui/src/components/chat/message/parts/SessionActiveSpinner.tsx
-270
View File
@@ -1,270 +0,0 @@
import React from 'react';
/**
* 5x5 grid letter patterns (indices 0-24).
* Grid layout:
* 0 1 2 3 4
* 5 6 7 8 9
* 10 11 12 13 14
* 15 16 17 18 19
* 20 21 22 23 24
*
* Each letter is represented as an array of "on" cell indices.
*/
const LETTER_PATTERNS: Record<string, readonly number[]> = {
// 0 1 2 3 4
// 5 6 7 8 9
// 10 11 12 13 14
// 15 16 17 18 19
// 20 21 22 23 24
A: [1, 2, 3, 5, 9, 10, 11, 12, 13, 14, 15, 19, 20, 24],
B: [0, 1, 2, 3, 5, 9, 10, 11, 12, 13, 15, 19, 20, 21, 22, 23],
C: [1, 2, 3, 5, 10, 15, 21, 22, 23],
D: [0, 1, 2, 3, 5, 9, 10, 14, 15, 19, 20, 21, 22, 23],
E: [0, 1, 2, 3, 5, 10, 11, 12, 15, 20, 21, 22, 23],
F: [0, 1, 2, 3, 5, 10, 11, 12, 15, 20],
G: [1, 2, 3, 5, 10, 12, 13, 15, 18, 19, 21, 22, 23],
H: [0, 4, 5, 9, 10, 11, 12, 13, 14, 15, 19, 20, 24],
I: [1, 2, 3, 7, 12, 17, 21, 22, 23],
J: [1, 2, 3, 8, 13, 15, 18, 21, 22],
K: [0, 3, 5, 7, 10, 11, 15, 17, 20, 23],
L: [0, 5, 10, 15, 20, 21, 22, 23],
M: [0, 4, 5, 6, 8, 9, 10, 12, 14, 15, 19, 20, 24],
N: [0, 4, 5, 6, 9, 10, 12, 14, 15, 18, 19, 20, 24],
O: [1, 2, 3, 5, 9, 10, 14, 15, 19, 21, 22, 23],
P: [0, 1, 2, 3, 5, 8, 9, 10, 11, 12, 13, 15, 20],
Q: [1, 2, 3, 5, 9, 10, 14, 15, 18, 19, 21, 22, 24],
R: [0, 1, 2, 3, 5, 8, 9, 10, 11, 12, 13, 15, 17, 20, 23],
S: [1, 2, 3, 5, 11, 12, 13, 19, 21, 22, 23],
T: [0, 1, 2, 3, 4, 7, 12, 17, 22],
U: [0, 4, 5, 9, 10, 14, 15, 19, 21, 22, 23],
V: [0, 4, 5, 9, 10, 14, 16, 18, 22],
W: [0, 4, 5, 9, 10, 12, 14, 15, 16, 18, 19, 21, 23],
X: [0, 4, 6, 8, 12, 16, 18, 20, 24],
Y: [0, 4, 6, 8, 12, 17, 22],
Z: [0, 1, 2, 3, 4, 8, 12, 16, 20, 21, 22, 23, 24],
'0': [1, 2, 3, 5, 9, 10, 14, 15, 19, 21, 22, 23],
'1': [2, 6, 7, 12, 17, 20, 21, 22, 23, 24],
'2': [1, 2, 3, 9, 11, 12, 13, 16, 20, 21, 22, 23, 24],
'3': [0, 1, 2, 3, 9, 11, 12, 13, 19, 20, 21, 22, 23],
'4': [0, 4, 5, 9, 10, 11, 12, 13, 14, 19, 24],
'5': [0, 1, 2, 3, 4, 5, 10, 11, 12, 13, 19, 20, 21, 22, 23],
'6': [1, 2, 3, 5, 10, 11, 12, 13, 15, 19, 21, 22, 23],
'7': [0, 1, 2, 3, 4, 9, 13, 17, 22],
'8': [1, 2, 3, 5, 9, 11, 12, 13, 15, 19, 21, 22, 23],
'9': [1, 2, 3, 5, 9, 11, 12, 13, 19, 21, 22, 23],
' ': [],
};
// Build Set versions for O(1) lookups
const LETTER_SETS: Record<string, Set<number>> = {};
for (const [key, indices] of Object.entries(LETTER_PATTERNS)) {
LETTER_SETS[key] = new Set(indices);
}
/** Duration each letter is displayed (ms) */
const LETTER_DURATION_MS = 800;
/** Crossfade transition duration (ms) */
const TRANSITION_MS = 500;
/** Pause between full cycles (ms) */
const CYCLE_PAUSE_MS = 1000;
/** Spacing between dot centers in SVG units */
const DOT_SPACING = 4;
/** Dot radius */
const DOT_RADIUS = 1.2;
/**
* Octagonal grid layout (7 rows):
*
* • • • row 0: 3 dots (cols 2-4)
* • • • • • row 1: 5 dots (cols 1-5) → letter row 0
* • • • • • • • row 2: 7 dots (cols 0-6) → letter row 1
* • • • • • • • row 3: 7 dots (cols 0-6) → letter row 2
* • • • • • • • row 4: 7 dots (cols 0-6) → letter row 3
* • • • • • row 5: 5 dots (cols 1-5) → letter row 4
* • • • row 6: 3 dots (cols 2-4)
*
* Letter indices (0-24) map to the inner 5x5 zone:
* rows 1-5, cols 1-5
*/
const OCTAGON_ROWS: { row: number; cols: number[] }[] = [
{ row: 0, cols: [2, 3, 4] },
{ row: 1, cols: [1, 2, 3, 4, 5] },
{ row: 2, cols: [0, 1, 2, 3, 4, 5, 6] },
{ row: 3, cols: [0, 1, 2, 3, 4, 5, 6] },
{ row: 4, cols: [0, 1, 2, 3, 4, 5, 6] },
{ row: 5, cols: [1, 2, 3, 4, 5] },
{ row: 6, cols: [2, 3, 4] },
];
interface OctCell {
id: number;
cx: number;
cy: number;
/** Index into the 5x5 letter grid (0-24), or -1 for border-only dots */
letterIndex: number;
// Stable random timing
shimmerDuration: number;
shimmerDelay: number;
idleDuration: number;
idleDelay: number;
}
const CELLS: OctCell[] = [];
let cellId = 0;
for (const { row, cols } of OCTAGON_ROWS) {
for (const col of cols) {
const cx = col * DOT_SPACING;
const cy = row * DOT_SPACING;
// Letter zone: rows 1-5 (octagon), cols 1-5 (octagon)
// maps to 5x5 letter index
let letterIndex = -1;
const letterRow = row - 1;
const letterCol = col - 1;
if (letterRow >= 0 && letterRow < 5 && letterCol >= 0 && letterCol < 5) {
letterIndex = letterRow * 5 + letterCol;
}
CELLS.push({
id: cellId++,
cx,
cy,
letterIndex,
shimmerDuration: 3 + Math.random() * 3,
shimmerDelay: Math.random() * 3,
idleDuration: 1 + Math.random(),
idleDelay: Math.random() * 1.5,
});
}
}
const VIEW_SIZE = 6 * DOT_SPACING + DOT_RADIUS * 2;
const VIEW_OFFSET = -DOT_RADIUS;
interface SessionActiveSpinnerProps {
className?: string;
/** Text to spell out letter by letter. Falls back to idle pulse when empty/undefined. */
text?: string;
}
/**
* Idle mode: random pulsing octagonal dot grid.
* Text mode: cycles through characters of `text`, morphing between letter shapes.
*/
export function SessionActiveSpinner({ className, text }: SessionActiveSpinnerProps) {
const normalizedText = text?.toUpperCase().replace(/[^A-Z0-9 ]/g, '') || '';
const hasText = normalizedText.length > 0;
const [charIndex, setCharIndex] = React.useState(0);
const [phase, setPhase] = React.useState<'hold' | 'morph'>('hold');
// Intro fade: foreground starts invisible and fades in
const [introReady, setIntroReady] = React.useState(false);
React.useEffect(() => {
const id = requestAnimationFrame(() => setIntroReady(true));
return () => cancelAnimationFrame(id);
}, []);
// Reset on text change
React.useEffect(() => {
setCharIndex(0);
setPhase('hold');
}, [normalizedText]);
// Letter cycling timer
React.useEffect(() => {
if (!hasText) return;
const total = normalizedText.length;
if (phase === 'hold') {
const isLastChar = charIndex === total - 1;
const delay = LETTER_DURATION_MS + (isLastChar ? CYCLE_PAUSE_MS : 0);
const timer = setTimeout(() => setPhase('morph'), delay);
return () => clearTimeout(timer);
}
const timer = setTimeout(() => {
setCharIndex((prev) => (prev + 1) % total);
setPhase('hold');
}, TRANSITION_MS);
return () => clearTimeout(timer);
}, [hasText, charIndex, normalizedText, phase]);
// Compute current and next letter sets for morphing
const total = normalizedText.length;
const currentSet = hasText
? (LETTER_SETS[normalizedText[charIndex]] ?? LETTER_SETS[' '])
: null;
const nextIndex = hasText ? (charIndex + 1) % total : 0;
const nextSet = hasText
? (LETTER_SETS[normalizedText[nextIndex]] ?? LETTER_SETS[' '])
: null;
return (
<svg
viewBox={`${VIEW_OFFSET} ${VIEW_OFFSET} ${VIEW_SIZE} ${VIEW_SIZE}`}
data-component="session-active-spinner"
className={className}
fill="var(--foreground)"
aria-hidden="true"
>
{/* Background layer: all dots with shimmer animation */}
{CELLS.map((cell) => (
<circle
key={cell.id}
cx={cell.cx}
cy={cell.cy}
r={DOT_RADIUS}
style={{
animation: `${currentSet ? 'pulse-opacity-dim' : 'pulse-opacity'} ${currentSet ? cell.shimmerDuration : cell.idleDuration}s ease-in-out infinite`,
animationDelay: `${currentSet ? cell.shimmerDelay : cell.idleDelay}s`,
animationFillMode: 'both',
}}
/>
))}
{/* Foreground layer: morphing letter dots (only on letter-zone cells) */}
<g fill="var(--primary)">
{currentSet && nextSet && CELLS.map((cell) => {
if (cell.letterIndex < 0) return null;
const inCurrent = currentSet.has(cell.letterIndex);
const inNext = nextSet.has(cell.letterIndex);
if (!inCurrent && !inNext) return null;
let opacity: number;
if (!introReady) {
opacity = 0;
} else if (phase === 'hold') {
opacity = inCurrent ? 1 : 0;
} else {
if (inCurrent && inNext) {
opacity = 1;
} else if (inCurrent) {
opacity = 0;
} else {
opacity = 1;
}
}
return (
<circle
key={`fg-${cell.id}`}
cx={cell.cx}
cy={cell.cy}
r={DOT_RADIUS}
style={{
opacity,
transition: `opacity ${TRANSITION_MS}ms ease-in-out`,
}}
/>
);
})}
</g>
</svg>
);
}
packages/ui/src/components/chat/message/parts/generatedJsonResult.ts
+2 -2
View File
@@ -1,11 +1,11 @@
export type GeneratedCommitResult = {
type GeneratedCommitResult = {
kind: 'commit';
subject: string;
highlights: string[];
raw: string;
};
export type GeneratedPrResult = {
type GeneratedPrResult = {
kind: 'pr';
title: string;
body: string;
packages/ui/src/components/chat/message/parts/toolDiffUtils.ts
+1 -1
View File
@@ -18,7 +18,7 @@ const isRecord = (value: unknown): value is Record<string, unknown> => {
return typeof value === 'object' && value !== null;
};
export const normalizePatchText = (patch: string): string => {
const normalizePatchText = (patch: string): string => {
return patch.replace(/\r\n/g, '\n').replace(/\r/g, '\n').trim();
};
packages/ui/src/components/chat/message/parts/toolRenderUtils.ts
-10
View File
@@ -7,8 +7,6 @@ const EXPANDABLE_TOOL_NAMES = new Set<string>([
const STANDALONE_TOOL_NAMES = new Set<string>(['task']);
const SEARCH_TOOL_NAMES = new Set<string>(['grep', 'search', 'find', 'ripgrep', 'glob']);
const normalizeToolName = (toolName: unknown): string => {
if (typeof toolName !== 'string') return '';
const trimmed = toolName.trim().toLowerCase();
@@ -34,11 +32,3 @@ export const isStaticTool = (toolName: unknown): boolean => {
if (typeof toolName !== 'string') return false;
return !isExpandableTool(toolName) && !isStandaloneTool(toolName);
};
export const getStaticGroupToolName = (toolName: string): string => {
const normalized = normalizeToolName(toolName);
if (SEARCH_TOOL_NAMES.has(normalized)) {
return 'grep';
}
return normalized;
};
packages/ui/src/components/chat/message/renderCompare.ts
+1 -1
View File
@@ -106,7 +106,7 @@ export const areRenderRelevantPartsEqual = (left: Part[], right: Part[]): boolea
return true;
};
export const areRenderRelevantMessageInfoEqual = (left: Message, right: Message): boolean => {
const areRenderRelevantMessageInfoEqual = (left: Message, right: Message): boolean => {
if (left === right) return true;
return left.id === right.id
packages/ui/src/components/chat/message/toolRenderers.tsx
+4 -209
View File
@@ -11,7 +11,7 @@ const cleanOutput = (output: string) => {
return cleaned.trim();
};
export const hasLspDiagnostics = (output: string): boolean => {
const hasLspDiagnostics = (output: string): boolean => {
if (!output) return false;
return output.includes('<diagnostics')
|| output.includes('<file_diagnostics>')
@@ -124,7 +124,7 @@ export const formatEditOutput = (output: string, toolName: string, metadata?: Re
return cleaned;
};
export interface ParsedReadOutputLine {
interface ParsedReadOutputLine {
text: string;
lineNumber: number | null;
isInfo: boolean;
@@ -528,9 +528,9 @@ export const renderWebSearchOutput = (output: string, options?: { unstyled?: boo
}
};
export type DiffLineType = 'context' | 'added' | 'removed';
type DiffLineType = 'context' | 'added' | 'removed';
export interface UnifiedDiffLine {
interface UnifiedDiffLine {
type: DiffLineType;
lineNumber: number | null;
content: string;
@@ -543,18 +543,6 @@ export interface UnifiedDiffHunk {
lines: UnifiedDiffLine[];
}
export interface SideBySideDiffLine {
leftLine: { type: 'context' | 'removed' | 'empty'; lineNumber: number | null; content: string };
rightLine: { type: 'context' | 'added' | 'empty'; lineNumber: number | null; content: string };
}
export interface SideBySideDiffHunk {
file: string;
oldStart: number;
newStart: number;
lines: SideBySideDiffLine[];
}
export const parseDiffToUnified = (diffText: string): UnifiedDiffHunk[] => {
const lines = diffText.split('\n');
let currentFile = '';
@@ -615,199 +603,6 @@ export const parseDiffToUnified = (diffText: string): UnifiedDiffHunk[] => {
return hunks;
};
export const parseDiffToLines = (diffText: string): SideBySideDiffHunk[] => {
const lines = diffText.split('\n');
let currentFile = '';
const hunks: SideBySideDiffHunk[] = [];
let i = 0;
while (i < lines.length) {
const line = lines[i];
if (line.startsWith('Index:') || line.startsWith('===') || line.startsWith('---') || line.startsWith('+++')) {
if (line.startsWith('Index:')) {
currentFile = line.split(' ')[1].split('/').pop() || 'file';
}
i++;
continue;
}
if (line.startsWith('@@')) {
const match = line.match(/@@ -(\d+),\d+ \+(\d+),\d+ @@/);
const oldStart = match ? parseInt(match[1]) : 0;
const newStart = match ? parseInt(match[2]) : 0;
const changes: Array<{
type: 'context' | 'added' | 'removed';
content: string;
oldLine?: number;
newLine?: number;
}> = [];
let oldLineNum = oldStart;
let newLineNum = newStart;
let j = i + 1;
while (j < lines.length && !lines[j].startsWith('@@') && !lines[j].startsWith('Index:')) {
const contentLine = lines[j];
if (contentLine.startsWith('+')) {
changes.push({ type: 'added', content: contentLine.substring(1), newLine: newLineNum });
newLineNum++;
} else if (contentLine.startsWith('-')) {
changes.push({ type: 'removed', content: contentLine.substring(1), oldLine: oldLineNum });
oldLineNum++;
} else if (contentLine.startsWith(' ')) {
changes.push({
type: 'context',
content: contentLine.substring(1),
oldLine: oldLineNum,
newLine: newLineNum,
});
oldLineNum++;
newLineNum++;
}
j++;
}
const alignedLines: Array<{
leftLine: { type: 'context' | 'removed' | 'empty'; lineNumber: number | null; content: string };
rightLine: { type: 'context' | 'added' | 'empty'; lineNumber: number | null; content: string };
}> = [];
const leftSide: Array<{ type: 'context' | 'removed'; lineNumber: number; content: string }> = [];
const rightSide: Array<{ type: 'context' | 'added'; lineNumber: number; content: string }> = [];
changes.forEach((change) => {
if (change.type === 'context') {
leftSide.push({ type: 'context', lineNumber: change.oldLine!, content: change.content });
rightSide.push({ type: 'context', lineNumber: change.newLine!, content: change.content });
} else if (change.type === 'removed') {
leftSide.push({ type: 'removed', lineNumber: change.oldLine!, content: change.content });
} else if (change.type === 'added') {
rightSide.push({ type: 'added', lineNumber: change.newLine!, content: change.content });
}
});
const alignmentPoints: Array<{ leftIdx: number; rightIdx: number }> = [];
leftSide.forEach((leftItem, leftIdx) => {
if (leftItem.type === 'context') {
const rightIdx = rightSide.findIndex((rightItem, rIdx) =>
rightItem.type === 'context' &&
rightItem.content === leftItem.content &&
!alignmentPoints.some((ap) => ap.rightIdx === rIdx)
);
if (rightIdx >= 0) {
alignmentPoints.push({ leftIdx, rightIdx });
}
}
});
alignmentPoints.sort((a, b) => a.leftIdx - b.leftIdx);
let leftIdx = 0;
let rightIdx = 0;
let alignIdx = 0;
while (leftIdx < leftSide.length || rightIdx < rightSide.length) {
const nextAlign = alignIdx < alignmentPoints.length ? alignmentPoints[alignIdx] : null;
if (nextAlign && leftIdx === nextAlign.leftIdx && rightIdx === nextAlign.rightIdx) {
const leftItem = leftSide[leftIdx];
const rightItem = rightSide[rightIdx];
alignedLines.push({
leftLine: {
type: 'context',
lineNumber: leftItem.lineNumber,
content: leftItem.content,
},
rightLine: {
type: 'context',
lineNumber: rightItem.lineNumber,
content: rightItem.content,
},
});
leftIdx++;
rightIdx++;
alignIdx++;
} else {
const needProcessLeft = leftIdx < leftSide.length && (!nextAlign || leftIdx < nextAlign.leftIdx);
const needProcessRight = rightIdx < rightSide.length && (!nextAlign || rightIdx < nextAlign.rightIdx);
if (needProcessLeft && needProcessRight) {
const leftItem = leftSide[leftIdx];
const rightItem = rightSide[rightIdx];
alignedLines.push({
leftLine: {
type: leftItem.type,
lineNumber: leftItem.lineNumber,
content: leftItem.content,
},
rightLine: {
type: rightItem.type,
lineNumber: rightItem.lineNumber,
content: rightItem.content,
},
});
leftIdx++;
rightIdx++;
} else if (needProcessLeft) {
const leftItem = leftSide[leftIdx];
alignedLines.push({
leftLine: {
type: leftItem.type,
lineNumber: leftItem.lineNumber,
content: leftItem.content,
},
rightLine: {
type: 'empty',
lineNumber: null,
content: '',
},
});
leftIdx++;
} else if (needProcessRight) {
const rightItem = rightSide[rightIdx];
alignedLines.push({
leftLine: {
type: 'empty',
lineNumber: null,
content: '',
},
rightLine: {
type: rightItem.type,
lineNumber: rightItem.lineNumber,
content: rightItem.content,
},
});
rightIdx++;
} else {
break;
}
}
}
hunks.push({
file: currentFile,
oldStart,
newStart,
lines: alignedLines,
});
i = j;
continue;
}
i++;
}
return hunks;
};
export const detectLanguageFromOutput = (output: string, toolName: string, input?: Record<string, unknown>) => {
return detectToolOutputLanguage(toolName, output, input);
};