@goodandready/dsh-subscriptions 0.6.26 → 0.6.28

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/lib/usage.js

@@ -49,6 +49,24 @@ export function asUsageSnapshot(percent) {
   if (usedPercent == null) return null
   return { usedPercent }
 }
+
+export function parseResetAt(val) {
+  if (val == null) return null
+  if (typeof val === 'number' && Number.isFinite(val) && val > 0) {
+    return val < 1e11 ? Math.round(val * 1000) : Math.round(val)
+  }
+  if (typeof val === 'string' && val.trim()) {
+    const s = val.trim()
+    const n = Number(s)
+    if (Number.isFinite(n) && n > 0) {
+      return n < 1e11 ? Math.round(n * 1000) : Math.round(n)
+    }
+    const parsed = Date.parse(s)
+    if (Number.isFinite(parsed) && parsed > 0) return parsed
+  }
+  return null
+}
+
 // Named limit windows reported by vendors (five_hour, seven_day, primary...).
 // Label map is a data table: extend it when a vendor adds a window name.
 const WINDOW_LABELS = {
@@ -105,11 +123,14 @@ export function usageWindows(obj) {
       if (usedPercent != null) {
         seen.add(resolved.id)
         const label = windowLabel(resolved.id)
+        const rawReset = value.resetAt ?? value.reset_at ?? value.resetTime ?? value.resets_at ?? value.resetsAt ?? value.reset_time
+        const resetAt = parseResetAt(rawReset)
         out.push({
           id: resolved.id,
           zh: label.zh,
           en: label.en,
           usedPercent,
+          ...(resetAt ? { resetAt } : {}),
           isModelBucket: resolved.isModelBucket,
         })
       }

package/lib/vault.js

@@ -9,7 +9,7 @@ export const VAULT_FORMAT = 'dsh-subscriptions-vault-v1'
 /**
  * Encrypts slots configuration and credential blobs into a portable vault string.
  */
-export function exportVault({ slots = [], blobs = {}, exportedBy = 'dsh-subscriptions' }, passphrase) {
+export function exportVault({ slots = [], blobs = {}, exportedBy = 'dsh-subscriptions', algorithm = 'scrypt' }, passphrase) {
   const pass = String(passphrase || '').trim()
   if (!pass || pass.length < 4) {
     throw new Error('passphrase must be at least 4 characters')
@@ -24,7 +24,7 @@ export function exportVault({ slots = [], blobs = {}, exportedBy = 'dsh-subscrip
     blobs: blobs && typeof blobs === 'object' ? blobs : {},
   }
 
-  const encrypted = encryptWithPassphrase(JSON.stringify(payload), pass)
+  const encrypted = encryptWithPassphrase(JSON.stringify(payload), pass, { algorithm })
   return {
     ok: true,
     vault: encrypted,
@@ -43,7 +43,7 @@ export function importVault(encryptedPayload, passphrase) {
   }
 
   const raw = String(encryptedPayload || '').trim()
-  if (!raw.startsWith('DSHE1:')) {
+  if (!raw.startsWith('DSHE1:') && !raw.startsWith('DSHE2:')) {
     throw new Error('invalid vault format: missing DSHE1 header')
   }
 

package/lib/vendors/copilot.js

@@ -42,6 +42,14 @@ export const COPILOT_MODELS = [
     maxTokens: 65536,
     inputModalities: ["text"],
     reasoning: { efforts: [{ id: "low", name: "Low" }, { id: "medium", name: "Medium" }, { id: "high", name: "High" }] }
+  },
+  {
+    id: "o1",
+    name: "o1 (Copilot)",
+    contextWindow: 200000,
+    maxTokens: 65536,
+    inputModalities: ["text", "image"],
+    reasoning: { efforts: [{ id: "low", name: "Low" }, { id: "medium", name: "Medium" }, { id: "high", name: "High" }] }
   }
 ]
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-subscriptions",
-  "version": "0.6.26",
+  "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",