savant-code 0.0.19 → 0.0.20

package/common/src/util/lru-cache.ts

@@ -1,67 +0,0 @@
-/**
- * A simple Least Recently Used (LRU) cache implementation using a Map.
- * It leverages the fact that Map objects maintain insertion order.
- */
-export class LRUCache<K, V> {
-  private cache = new Map<K, V>()
-
-  constructor(private maxSize: number) {
-    if (maxSize <= 0) {
-      throw new Error('LRUCache maxSize must be a positive number.')
-    }
-  }
-
-  /**
-   * Retrieves an item from the cache. If found, marks it as recently used.
-   * @param key The key of the item to retrieve.
-   * @returns The value associated with the key, or undefined if not found.
-   */
-  get(key: K): V | undefined {
-    const value = this.cache.get(key)
-    if (value !== undefined) {
-      // Mark as recently used by deleting and re-setting
-      this.cache.delete(key)
-      this.cache.set(key, value)
-      return value
-    }
-    return undefined
-  }
-
-  /**
-   * Adds or updates an item in the cache. If the cache exceeds maxSize,
-   * the least recently used item is evicted.
-   * @param key The key of the item to set.
-   * @param value The value to associate with the key.
-   */
-  set(key: K, value: V): void {
-    // If key already exists, delete it first to update its position
-    if (this.cache.has(key)) {
-      this.cache.delete(key)
-    }
-    // Check if cache is full before adding the new item
-    else if (this.cache.size >= this.maxSize) {
-      // Evict the least recently used item (the first item in the Map's iteration order)
-      const oldestKey = this.cache.keys().next().value
-      if (oldestKey !== undefined) {
-        // Should always be defined if size >= maxSize > 0
-        this.cache.delete(oldestKey)
-      }
-    }
-    // Add the new item (or re-add the updated item)
-    this.cache.set(key, value)
-  }
-
-  /**
-   * Returns the current number of items in the cache.
-   */
-  get size(): number {
-    return this.cache.size
-  }
-
-  /**
-   * Clears all items from the cache.
-   */
-  clear(): void {
-    this.cache.clear()
-  }
-}

package/common/src/util/messages.ts

