@kirosnn/mosaic 0.71.0 → 0.73.0

package/src/utils/markdown.tsx

@@ -121,112 +121,176 @@ export function parseMarkdownContent(content: string): ParsedMarkdownLine[] {
   return result;
 }
 
-export function wrapMarkdownText(text: string, maxWidth: number): { text: string; segments: MarkdownSegment[] }[] {
-  if (!text || maxWidth <= 0) return [{ text: '', segments: [] }];
-
-  const segments = parseMarkdownLine(text);
-  const lines: { text: string; segments: MarkdownSegment[] }[] = [];
-  let currentLine = '';
-  let currentSegments: MarkdownSegment[] = [];
-
-  for (const segment of segments) {
-    const content = segment.content;
-    const fullText = content;
-
-    if (!currentLine) {
-      if (fullText.length <= maxWidth) {
-        currentLine = fullText;
-        currentSegments.push(segment);
-      } else {
-        let remaining = content;
-        while (remaining) {
-          if (remaining.length <= maxWidth) {
-            currentLine = remaining;
-            currentSegments.push({ ...segment, content: remaining });
-            remaining = '';
-          } else {
-            const breakPoint = remaining.lastIndexOf(' ', maxWidth);
-            if (breakPoint > 0) {
-              const chunk = remaining.slice(0, breakPoint);
-              currentLine = chunk;
-              currentSegments.push({ ...segment, content: chunk });
-              lines.push({ text: currentLine, segments: currentSegments });
-              currentLine = '';
-              currentSegments = [];
-              remaining = remaining.slice(breakPoint + 1);
-            } else {
-              const chunk = remaining.slice(0, maxWidth);
-              currentLine = chunk;
-              currentSegments.push({ ...segment, content: chunk });
-              lines.push({ text: currentLine, segments: currentSegments });
-              currentLine = '';
-              currentSegments = [];
-              remaining = remaining.slice(maxWidth);
-            }
-          }
-        }
-      }
+export function wrapMarkdownText(text: string, maxWidth: number): { text: string; segments: MarkdownSegment[] }[] {
+  if (!text || maxWidth <= 0) return [{ text: '', segments: [] }];
+
+  const segments = parseMarkdownLine(text);
+  const lines: { text: string; segments: MarkdownSegment[] }[] = [];
+  let currentLine = '';
+  let currentSegments: MarkdownSegment[] = [];
+
+  const splitSegment = (segment: MarkdownSegment): MarkdownSegment[] => {
+    if (segment.type === 'code') return [segment];
+    const parts = segment.content.match(/\s+|[^\s]+/g);
+    if (!parts) return [segment];
+    return parts.map(part => ({ ...segment, content: part }));
+  };
+
+  const pushLine = () => {
+    if (!currentLine) return;
+    lines.push({ text: currentLine, segments: currentSegments });
+    currentLine = '';
+    currentSegments = [];
+  };
+
+  const addPiece = (piece: MarkdownSegment) => {
+    let remaining = piece.content;
+    while (remaining.length > 0) {
+      if (!currentLine) {
+        if (remaining.trim() === '') {
+          return;
+        }
+        if (remaining.length <= maxWidth) {
+          currentLine = remaining;
+          currentSegments = [{ ...piece, content: remaining }];
+          return;
+        }
+        const chunk = remaining.slice(0, maxWidth);
+        lines.push({ text: chunk, segments: [{ ...piece, content: chunk }] });
+        remaining = remaining.slice(maxWidth);
+        continue;
+      }
+
+      if ((currentLine + remaining).length <= maxWidth) {
+        currentLine += remaining;
+        currentSegments.push({ ...piece, content: remaining });
+        return;
+      }
+
+      pushLine();
+    }
+  };
+
+  for (const segment of segments) {
+    const pieces = splitSegment(segment);
+    for (const piece of pieces) {
+      addPiece(piece);
+    }
+  }
+
+  if (currentLine) {
+    lines.push({ text: currentLine, segments: currentSegments });
+  }
+
+  return lines.length > 0 ? lines : [{ text: '', segments: [] }];
+}
+
+export interface WrappedMarkdownBlock {
+  type: 'line' | 'code';
+  wrappedLines?: { text: string; segments: MarkdownSegment[] }[];
+  codeLines?: string[];
+  language?: string;
+}
+
+function wrapCodeLine(line: string, maxWidth: number): string[] {
+  if (!line) return [''];
+  if (maxWidth <= 0) return [line];
+  if (line.length <= maxWidth) return [line];
+
+  const chunks: string[] = [];
+  let i = 0;
+  while (i < line.length) {
+    chunks.push(line.slice(i, i + maxWidth));
+    i += maxWidth;
+  }
+  return chunks;
+}
+
+function reflowParagraphs(text: string): string {
+  const rawLines = text.split('\n');
+  const result: string[] = [];
+  let inCodeBlock = false;
+
+  for (let i = 0; i < rawLines.length; i++) {
+    const line = rawLines[i]!;
+
+    if (/^```/.test(line)) {
+      inCodeBlock = !inCodeBlock;
+      result.push(line);
+      continue;
+    }
+
+    if (inCodeBlock) {
+      result.push(line);
+      continue;
+    }
+
+    if (line.trim() === '') {
+      result.push(line);
+      continue;
+    }
+
+    if (/^#{1,6}\s/.test(line) || /^[-*+]\s/.test(line) || /^\d+\.\s/.test(line)) {
+      result.push(line);
+      continue;
+    }
+
+    const prev = result.length > 0 ? result[result.length - 1]! : '';
+    const prevIsText = prev.trim() !== '' &&
+      !/^```/.test(prev) &&
+      !/^#{1,6}\s/.test(prev) &&
+      !/^[-*+]\s/.test(prev) &&
+      !/^\d+\.\s/.test(prev);
+
+    if (prevIsText) {
+      result[result.length - 1] = prev + ' ' + line;
     } else {
-      const needsSpace = !currentLine.endsWith(' ') && !fullText.startsWith(' ');
-      const separator = needsSpace ? ' ' : '';
+      result.push(line);
+    }
+  }
 
-      if ((currentLine + separator + fullText).length <= maxWidth) {
-        currentLine += separator + fullText;
-        currentSegments.push(segment);
+  return result.join('\n');
+}
+
+export function parseAndWrapMarkdown(text: string, maxWidth: number): WrappedMarkdownBlock[] {
+  const lines = reflowParagraphs(text).split('\n');
+  const blocks: WrappedMarkdownBlock[] = [];
+  let inCodeBlock = false;
+  let codeLines: string[] = [];
+  let language: string | undefined;
+
+  for (const line of lines) {
+    const fenceMatch = line.match(/^```([A-Za-z0-9_-]+)?\s*$/);
+    if (fenceMatch) {
+      if (!inCodeBlock) {
+        inCodeBlock = true;
+        language = fenceMatch[1];
+        codeLines = [];
       } else {
-        lines.push({ text: currentLine, segments: currentSegments });
-        currentLine = fullText;
-        currentSegments = [segment];
-
-        if (fullText.length > maxWidth) {
-          let remaining = content;
-          while (remaining) {
-            if (remaining.length <= maxWidth) {
-              currentLine = remaining;
-              currentSegments = [{ ...segment, content: remaining }];
-              remaining = '';
-            } else {
-              const breakPoint = remaining.lastIndexOf(' ', maxWidth);
-              if (breakPoint > 0) {
-                const chunk = remaining.slice(0, breakPoint);
-                currentLine = chunk;
-                currentSegments = [{ ...segment, content: chunk }];
-                lines.push({ text: currentLine, segments: currentSegments });
-                currentLine = '';
-                currentSegments = [];
-                remaining = remaining.slice(breakPoint + 1);
-              } else {
-                const chunk = remaining.slice(0, maxWidth);
-                currentLine = chunk;
-                currentSegments = [{ ...segment, content: chunk }];
-                lines.push({ text: currentLine, segments: currentSegments });
-                currentLine = '';
-                currentSegments = [];
-                remaining = remaining.slice(maxWidth);
-              }
-            }
-          }
-        }
+        const wrapped = codeLines.flatMap(codeLine => wrapCodeLine(codeLine, maxWidth));
+        blocks.push({ type: 'code', codeLines: wrapped, language });
+        inCodeBlock = false;
+        codeLines = [];
+        language = undefined;
       }
+      continue;
+    }
+
+    if (inCodeBlock) {
+      codeLines.push(line);
+      continue;
     }
-  }
 
-  if (currentLine) {
-    lines.push({ text: currentLine, segments: currentSegments });
+    blocks.push({
+      type: 'line',
+      wrappedLines: wrapMarkdownText(line, maxWidth)
+    });
   }
 
-  return lines.length > 0 ? lines : [{ text: '', segments: [] }];
-}
+  if (inCodeBlock) {
+    const wrapped = codeLines.flatMap(codeLine => wrapCodeLine(codeLine, maxWidth));
+    blocks.push({ type: 'code', codeLines: wrapped, language });
+  }
 
-export interface WrappedMarkdownBlock {
-  type: 'line';
-  wrappedLines?: { text: string; segments: MarkdownSegment[] }[];
+  return blocks;
 }
-
-export function parseAndWrapMarkdown(text: string, maxWidth: number): WrappedMarkdownBlock[] {
-  const lines = text.split('\n');
-  return lines.map((line) => ({
-    type: 'line',
-    wrappedLines: wrapMarkdownText(line, maxWidth)
-  }));
-}

package/src/utils/models.ts

@@ -286,12 +286,34 @@ export async function findModelsDevModelById(
     return modelsDev.getModelById(modelId, options);
 }
 
-export async function searchModelsDev(query: ModelsDevSearchQuery, options: { refresh?: boolean } = {}): Promise<ModelsDevSearchResult[]> {
-    return modelsDev.search(query, options);
-}
-
-export function modelAcceptsImages(model: ModelsDevModel): boolean {
-    if (!model.modalities) return false;
-    const { input } = model.modalities;
-    return Array.isArray(input) && input.includes("image");
-}
+export async function searchModelsDev(query: ModelsDevSearchQuery, options: { refresh?: boolean } = {}): Promise<ModelsDevSearchResult[]> {
+    return modelsDev.search(query, options);
+}
+
+export async function getModelsDevContextLimit(
+    providerId: string,
+    modelId: string,
+    options: { refresh?: boolean } = {}
+): Promise<number | null> {
+    try {
+        const direct = await getModelsDevModel(providerId, modelId, options);
+        const limit = direct?.limit?.context;
+        if (typeof limit === "number" && Number.isFinite(limit) && limit > 0) return limit;
+    } catch {
+    }
+
+    try {
+        const byId = await findModelsDevModelById(modelId, options);
+        const limit = byId?.model?.limit?.context;
+        if (typeof limit === "number" && Number.isFinite(limit) && limit > 0) return limit;
+    } catch {
+    }
+
+    return null;
+}
+
+export function modelAcceptsImages(model: ModelsDevModel): boolean {
+    if (!model.modalities) return false;
+    const { input } = model.modalities;
+    return Array.isArray(input) && input.includes("image");
+}

package/src/utils/questionBridge.ts

@@ -1,12 +1,15 @@
 export interface QuestionOption {
   label: string;
   value?: string | null;
+  group?: string;
 }
 
 export interface QuestionRequest {
   id: string;
   prompt: string;
   options: QuestionOption[];
+  timeout?: number;
+  validation?: { pattern: string; message?: string };
 }
 
 export interface QuestionAnswer {
@@ -23,6 +26,7 @@ let currentRequest: QuestionRequest | null = null;
 let listeners = new Set<QuestionListener>();
 let pendingResolve: ((answer: QuestionAnswer) => void) | null = null;
 let pendingReject: ((reason?: any) => void) | null = null;
+let pendingTimeoutId: ReturnType<typeof setTimeout> | null = null;
 
 function notify(): void {
   for (const listener of listeners) {
@@ -46,7 +50,12 @@ export function getCurrentQuestion(): QuestionRequest | null {
   return currentRequest;
 }
 
-export async function askQuestion(prompt: string, options: QuestionOption[]): Promise<QuestionAnswer> {
+export async function askQuestion(
+  prompt: string,
+  options: QuestionOption[],
+  timeout?: number,
+  validation?: { pattern: string; message?: string },
+): Promise<QuestionAnswer> {
   if (pendingResolve) {
     throw new Error('A question is already pending');
   }
@@ -63,6 +72,8 @@ export async function askQuestion(prompt: string, options: QuestionOption[]): Pr
     id: createId(),
     prompt,
     options,
+    ...(timeout !== undefined && { timeout }),
+    ...(validation !== undefined && { validation }),
   };
 
   currentRequest = request;
@@ -71,6 +82,20 @@ export async function askQuestion(prompt: string, options: QuestionOption[]): Pr
   const answer = await new Promise<QuestionAnswer>((resolve, reject) => {
     pendingResolve = resolve;
     pendingReject = reject;
+
+    if (timeout !== undefined && timeout > 0) {
+      pendingTimeoutId = setTimeout(() => {
+        pendingTimeoutId = null;
+        if (pendingReject) {
+          const rej = pendingReject;
+          pendingResolve = null;
+          pendingReject = null;
+          currentRequest = null;
+          notify();
+          rej(new Error(`Question timed out after ${timeout}s`));
+        }
+      }, timeout * 1000);
+    }
   });
 
   return answer;
@@ -101,6 +126,11 @@ export function answerQuestion(index: number, customText?: string): void {
 
   if (!answer) return;
 
+  if (pendingTimeoutId !== null) {
+    clearTimeout(pendingTimeoutId);
+    pendingTimeoutId = null;
+  }
+
   const resolve = pendingResolve;
   pendingResolve = null;
   pendingReject = null;
@@ -112,6 +142,11 @@ export function answerQuestion(index: number, customText?: string): void {
 export function cancelQuestion(): void {
   if (!currentRequest || !pendingReject) return;
 
+  if (pendingTimeoutId !== null) {
+    clearTimeout(pendingTimeoutId);
+    pendingTimeoutId = null;
+  }
+
   const reject = pendingReject;
   pendingResolve = null;
   pendingReject = null;

package/src/utils/tokenEstimator.ts

@@ -0,0 +1,32 @@
+const CODE_CHARS = /[{}()\[\]=<>:;]/g;
+const CODE_DENSITY_THRESHOLD = 0.04;
+
+export function estimateTokensFromText(text: string): number {
+  if (!text) return 0;
+  const matches = text.match(CODE_CHARS);
+  const density = matches ? matches.length / text.length : 0;
+  const ratio = density >= CODE_DENSITY_THRESHOLD ? 2.8 : 3.3;
+  return Math.ceil(text.length / ratio);
+}
+
+export function estimateTokensForContent(content: string, thinkingContent?: string): number {
+  const contentTokens = estimateTokensFromText(content);
+  const thinkingTokens = thinkingContent ? estimateTokensFromText(thinkingContent) : 0;
+  return contentTokens + thinkingTokens + 4;
+}
+
+const CONTEXT_BUDGETS: Record<string, number> = {
+  anthropic: 180000,
+  openai: 115000,
+  google: 900000,
+  mistral: 28000,
+  xai: 117000,
+  ollama: 7000,
+};
+
+const DEFAULT_BUDGET = 12000;
+
+export function getDefaultContextBudget(provider?: string): number {
+  if (!provider) return DEFAULT_BUDGET;
+  return CONTEXT_BUDGETS[provider] ?? DEFAULT_BUDGET;
+}