@goodandready/dsh-subscriptions 0.6.27 → 0.6.28

package/lib/gemini-schema.js

@@ -1,3 +1,4 @@
+import { normalizeTools } from './tools-normalizer.js'
 const TYPE_MAP = {
   string: 'string',
   number: 'number',
@@ -33,7 +34,7 @@ export function toGeminiSchema(schema, depth) {
     else type = 'string'
   }
   const out = { type }
-  if (typed && typed.nullable) out.nullable = true
+  if ((typed && typed.nullable) || schema.nullable === true) out.nullable = true
   if (schema.description) out.description = String(schema.description)
   if (type === 'object') {
     const props = schema.properties
@@ -65,10 +66,11 @@ export function toGeminiSchema(schema, depth) {
 }
 
 export function geminiFunctionDeclarations(tools) {
-  if (!Array.isArray(tools) || !tools.length) return undefined
-  return tools.map((tool) => ({
+  const norm = normalizeTools(tools)
+  if (!norm) return undefined
+  return norm.map((tool) => ({
     name: tool.name,
-    description: tool.description || '',
-    parameters: toGeminiSchema(tool.parameters || { type: 'object' }),
+    description: tool.description,
+    parameters: toGeminiSchema(tool.parameters),
   }))
 }

package/lib/images.js

@@ -109,3 +109,128 @@ export async function generateOnce(options) {
   }
   return parseImages(payload)
 }
+
+// Multimodal Payload Normalization for Vision Models
+export function parseDataUri(uri) {
+  if (typeof uri !== 'string') return null
+  const m = /^data:([a-zA-Z0-9.+/-]+);base64,(.+)$/.exec(uri.trim())
+  if (!m) return null
+  return { mimeType: m[1], base64: m[2] }
+}
+
+export function normalizeImage(item) {
+  if (!item) return null
+
+  // 1. Direct string (data URI or URL)
+  if (typeof item === 'string') {
+    const dataUri = parseDataUri(item)
+    if (dataUri) {
+      return { mimeType: dataUri.mimeType, base64: dataUri.base64, url: item.trim() }
+    }
+    if (/^https?:\/\//i.test(item.trim())) {
+      return { mimeType: 'image/jpeg', base64: null, url: item.trim() }
+    }
+    return null
+  }
+
+  if (typeof item !== 'object') return null
+
+  // 2. Anthropic style: { type: 'image', source: { type: 'base64', media_type, data } }
+  if (item.source && item.source.type === 'base64' && item.source.data) {
+    const mimeType = item.source.media_type || 'image/jpeg'
+    const base64 = item.source.data
+    return {
+      mimeType,
+      base64,
+      url: `data:${mimeType};base64,${base64}`,
+    }
+  }
+
+  // 3. Gemini style: { inlineData: { mimeType, data } }
+  if (item.inlineData && item.inlineData.data) {
+    const mimeType = item.inlineData.mimeType || 'image/jpeg'
+    const base64 = item.inlineData.data
+    return {
+      mimeType,
+      base64,
+      url: `data:${mimeType};base64,${base64}`,
+    }
+  }
+
+  // 4. OpenAI style: { type: 'image_url', image_url: { url } } or { type: 'image', image: '...' }
+  const rawUrl = (item.image_url && (item.image_url.url || item.image_url)) ||
+                 item.image || item.url
+
+  if (typeof rawUrl === 'string') {
+    const dataUri = parseDataUri(rawUrl)
+    if (dataUri) {
+      return { mimeType: dataUri.mimeType, base64: dataUri.base64, url: rawUrl.trim() }
+    }
+    if (/^https?:\/\//i.test(rawUrl.trim())) {
+      return { mimeType: 'image/jpeg', base64: null, url: rawUrl.trim() }
+    }
+  }
+
+  return null
+}
+
+export function extractImages(content) {
+  if (!Array.isArray(content)) {
+    const norm = normalizeImage(content)
+    return norm ? [norm] : []
+  }
+  const images = []
+  for (const block of content) {
+    if (!block) continue
+    if (typeof block === 'string') {
+      const norm = normalizeImage(block)
+      if (norm) images.push(norm)
+      continue
+    }
+    if (block.type === 'image' || block.type === 'image_url' || block.inlineData || block.image_url || block.image) {
+      const norm = normalizeImage(block)
+      if (norm) images.push(norm)
+    }
+  }
+  return images
+}
+
+export function toOpenAiImage(norm) {
+  const url = norm.url || (norm.base64 ? `data:${norm.mimeType};base64,${norm.base64}` : null)
+  if (!url) return null
+  return {
+    type: 'image_url',
+    image_url: { url },
+  }
+}
+
+export function toAnthropicImage(norm) {
+  if (!norm.base64) return null
+  return {
+    type: 'image',
+    source: {
+      type: 'base64',
+      media_type: norm.mimeType || 'image/jpeg',
+      data: norm.base64,
+    },
+  }
+}
+
+export function toGeminiImage(norm) {
+  if (!norm.base64) return null
+  return {
+    inlineData: {
+      mimeType: norm.mimeType || 'image/jpeg',
+      data: norm.base64,
+    },
+  }
+}
+
+export function toCodexImage(norm) {
+  const url = norm.url || (norm.base64 ? `data:${norm.mimeType};base64,${norm.base64}` : null)
+  if (!url) return null
+  return {
+    type: 'input_image',
+    image_url: url,
+  }
+}

package/lib/messages.js

@@ -1,3 +1,5 @@
+import { extractImages, toOpenAiImage, toAnthropicImage, toGeminiImage, toCodexImage } from './images.js'
+import { normalizeTools } from './tools-normalizer.js'
 import { geminiFunctionDeclarations } from './gemini-schema.js'
 
 function flattenText(content) {
@@ -64,7 +66,18 @@ export function openaiMessages(options) {
     }
     const results = toolResults(message.content)
     const text = flattenText(message.content)
-    if (text || !results.length) out.push({ role: 'user', content: text })
+    const images = extractImages(message.content)
+    if (images.length) {
+      const parts = []
+      if (text) parts.push({ type: 'text', text })
+      for (const img of images) {
+        const blk = toOpenAiImage(img)
+        if (blk) parts.push(blk)
+      }
+      out.push({ role: 'user', content: parts })
+    } else if (text || !results.length) {
+      out.push({ role: 'user', content: text })
+    }
     for (const result of results) {
       out.push({
         role: 'tool',
@@ -77,14 +90,14 @@ export function openaiMessages(options) {
 }
 
 export function openaiTools(options) {
-  const tools = options.tools
-  if (!Array.isArray(tools) || !tools.length) return undefined
+  const tools = normalizeTools(options && options.tools)
+  if (!tools) return undefined
   return tools.map((tool) => ({
     type: 'function',
     function: {
       name: tool.name,
-      description: tool.description || '',
-      parameters: tool.parameters || { type: 'object' },
+      description: tool.description,
+      parameters: tool.parameters,
     },
   }))
 }
@@ -147,6 +160,18 @@ export function reconcileResponsesInput(items) {
   return result
 }
 
+export function normalizeSystemPrefix(parts) {
+  if (!Array.isArray(parts)) return ""
+  return parts
+    .map((p) => {
+      if (!p) return ""
+      const s = typeof p === "string" ? p : (p.text || String(p))
+      return s.replace(/\r\n/g, "\n").trim()
+    })
+    .filter(Boolean)
+    .join("\n\n")
+}
+
 export function codexResponsesBody(options, fallbackInstructions, vendorCfg) {
   const systemParts = []
   if (options.system) systemParts.push(options.system)
@@ -215,6 +240,15 @@ export function codexResponsesBody(options, fallbackInstructions, vendorCfg) {
     const results = toolResults(message.content)
     const text = flattenText(message.content)
     if (text) addText('user', text)
+    const images = extractImages(message.content)
+    for (const img of images) {
+      const blk = toCodexImage(img)
+      if (blk) {
+        if (pendingRole && pendingRole !== 'user') flush()
+        pendingRole = 'user'
+        pendingContent.push(blk)
+      }
+    }
     for (const result of results) {
       flush()
       const callId = String(result.toolCallId || result.tool_call_id || result.call_id || result.id || '')
@@ -239,7 +273,7 @@ export function codexResponsesBody(options, fallbackInstructions, vendorCfg) {
     description: tool.function.description,
     parameters: tool.function.parameters,
   }))
-  const instructions = systemParts.filter(Boolean).join('\n\n') || fallbackInstructions
+  const instructions = normalizeSystemPrefix(systemParts) || (fallbackInstructions ? fallbackInstructions.replace(/\r\n/g, "\n").trim() : undefined)
   return {
     model: options.model,
     stream: true,
@@ -265,77 +299,123 @@ export function anthropicPayload(options, extraSystem) {
   if (options.system) systemParts.push(options.system)
   const messages = []
   for (const message of options.messages || []) {
-    if (message.role === 'system') {
+    if (message.role === "system") {
       systemParts.push(flattenText(message.content))
       continue
     }
-    if (message.role === 'assistant') {
+    if (message.role === "assistant") {
       const blocks = []
       const text = flattenText(message.content)
-      if (text) blocks.push({ type: 'text', text })
+      if (text) blocks.push({ type: "text", text })
       const calls = [
         ...toolCalls(message.content),
         ...((message.tool_calls || message.toolCalls || []).map((c) => ({
           id: c.id || c.call_id,
           name: c.name || (c.function && c.function.name),
-          arguments: c.arguments || (c.function && c.function.arguments) || '{}',
+          arguments: c.arguments || (c.function && c.function.arguments) || "{}",
         }))),
       ]
       for (const call of calls) {
         if (!call.id) continue
         blocks.push({
-          type: 'tool_use',
+          type: "tool_use",
           id: call.id,
           name: call.name,
           input: safeJson(call.arguments),
         })
       }
-      messages.push({ role: 'assistant', content: blocks.length ? blocks : [{ type: 'text', text: '' }] })
+      messages.push({ role: "assistant", content: blocks.length ? blocks : [{ type: "text", text: "" }] })
       continue
     }
-    if (message.role === 'tool') {
-      const toolUseId = String(message.toolCallId || message.tool_call_id || message.tool_use_id || message.id || '')
-      const content = typeof message.content === 'string'
+    if (message.role === "tool") {
+      const toolUseId = String(message.toolCallId || message.tool_call_id || message.tool_use_id || message.id || "")
+      const content = typeof message.content === "string"
         ? message.content
-        : (flattenText(message.content) || JSON.stringify(message.content || ''))
+        : (flattenText(message.content) || JSON.stringify(message.content || ""))
       messages.push({
-        role: 'user',
+        role: "user",
         content: [{
-          type: 'tool_result',
+          type: "tool_result",
           tool_use_id: toolUseId,
-          content: content || '',
+          content: content || "",
         }],
       })
       continue
     }
     const blocks = []
     const text = flattenText(message.content)
-    if (text) blocks.push({ type: 'text', text })
+    if (text) blocks.push({ type: "text", text })
+    const images = extractImages(message.content)
+    for (const img of images) {
+      const blk = toAnthropicImage(img)
+      if (blk) blocks.push(blk)
+    }
     for (const result of toolResults(message.content)) {
-      const toolUseId = String(result.toolCallId || result.tool_call_id || result.tool_use_id || result.id || '')
-      const content = typeof result.content === 'string'
+      const toolUseId = String(result.toolCallId || result.tool_call_id || result.tool_use_id || result.id || "")
+      const content = typeof result.content === "string"
         ? result.content
-        : (flattenText(result.content) || (result.output != null ? (typeof result.output === 'string' ? result.output : JSON.stringify(result.output)) : ''))
+        : (flattenText(result.content) || (result.output != null ? (typeof result.output === "string" ? result.output : JSON.stringify(result.output)) : ""))
       blocks.push({
-        type: 'tool_result',
+        type: "tool_result",
         tool_use_id: toolUseId,
-        content: content || '',
+        content: content || "",
       })
     }
-    messages.push({ role: 'user', content: blocks.length ? blocks : [{ type: 'text', text: '' }] })
+    messages.push({ role: "user", content: blocks.length ? blocks : [{ type: "text", text: "" }] })
   }
-  const tools = Array.isArray(options.tools)
-    ? options.tools.map((tool) => ({
-      name: tool.name,
-      description: tool.description || '',
-      input_schema: tool.parameters || { type: 'object' },
-    }))
+
+  const useCacheControl = options.cacheControl !== false
+  const systemText = normalizeSystemPrefix(systemParts)
+  let system
+  if (systemText) {
+    if (useCacheControl) {
+      system = [{ type: "text", text: systemText, cache_control: { type: "ephemeral" } }]
+    } else {
+      system = systemText
+    }
+  }
+
+  const normTools = normalizeTools(options.tools)
+  const tools = normTools
+    ? normTools.map((tool, idx) => {
+      const item = {
+        name: tool.name,
+        description: tool.description,
+        input_schema: tool.parameters,
+      }
+      if (useCacheControl && idx === normTools.length - 1) {
+        item.cache_control = { type: "ephemeral" }
+      }
+      return item
+    })
     : undefined
+
+  if (useCacheControl) {
+    const userTurnIndices = []
+    for (let i = 0; i < messages.length; i++) {
+      if (messages[i].role === "user") {
+        userTurnIndices.push(i)
+      }
+    }
+    if (userTurnIndices.length >= 2) {
+      const targetIdx = userTurnIndices[userTurnIndices.length - 2]
+      const targetMsg = messages[targetIdx]
+      if (Array.isArray(targetMsg.content) && targetMsg.content.length > 0) {
+        const lastBlockIdx = targetMsg.content.length - 1
+        const lastBlock = targetMsg.content[lastBlockIdx]
+        targetMsg.content[lastBlockIdx] = {
+          ...lastBlock,
+          cache_control: { type: "ephemeral" },
+        }
+      }
+    }
+  }
+
   return {
     model: options.model,
     max_tokens: options.maxTokens || 8192,
     stream: true,
-    ...(systemParts.length ? { system: systemParts.join('\n\n') } : {}),
+    ...(system ? { system } : {}),
     messages,
     ...(tools && tools.length ? { tools } : {}),
     ...(options.temperature != null ? { temperature: options.temperature } : {}),
@@ -371,6 +451,11 @@ export function googleContents(options) {
     const parts = []
     const text = flattenText(message.content)
     if (text) parts.push({ text })
+    const images = extractImages(message.content)
+    for (const img of images) {
+      const blk = toGeminiImage(img)
+      if (blk) parts.push(blk)
+    }
     const calls = [
       ...toolCalls(message.content),
       ...((message.tool_calls || message.toolCalls || []).map((c) => ({
@@ -400,7 +485,10 @@ export function googleContents(options) {
   const tools = declarations ? [{ functionDeclarations: declarations }] : undefined
   return {
     contents,
-    ...(systemParts.length ? { systemInstruction: { parts: systemParts } } : {}),
+    ...(() => {
+      const systemText = normalizeSystemPrefix(systemParts)
+      return systemText ? { systemInstruction: { parts: [{ text: systemText }] } } : {}
+    })(),
     ...(tools ? { tools } : {}),
     generationConfig: {
       ...(options.temperature != null ? { temperature: options.temperature } : {}),

package/lib/runaway-guard.js

@@ -0,0 +1,105 @@
+export class RunawayDetector {
+  constructor(options = {}) {
+    this.maxIdenticalConsecutive = options.maxIdenticalConsecutive || 30
+    this.maxPatternRepetitions = options.maxPatternRepetitions || 6
+    this.minPatternLength = options.minPatternLength || 4
+    this.maxPatternLength = options.maxPatternLength || 80
+    this.history = ''
+    this.lastChunk = null
+    this.identicalCount = 0
+    this.tripped = false
+    this.reason = null
+  }
+
+  feed(text) {
+    if (this.tripped || !text || typeof text !== 'string') return false
+
+    // 1. Check identical consecutive text chunks
+    if (this.lastChunk === text) {
+      this.identicalCount++
+      if (this.identicalCount >= this.maxIdenticalConsecutive) {
+        this.tripped = true
+        this.reason = `identical_chunk_loop (${this.identicalCount} repetitions of "${text.slice(0, 16)}")`
+        return true
+      }
+    } else {
+      this.lastChunk = text
+      this.identicalCount = 1
+    }
+
+    // 2. Sliding window n-gram repetition detection
+    const maxHistLen = this.maxPatternLength * this.maxPatternRepetitions + 128
+    this.history += text
+    if (this.history.length > maxHistLen * 2) {
+      this.history = this.history.slice(-maxHistLen)
+    }
+
+    const hLen = this.history.length
+    for (let pLen = this.minPatternLength; pLen <= this.maxPatternLength; pLen++) {
+      const requiredLen = pLen * this.maxPatternRepetitions
+      if (hLen < requiredLen) break
+
+      const pattern = this.history.slice(hLen - pLen)
+      let matches = 0
+      for (let i = 1; i < this.maxPatternRepetitions; i++) {
+        const seg = this.history.slice(hLen - (i + 1) * pLen, hLen - i * pLen)
+        if (seg === pattern) {
+          matches++
+        } else {
+          break
+        }
+      }
+      if (matches >= this.maxPatternRepetitions - 1) {
+        this.tripped = true
+        this.reason = `pattern_repetition_loop (${pLen} chars repeated ${this.maxPatternRepetitions} times: "${pattern.slice(0, 20)}...")`
+        return true
+      }
+    }
+
+    return false
+  }
+
+  isTripped() {
+    return this.tripped
+  }
+
+  getReason() {
+    return this.reason
+  }
+}
+
+export async function* withRunawayGuard(stream, options = {}) {
+  if (options && options.enabled === false) {
+    yield* stream
+    return
+  }
+
+  const detector = new RunawayDetector(options)
+
+  for await (const chunk of stream) {
+    if (chunk && chunk.type === 'finish') {
+      yield chunk
+      return
+    }
+
+    const text = (chunk && typeof chunk === 'object')
+      ? (typeof chunk.text === 'string' ? chunk.text : null)
+      : null
+
+    if (text && (chunk.type === 'text-delta' || chunk.type === 'reasoning-delta' || !chunk.type)) {
+      if (detector.feed(text)) {
+        yield {
+          type: 'finish',
+          reason: {
+            kind: 'stop',
+            message: 'runaway_loop_detected',
+            detail: detector.getReason(),
+          },
+        }
+        return
+      }
+    }
+
+    yield chunk
+  }
+}

package/lib/stream-rotate.js

@@ -1,5 +1,6 @@
 import { pickAccount, markCooldown, isSwitchableError, isRegionError, modelFamily } from './rotate.js'
 import { putInQuarantine, REASON_RATE_LIMIT, REASON_HARD_LIMIT, REASON_REVOKED } from './quarantine.js'
+import { withRunawayGuard } from './runaway-guard.js'
 
 export async function* streamWithRotation({
   accounts,
@@ -49,7 +50,8 @@ export async function* streamWithRotation({
 
     while (true) {
       try {
-        for await (const chunk of streamOnce(account, options)) {
+        const guardedStream = withRunawayGuard(streamOnce(account, options), options && options.runawayGuard)
+        for await (const chunk of guardedStream) {
           firstChunkDelivered = true
           yield chunk
         }

package/lib/tools-normalizer.js

@@ -0,0 +1,118 @@
+export function sanitizeToolName(name) {
+  if (typeof name !== 'string' || !name.trim()) return 'tool_fn'
+  const sanitized = name.trim().replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 64)
+  return sanitized || 'tool_fn'
+}
+
+export function sanitizeDescription(desc) {
+  if (typeof desc === 'string') return desc.trim()
+  if (desc == null) return ''
+  return String(desc).trim()
+}
+
+export function normalizeJsonSchema(schema, depth = 0) {
+  if (depth > 12) return { type: 'string' }
+  if (!schema || typeof schema !== 'object') {
+    return { type: 'object' }
+  }
+  if (Array.isArray(schema)) {
+    return normalizeJsonSchema(schema[0] || { type: 'object' }, depth + 1)
+  }
+
+  const out = {}
+
+  let type = schema.type
+  let nullable = false
+  if (Array.isArray(type)) {
+    nullable = type.includes('null')
+    type = type.find((t) => t && t !== 'null') || 'string'
+  }
+  if (typeof type === 'string') {
+    out.type = type.toLowerCase()
+  } else if (schema.properties) {
+    out.type = 'object'
+  } else if (schema.items) {
+    out.type = 'array'
+  } else {
+    out.type = depth === 0 ? 'object' : 'string'
+  }
+
+  if (nullable) {
+    out.nullable = true
+  }
+
+  if (schema.description) {
+    out.description = String(schema.description)
+  }
+
+  if (out.type === 'object') {
+    if (schema.properties && typeof schema.properties === 'object' && !Array.isArray(schema.properties)) {
+      out.properties = {}
+      for (const [key, val] of Object.entries(schema.properties)) {
+        if (typeof key === 'string' && key) {
+          out.properties[key] = normalizeJsonSchema(val, depth + 1)
+        }
+      }
+    }
+
+    if (Array.isArray(schema.required)) {
+      const propKeys = new Set(Object.keys(out.properties))
+      const reqs = schema.required
+        .filter((k) => typeof k === 'string' && k.length > 0)
+        .filter((k) => propKeys.size === 0 || propKeys.has(k))
+      if (reqs.length > 0) {
+        out.required = [...new Set(reqs)]
+      }
+    }
+
+    if (typeof schema.additionalProperties === 'boolean') {
+      out.additionalProperties = schema.additionalProperties
+    }
+  } else if (out.type === 'array') {
+    if (schema.items) {
+      out.items = normalizeJsonSchema(
+        Array.isArray(schema.items) ? schema.items[0] : schema.items,
+        depth + 1,
+      )
+    } else {
+      out.items = { type: 'string' }
+    }
+  }
+
+  if (Array.isArray(schema.enum) && schema.enum.length > 0) {
+    const cleaned = [...new Set(
+      schema.enum
+        .map((item) => (item != null ? String(item).trim() : ''))
+        .filter((item) => item.length > 0),
+    )]
+    if (cleaned.length > 0) {
+      out.enum = cleaned
+    }
+  }
+
+  return out
+}
+
+export function normalizeTools(tools) {
+  if (!Array.isArray(tools) || !tools.length) return undefined
+  const validTools = []
+
+  for (const tool of tools) {
+    if (!tool || typeof tool !== 'object') continue
+    const rawName = tool.name || (tool.function && tool.function.name)
+    if (!rawName) continue
+
+    const name = sanitizeToolName(rawName)
+    const description = sanitizeDescription(tool.description || (tool.function && tool.function.description))
+    const rawParams = tool.parameters || tool.input_schema || (tool.function && tool.function.parameters)
+    const parameters = normalizeJsonSchema(rawParams)
+
+    validTools.push({
+      name,
+      description,
+      parameters,
+    })
+  }
+
+  return validTools.length ? validTools : undefined
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-subscriptions",
-  "version": "0.6.27",
+  "version": "0.6.28",
   "description": "Use ChatGPT Codex, Claude, Grok, Antigravity, Kimi, GLM, Cursor, Kiro, Copilot, Qwen, ERNIE, Spark, JetBrains, Perplexity, Replit, and Cody subscriptions as DeepSeek Harness LLM providers via OAuth.",
   "license": "MIT",
   "type": "module",