@@ -1,600 +0,0 @@
-import { modelMessageSchema } from 'ai'
-import { cloneDeep, has, isEqual } from 'lodash'
-
-import type { Logger } from '../types/contracts/logger'
-import type { JSONValue } from '../types/json'
-import type { TextPart, ToolResultOutput } from '../types/messages/content-part'
-import type { ProviderMetadata } from '../types/messages/provider-metadata'
-import type {
-  AssistantMessage,
-  AuxiliaryMessageData,
-  Message,
-  SystemMessage,
-  ToolMessage,
-  UserMessage,
-} from '../types/messages/savant-code-message'
-import type {
-  AssistantModelMessage,
-  ModelMessage,
-  SystemModelMessage,
-  ToolModelMessage,
-  UserModelMessage,
-} from 'ai'
-
-export function toContentString(msg: ModelMessage): string {
-  const { content } = msg
-  if (typeof content === 'string') return content
-  return content
-    .map((item) =>
-      item && 'text' in item && typeof item.text === 'string' ? item.text : '',
-    )
-    .join('\n')
-}
-
-export function withCacheControl<
-  T extends { providerOptions?: ProviderMetadata },
->(obj: T): T {
-  const wrapper = cloneDeep(obj)
-  if (!wrapper.providerOptions) {
-    wrapper.providerOptions = {}
-  }
-
-  /* 'savant-code' provider name is not compatible with providerMetadata for
-   * messages, so we need to use 'openaiCompatible' instead.
-   * https://github.com/vercel/ai/blob/8e4fdac31b4f8c6a8d07a606a8833e74adf99470/packages/openai-compatible/src/chat/convert-to-openai-compatible-chat-messages.ts#L9
-   */
-  for (const provider of [
-    'anthropic',
-    'openrouter',
-    'openaiCompatible',
-  ] as const) {
-    if (!wrapper.providerOptions[provider]) {
-      wrapper.providerOptions[provider] = {}
-    }
-    wrapper.providerOptions[provider].cache_control = { type: 'ephemeral' }
-  }
-
-  return wrapper
-}
-
-export function withoutCacheControl<
-  T extends { providerOptions?: ProviderMetadata },
->(obj: T): T {
-  const wrapper = cloneDeep(obj)
-
-  for (const provider of [
-    'anthropic',
-    'openrouter',
-    'openaiCompatible',
-  ] as const) {
-    if (has(wrapper.providerOptions?.[provider]?.cache_control, 'type')) {
-      delete wrapper.providerOptions?.[provider]?.cache_control?.type
-    }
-    if (
-      Object.keys(wrapper.providerOptions?.[provider]?.cache_control ?? {})
-        .length === 0
-    ) {
-      delete wrapper.providerOptions?.[provider]?.cache_control
-    }
-    if (Object.keys(wrapper.providerOptions?.[provider] ?? {}).length === 0) {
-      delete wrapper.providerOptions?.[provider]
-    }
-  }
-
-  if (Object.keys(wrapper.providerOptions ?? {}).length === 0) {
-    delete wrapper.providerOptions
-  }
-
-  return wrapper
-}
-
-type NonStringContent<T extends { content: string | readonly object[] }> = Omit<
-  T,
-  'content'
-> & {
-  content: Exclude<T['content'], string>
-}
-export type SavantModelMessage = (
-  | SystemModelMessage
-  | NonStringContent<UserModelMessage>
-  | NonStringContent<AssistantModelMessage>
-  | ToolModelMessage
-) &
-  AuxiliaryMessageData
-
-function textPartFromString(text: string): TextPart {
-  return { type: 'text', text }
-}
-
-function assistantToSavantCodeMessage(
-  message: Omit<AssistantMessage, 'content'> & {
-    content: Exclude<AssistantMessage['content'], string>[number]
-  },
-): AssistantMessage {
-  // if (message.content.type === 'tool-call') {
-  //   return cloneDeep({
-  //     ...message,
-  //     content: [
-  //       {
-  //         type: 'text',
-  //         text: getToolCallString(
-  //           message.content.toolName,
-  //           message.content.input,
-  //           false,
-  //         ),
-  //       },
-  //     ],
-  //   })
-  // }
-  return cloneDeep({ ...message, content: [message.content] })
-}
-
-function convertToolResultMessage(message: ToolMessage): SavantModelMessage[] {
-  // Defensive: some compaction paths historically wrote a bare string here.
-  // Coerce any non-array content into a json tool result so downstream code
-  // can safely call .map() and the AI SDK receives a valid tool-result shape.
-  if (!Array.isArray(message.content)) {
-    message = {
-      ...message,
-      content: [
-        {
-          type: 'json',
-          value: message.content as JSONValue,
-        } as ToolResultOutput,
-      ],
-    }
-  }
-
-  if (message.content.length === 0) {
-    return [
-      cloneDeep<ToolModelMessage>({
-        ...message,
-        role: 'tool',
-        content: [
-          {
-            ...message,
-            output: { type: 'json', value: '' },
-            type: 'tool-result',
-          },
-        ],
-      }),
-    ]
-  }
-  return message.content.map((c) => {
-    if (c.type === 'json') {
-      return cloneDeep<ToolModelMessage>({
-        ...message,
-        role: 'tool',
-        content: [{ ...message, output: c, type: 'tool-result' }],
-      })
-    }
-    if (c.type === 'media') {
-      return cloneDeep<UserMessage>({
-        ...message,
-        role: 'user',
-        content: [{ type: 'file', data: c.data, mediaType: c.mediaType }],
-      })
-    }
-    c satisfies never
-    throw new Error(`Invalid tool output type: ${JSON.stringify(c)}`)
-  })
-}
-
-function convertToolMessage(message: Message): SavantModelMessage[] {
-  if (message.role === 'system') {
-    // Defensive: older serialized state may store system content as a plain
-    // string instead of TextPart[]. Treat any non-array as the literal text.
-    const content = message.content as unknown as string | TextPart[]
-    let textContent: string
-    if (Array.isArray(content)) {
-      textContent = content
-        .map((c) => (c && 'text' in c ? c.text : ''))
-        .join('\n\n')
-    } else if (typeof content === 'string') {
-      textContent = content
-    } else {
-      textContent = ''
-    }
-    return [
-      {
-        ...message,
-        content: textContent,
-      },
-    ]
-  }
-  if (message.role === 'user') {
-    // Defensive: older serialized state may store user content as a plain
-    // string. Wrap it as a TextPart[] so downstream code always sees an array.
-    const content = message.content as unknown as
-      string | UserMessage['content']
-    if (typeof content === 'string') {
-      return [
-        cloneDeep({
-          ...message,
-          content: [textPartFromString(content)],
-        }),
-      ]
-    }
-    if (!Array.isArray(content)) {
-      return [
-        cloneDeep({
-          ...message,
-          content: [],
-        }),
-      ]
-    }
-    return [cloneDeep(message)]
-  }
-  if (message.role === 'assistant') {
-    // Defensive: older serialized state may store assistant content as a plain
-    // string (or invalid value). Wrap it as a TextPart[] before iterating.
-    const content = message.content as unknown as
-      string | AssistantMessage['content']
-    if (!Array.isArray(content)) {
-      const text = typeof content === 'string' ? content : ''
-      return [
-        cloneDeep({
-          ...message,
-          content: [textPartFromString(text)],
-        }),
-      ]
-    }
-    return content.map((c) => {
-      return assistantToSavantCodeMessage({
-        ...message,
-        content: c,
-      })
-    })
-  }
-  if (message.role === 'tool') {
-    return convertToolResultMessage(message)
-  }
-  message satisfies never
-  throw new Error(
-    `Invalid message role: ${(message as { role: unknown }).role}`,
-  )
-}
-
-function convertToolMessages(messages: Message[]): SavantModelMessage[] {
-  const withoutToolMessages: SavantModelMessage[] = []
-  for (const message of messages) {
-    withoutToolMessages.push(...convertToolMessage(message))
-  }
-  return withoutToolMessages
-}
-
-/**
- * Recursively replace any lone (unpaired) UTF-16 surrogate with U+FFFD in every
- * string reachable from `value`, mutating objects/arrays in place.
- *
- * Why this exists: unsafe truncation (e.g. slicing a file read or terminal
- * output in the middle of an emoji / astral-plane character) can leave a lone
- * surrogate in message content. JS's `JSON.stringify` is "well-formed" and emits
- * it as a syntactically-valid `\uXXXX` escape, and JS's `JSON.parse` is lenient
- * and accepts it, so the corruption slips through every client-side check. But
- * strict server-side parsers — notably Rust's serde_json, used by
- * OpenAI/OpenRouter/Anthropic — reject the whole request body with
- * "unexpected end of hex escape". Once such content lands in the message
- * history, EVERY subsequent provider request fails fatally and the agent stops,
- * even though nothing is wrong with the current turn's tool call.
- *
- * Sanitizing here, at the single chokepoint where all messages are converted to
- * provider format, guarantees a single bad character can never poison the
- * conversation regardless of which tool produced it. It is a no-op on
- * already-valid strings, so valid emoji, base64, etc. are untouched.
- *
- * (Equivalent to `String.prototype.toWellFormed()`, implemented as a regex so we
- * don't need to widen the project's TS lib to ES2024.)
- */
-const LONE_SURROGATE_REGEX =
-  /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g
-
-function toWellFormedString(str: string): string {
-  return str.replace(LONE_SURROGATE_REGEX, '�')
-}
-
-// FID-2026-0803-003 CMN-8: mirror deepParseJson's depth cap so a deeply nested
-// message payload cannot overflow the stack.
-const MAX_WELL_FORM_DEPTH = 100
-
-function wellFormStringsInPlace(value: object, depth = 0): void {
-  // Arrays and plain objects are both handled here: Object.keys enumerates array
-  // indices too, and indexing by string key mutates the element in place.
-  // ECHO Law 6 trust-boundary: validate object shape (already enforced by `: object`
-  // signature) + null check + recursive object-only descent.
-  if (depth > MAX_WELL_FORM_DEPTH) return
-  const obj = value as Record<string, JSONValue>
-  for (const key of Object.keys(obj)) {
-    const item = obj[key]
-    if (typeof item === 'string') {
-      obj[key] = toWellFormedString(item)
-    } else if (item && typeof item === 'object') {
-      wellFormStringsInPlace(item, depth + 1)
-    }
-  }
-}
-
-export function convertCbToModelMessages({
-  messages,
-  includeCacheControl = true,
-  logger,
-}: {
-  messages: Message[]
-  includeCacheControl?: boolean
-  logger?: Logger
-}): SavantModelMessage[] {
-  const toolMessagesConverted: SavantModelMessage[] =
-    convertToolMessages(messages)
-
-  const aggregated: SavantModelMessage[] = []
-  for (const message of toolMessagesConverted) {
-    if (aggregated.length === 0) {
-      aggregated.push(message)
-      continue
-    }
-
-    const lastMessage = aggregated[aggregated.length - 1]
-    if (
-      lastMessage.timeToLive !== message.timeToLive ||
-      !isEqual(lastMessage.providerOptions, message.providerOptions) ||
-      !isEqual(lastMessage.tags, message.tags)
-    ) {
-      aggregated.push(message)
-      continue
-    }
-    if (lastMessage.role === 'system' && message.role === 'system') {
-      lastMessage.content += '\n\n' + message.content
-      continue
-    }
-    if (lastMessage.role === 'user' && message.role === 'user') {
-      lastMessage.content.push(...message.content)
-      continue
-    }
-    if (lastMessage.role === 'assistant' && message.role === 'assistant') {
-      lastMessage.content.push(...message.content)
-      continue
-    }
-
-    aggregated.push(message)
-  }
-
-  // Neutralize any lone UTF-16 surrogates before the messages reach the provider.
-  // These are mutated in place; every aggregated message is a fresh clone (see
-  // convertToolMessage), so the caller's message history is unaffected.
-  for (const message of aggregated) {
-    if (typeof message.content === 'string') {
-      message.content = toWellFormedString(message.content)
-    } else if (message.content && typeof message.content === 'object') {
-      wellFormStringsInPlace(message.content)
-    }
-  }
-
-  if (!includeCacheControl) {
-    return aggregated
-  }
-
-  // Add cache control to specific messages (max of 4 can be marked for caching!):
-  // - The message right before the three tagged messages
-  // - Last message
-  for (const tag of [
-    'LAST_ASSISTANT_MESSAGE',
-    'USER_PROMPT',
-    'STEP_PROMPT',
-    undefined, // Last message
-  ] as const) {
-    let index =
-      tag === 'LAST_ASSISTANT_MESSAGE'
-        ? aggregated.findLastIndex((m) => m.role === 'assistant')
-        : tag
-          ? aggregated.findLastIndex((m) => m.tags?.includes(tag))
-          : aggregated.length
-    if (index <= 0) {
-      continue
-    }
-
-    // Iterate to find the last "valid" message that we can cache control
-    let prevMessage: (typeof aggregated)[number]
-    let contentBlock: (typeof prevMessage)['content']
-    addCacheControlLoop: while (true) {
-      index--
-
-      // No message found
-      if (index < 0) {
-        break
-      }
-
-      prevMessage = aggregated[index]
-      contentBlock = prevMessage.content
-
-      if (typeof contentBlock === 'string') {
-        // This must be a system message
-        aggregated[index] = withCacheControl(aggregated[index])
-        break
-      }
-
-      // Iterate to find the last valid content part (not a very short string)
-      let lastContentIndex = contentBlock.length
-      let lastContentPart: (typeof contentBlock)[number]
-      while (true) {
-        lastContentIndex--
-        lastContentPart = contentBlock[lastContentIndex]
-
-        if (lastContentIndex < 0) {
-          // Continue searching in next message
-          break
-        }
-
-        if (lastContentPart.type !== 'text') {
-          contentBlock[lastContentIndex] = withCacheControl(
-            contentBlock[lastContentIndex],
-          )
-          break addCacheControlLoop
-        }
-
-        prevMessage.content = [
-          ...contentBlock.slice(0, lastContentIndex),
-          withCacheControl(lastContentPart),
-          ...contentBlock.slice(lastContentIndex + 1),
-        ] as typeof contentBlock
-
-        break addCacheControlLoop
-      }
-      break
-    }
-  }
-
-  // Validate each message against the AI SDK schema
-  for (let i = 0; i < aggregated.length; i++) {
-    const message = aggregated[i]
-    const result = modelMessageSchema.safeParse(message)
-    if (!result.success) {
-      if (logger) {
-        logger.error(
-          { message, aggregated, error: result.error },
-          `convertCbToModelMessages: Message at index ${i} failed schema validation.`,
-        )
-      }
-      throw new Error(
-        `convertCbToModelMessages: Message at index ${i} failed schema validation.\n` +
-          `Role: ${message.role}\n` +
-          `Message:\n${result.error.message}`,
-      )
-    }
-  }
-
-  return aggregated
-}
-
-// type NoContent<T> = T & { content?: never }
-export type SystemContent =
-  string | SystemMessage['content'][number] | SystemMessage['content']
-export function systemContent(
-  content: SystemContent,
-): SystemMessage['content'] {
-  if (typeof content === 'string') {
-    return [{ type: 'text', text: content }]
-  }
-  if (Array.isArray(content)) {
-    return content
-  }
-  return [content]
-}
-
-export function systemMessage(
-  params:
-    | SystemContent
-    | ({
-        content: SystemContent
-      } & Omit<SystemMessage, 'role' | 'content'>),
-): SystemMessage {
-  if (typeof params === 'object' && 'content' in params) {
-    return {
-      ...params,
-      role: 'system',
-      content: systemContent(params.content),
-    }
-  }
-  return {
-    role: 'system',
-    content: systemContent(params),
-  }
-}
-
-export type UserContent =
-  string | UserMessage['content'][number] | UserMessage['content']
-export function userContent(content: UserContent): UserMessage['content'] {
-  if (typeof content === 'string') {
-    return [{ type: 'text', text: content }]
-  }
-  if (Array.isArray(content)) {
-    return content
-  }
-  return [content]
-}
-
-export function userMessage(
-  params:
-    | UserContent
-    | ({
-        content: UserContent
-      } & Omit<UserMessage, 'role' | 'content'>),
-): UserMessage {
-  if (typeof params === 'object' && 'content' in params) {
-    return {
-      ...params,
-      role: 'user',
-      content: userContent(params.content),
-      sentAt: Date.now(),
-    }
-  }
-  return {
-    role: 'user',
-    content: userContent(params),
-    sentAt: Date.now(),
-  }
-}
-
-export type AssistantContent =
-  string | AssistantMessage['content'][number] | AssistantMessage['content']
-export function assistantContent(
-  content: AssistantContent,
-): AssistantMessage['content'] {
-  if (typeof content === 'string') {
-    return [{ type: 'text', text: content }]
-  }
-  if (Array.isArray(content)) {
-    return content
-  }
-  return [content]
-}
-
-export function assistantMessage(
-  params:
-    | AssistantContent
-    | ({
-        content: AssistantContent
-      } & Omit<AssistantMessage, 'role' | 'content'>),
-): AssistantMessage {
-  if (typeof params === 'object' && 'content' in params) {
-    return {
-      ...params,
-      role: 'assistant',
-      content: assistantContent(params.content),
-      sentAt: Date.now(),
-    }
-  }
-  return {
-    role: 'assistant',
-    content: assistantContent(params),
-    sentAt: Date.now(),
-  }
-}
-
-export function jsonToolResult<T extends JSONValue>(
-  value: T,
-): [
-  Extract<ToolResultOutput, { type: 'json' }> & {
-    value: T
-  },
-] {
-  return [
-    {
-      type: 'json',
-      value,
-    },
-  ]
-}
-
-export function mediaToolResult(params: {
-  data: string
-  mediaType: string
-}): [Extract<ToolResultOutput, { type: 'media' }>] {
-  const { data, mediaType } = params
-  return [
-    {
-      type: 'media',
-      data,
-      mediaType,
-    },
-  ]
-}

package/common/src/util/model-utils.ts

@@ -1,25 +0,0 @@
-import type { Model } from '../old-constants'
-
-// Cache the explicitly defined models for O(1) lookup performance
-// Cast to string[] to avoid TypeScript union type issues with (string & {})
-let explicitlyDefinedModels: Set<string> | null = null
-
-function getExplicitlyDefinedModels(): Set<string> {
-  if (explicitlyDefinedModels === null) {
-    // NOTE: Inline require() avoids circular dependency - old-constants imports this
-    // module, so a top-level import would create a circular reference
-    const { models } = require('../old-constants')
-    explicitlyDefinedModels = new Set(Object.values(models) as string[])
-  }
-  return explicitlyDefinedModels
-}
-
-/**
- * Check if a model is explicitly defined in the models constant object.
- * This is used to determine if a model should allow fallbacks or support cache control.
- * @param model - The model to check
- * @returns boolean - True if the model is explicitly defined, false otherwise
- */
-export function isExplicitlyDefinedModel(model: Model): boolean {
-  return getExplicitlyDefinedModels().has(model as string)
-}