dsh-ptc-plus 0.2.1

package/internal/source-position-map.js

@@ -0,0 +1,224 @@
+export function identitySourceMap(length) {
+  return [{ generatedStart: 0, generatedEnd: length, originalStart: 0, originalEnd: length }]
+}
+
+/** Build generated text while making every copied source range explicit. */
+export function createMappedTextBuilder(source, sourceOffset = 0) {
+  if (typeof source !== 'string' || !Number.isSafeInteger(sourceOffset) || sourceOffset < 0) {
+    throw new TypeError('mapped text source and offset must be valid')
+  }
+  let text = ''
+  const mappings = []
+  const append = (value) => {
+    if (typeof value !== 'string') throw new TypeError('mapped text must be a string')
+    text += value
+  }
+  const appendMapped = (value, originalStart, originalEnd) => {
+    if (typeof value !== 'string' || !Number.isSafeInteger(originalStart)
+      || !Number.isSafeInteger(originalEnd) || originalStart < sourceOffset
+      || originalEnd < originalStart || originalEnd > sourceOffset + source.length) {
+      throw new RangeError('mapped text range must be bounded by its source')
+    }
+    const generatedStart = text.length
+    text += value
+    if (value.length > 0) {
+      mappings.push({
+        generatedStart,
+        generatedEnd: text.length,
+        originalStart: originalStart - sourceOffset,
+        originalEnd: originalEnd - sourceOffset,
+      })
+    }
+  }
+  return {
+    append,
+    appendMapped,
+    appendSource(start, end) {
+      appendMapped(source.slice(start - sourceOffset, end - sourceOffset), start, end)
+    },
+    result() {
+      return { text, mappings }
+    },
+  }
+}
+
+function originalOffsetAt(sourceMap, generatedOffset) {
+  let low = 0
+  let high = sourceMap.length
+  while (low < high) {
+    const middle = (low + high) >>> 1
+    if (generatedOffset < sourceMap[middle].generatedEnd) high = middle
+    else low = middle + 1
+  }
+  const segment = sourceMap[low] ?? sourceMap.at(-1)
+  if (segment === undefined) return generatedOffset
+  const generatedLength = segment.generatedEnd - segment.generatedStart
+  const originalLength = segment.originalEnd - segment.originalStart
+  const localOffset = Math.max(0, generatedOffset - segment.generatedStart)
+  if (localOffset >= generatedLength) return segment.originalEnd
+  if (generatedLength === originalLength) return segment.originalStart + localOffset
+  if (generatedLength <= 1 || originalLength <= 1) return segment.originalStart
+  return segment.originalStart
+    + Math.floor((localOffset * (originalLength - 1)) / (generatedLength - 1))
+}
+
+function mappedOffsetRange(sourceMap, start, end) {
+  return {
+    originalStart: originalOffsetAt(sourceMap, start),
+    originalEnd: originalOffsetAt(sourceMap, Math.max(start, end - 1)) + (end > start ? 1 : 0),
+  }
+}
+
+function replacementSegments(sourceMap, start, end, replacementLength, mappings) {
+  const { originalStart: startOriginal, originalEnd: endOriginal } = mappedOffsetRange(sourceMap, start, end)
+  if (!Array.isArray(mappings) || mappings.length === 0) {
+    return replacementLength === 0 ? [] : [{
+      generatedStart: start,
+      generatedEnd: start + replacementLength,
+      originalStart: startOriginal,
+      originalEnd: endOriginal,
+    }]
+  }
+  const segments = []
+  let cursor = 0
+  for (const mapping of mappings) {
+    if (mapping.generatedStart > cursor) {
+      segments.push({
+        generatedStart: start + cursor,
+        generatedEnd: start + mapping.generatedStart,
+        originalStart: startOriginal,
+        originalEnd: endOriginal,
+      })
+    }
+    const original = mappedOffsetRange(sourceMap, mapping.originalStart, mapping.originalEnd)
+    segments.push({
+      generatedStart: start + mapping.generatedStart,
+      generatedEnd: start + mapping.generatedEnd,
+      ...original,
+    })
+    cursor = mapping.generatedEnd
+  }
+  if (cursor < replacementLength) {
+    segments.push({
+      generatedStart: start + cursor,
+      generatedEnd: start + replacementLength,
+      originalStart: startOriginal,
+      originalEnd: endOriginal,
+    })
+  }
+  return segments
+}
+
+export function applySourceEdits(code, sourceMap, edits) {
+  if (!Array.isArray(edits) || edits.length === 0) return { code, sourceMap }
+  const ordered = [...edits].sort((left, right) => left.start - right.start || left.end - right.end)
+  const normalized = []
+  let previousEnd = 0
+  let previous
+  for (const item of ordered) {
+    const text = item.text ?? ''
+    if (!Number.isSafeInteger(item.start) || !Number.isSafeInteger(item.end)
+      || item.start < 0 || item.end < item.start || item.end > code.length
+      || item.start < previousEnd || typeof text !== 'string'
+      || (item.mappings !== undefined && !Array.isArray(item.mappings))
+      || (item.start === item.end && previous?.start === item.start && previous.end === item.end)) {
+      throw new RangeError('source edits must be bounded, ordered, and non-overlapping')
+    }
+    const itemMappings = [...(item.mappings ?? [])]
+      .sort((left, right) => left.generatedStart - right.generatedStart)
+    let mappingEnd = 0
+    for (const mapping of itemMappings) {
+      if (!Number.isSafeInteger(mapping.generatedStart) || !Number.isSafeInteger(mapping.generatedEnd)
+        || !Number.isSafeInteger(mapping.originalStart) || !Number.isSafeInteger(mapping.originalEnd)
+        || mapping.generatedStart < mappingEnd || mapping.generatedEnd < mapping.generatedStart
+        || mapping.generatedEnd > text.length || mapping.originalStart < 0
+        || mapping.originalEnd < mapping.originalStart || mapping.originalEnd > code.length) {
+        throw new RangeError('source edit mappings must be bounded and non-overlapping')
+      }
+      mappingEnd = mapping.generatedEnd
+    }
+    normalized.push({ ...item, text, mappings: itemMappings })
+    previousEnd = item.end
+    previous = item
+  }
+
+  const chunks = []
+  const mappings = []
+  let generatedOffset = 0
+  let sourceOffset = 0
+  let segmentIndex = 0
+  const appendUnchanged = end => {
+    if (end <= sourceOffset) return
+    chunks.push(code.slice(sourceOffset, end))
+    while (segmentIndex < sourceMap.length && sourceMap[segmentIndex].generatedEnd <= sourceOffset) segmentIndex += 1
+    for (let index = segmentIndex; index < sourceMap.length; index += 1) {
+      const segment = sourceMap[index]
+      if (segment.generatedStart >= end) break
+      const start = Math.max(sourceOffset, segment.generatedStart)
+      const stop = Math.min(end, segment.generatedEnd)
+      if (stop <= start) continue
+      const { originalStart, originalEnd } = mappedOffsetRange(sourceMap, start, stop)
+      mappings.push({
+        generatedStart: generatedOffset + start - sourceOffset,
+        generatedEnd: generatedOffset + stop - sourceOffset,
+        originalStart,
+        originalEnd,
+      })
+    }
+    generatedOffset += end - sourceOffset
+    sourceOffset = end
+  }
+
+  for (const item of normalized) {
+    appendUnchanged(item.start)
+    const { text } = item
+    chunks.push(text)
+    mappings.push(...replacementSegments(sourceMap, item.start, item.end, text.length, item.mappings)
+      .map(segment => ({ ...segment, generatedStart: segment.generatedStart - item.start + generatedOffset,
+        generatedEnd: segment.generatedEnd - item.start + generatedOffset })))
+    generatedOffset += text.length
+    sourceOffset = item.end
+  }
+  appendUnchanged(code.length)
+  return { code: chunks.join(''), sourceMap: mappings }
+}
+
+function lineStartOffset(source, line) {
+  let offset = 0
+  for (let current = 1; current < line; current += 1) {
+    const newline = source.indexOf('\n', offset)
+    if (newline < 0) return source.length
+    offset = newline + 1
+  }
+  return offset
+}
+
+function positionAtOffset(source, offset) {
+  const prefix = source.slice(0, offset)
+  const line = prefix.split(/\r?\n/).length
+  const lastBreak = prefix.lastIndexOf('\n')
+  return { line, column: offset - lastBreak }
+}
+
+export function mapSourcePosition(position, generatedSource, originalSource, sourceMap) {
+  if (position === undefined || sourceMap === undefined) return position
+  if (!Number.isSafeInteger(position.line) || position.line < 1
+    || !Number.isSafeInteger(position.column) || position.column < 1) return position
+  const lineStart = lineStartOffset(generatedSource, position.line)
+  const mappedOffset = originalOffsetAt(sourceMap, lineStart + position.column - 1)
+  return positionAtOffset(originalSource, mappedOffset)
+}
+
+/** Map a complete generated-source span into original cell coordinates. */
+export function mapSourceSpan(span, generatedSource, originalSource, sourceMap) {
+  if (span === undefined) return undefined
+  const start = mapSourcePosition(span, generatedSource, originalSource, sourceMap)
+  if (span.end === undefined) return start === span ? span : start
+  if (!Number.isSafeInteger(span.end.line) || span.end.line < 1
+    || !Number.isSafeInteger(span.end.column) || span.end.column < 1) {
+    return { ...start, end: span.end }
+  }
+  const generatedEnd = lineStartOffset(generatedSource, span.end.line) + span.end.column - 1
+  const original = mappedOffsetRange(sourceMap, Math.max(0, generatedEnd - 1), generatedEnd)
+  return { ...start, end: positionAtOffset(originalSource, original.originalEnd) }
+}

package/internal/tool-call-canonicalizer.js

@@ -0,0 +1,339 @@
+function parseArguments(raw) {
+  try {
+    return { ok: true, value: JSON.parse(raw) }
+  } catch {
+    return { ok: false }
+  }
+}
+
+function jsonValuesEqual(left, right) {
+  const pending = [[left, right]]
+  while (pending.length > 0) {
+    const [currentLeft, currentRight] = pending.pop()
+    if (Object.is(currentLeft, currentRight)) continue
+    if (currentLeft === null || currentRight === null
+      || typeof currentLeft !== 'object' || typeof currentRight !== 'object'
+      || Array.isArray(currentLeft) !== Array.isArray(currentRight)) return false
+    const leftKeys = Object.keys(currentLeft)
+    const rightKeys = Object.keys(currentRight)
+    if (leftKeys.length !== rightKeys.length
+      || leftKeys.some(key => !Object.hasOwn(currentRight, key))) return false
+    for (const key of leftKeys) pending.push([currentLeft[key], currentRight[key]])
+  }
+  return true
+}
+
+function containsOwnProto(value) {
+  const pending = [value]
+  while (pending.length > 0) {
+    const current = pending.pop()
+    if (current === null || typeof current !== 'object') continue
+    if (!Array.isArray(current) && Object.hasOwn(current, '__proto__')) return true
+    for (const child of Object.values(current)) pending.push(child)
+  }
+  return false
+}
+
+const MAX_DIRECT_LITERAL_DEPTH = 128
+
+function jsonContainerDepth(value) {
+  let maximum = 0
+  const pending = [{ value, depth: 0 }]
+  while (pending.length > 0) {
+    const current = pending.pop()
+    if (current.value === null || typeof current.value !== 'object') continue
+    const depth = current.depth + 1
+    if (depth > maximum) maximum = depth
+    for (const child of Object.values(current.value)) pending.push({ value: child, depth })
+  }
+  return maximum
+}
+
+function numberLiteral(value) {
+  if (Object.is(value, -0)) return '-0'
+  if (value === Infinity) return '1e400'
+  if (value === -Infinity) return '-1e400'
+  return JSON.stringify(value)
+}
+
+function safeJsonLiteral(value) {
+  const output = []
+  const pending = [{ kind: 'value', value }]
+  while (pending.length > 0) {
+    const item = pending.pop()
+    if (item.kind === 'text') {
+      output.push(item.value)
+      continue
+    }
+    const current = item.value
+    if (current === null) output.push('null')
+    else if (typeof current === 'string') output.push(JSON.stringify(current))
+    else if (typeof current === 'boolean') output.push(String(current))
+    else if (typeof current === 'number') output.push(numberLiteral(current))
+    else if (Array.isArray(current)) {
+      output.push('[')
+      pending.push({ kind: 'text', value: ']' })
+      for (let index = current.length - 1; index >= 0; index -= 1) {
+        if (index < current.length - 1) pending.push({ kind: 'text', value: ',' })
+        pending.push({ kind: 'value', value: current[index] })
+      }
+    } else {
+      const keys = Object.keys(current)
+      output.push('{')
+      pending.push({ kind: 'text', value: '}' })
+      for (let index = keys.length - 1; index >= 0; index -= 1) {
+        const key = keys[index]
+        if (index < keys.length - 1) pending.push({ kind: 'text', value: ',' })
+        pending.push({ kind: 'value', value: current[key] })
+        pending.push({
+          kind: 'text',
+          value: `${key === '__proto__' ? `[${JSON.stringify(key)}]` : JSON.stringify(key)}:`,
+        })
+      }
+    }
+  }
+  return output.join('')
+}
+
+function isIdentifierName(name) {
+  return /^(?:[$_]|\p{ID_Start})(?:[$_\u200C\u200D]|\p{ID_Continue})*$/u.test(name)
+}
+
+function toolMemberCode(name) {
+  return isIdentifierName(name) ? `tools.${name}` : `tools[${JSON.stringify(name)}]`
+}
+
+function nativeCallCode(name, rawArgs, parsedArgs) {
+  const argumentCode = jsonContainerDepth(parsedArgs) > MAX_DIRECT_LITERAL_DEPTH
+    ? `JSON.parse(${JSON.stringify(rawArgs)})`
+    : containsOwnProto(parsedArgs) ? safeJsonLiteral(parsedArgs) : rawArgs
+  return `{\n  return await ${toolMemberCode(name)}(${argumentCode})\n}`
+}
+
+function acceptsTransportView(tools, editToolName) {
+  if (!Array.isArray(tools) || tools.length < 1 || tools.length > 2) return false
+  const names = tools.map(tool => tool?.name)
+  if (new Set(names).size !== names.length || !names.includes('run_code')) return false
+  return names.every(name => name === 'run_code' || name === editToolName)
+}
+
+function resolveCandidateName(name, nativeSchemas) {
+  if (typeof name !== 'string' || name.length === 0) return undefined
+  const matches = new Set()
+  if (nativeSchemas.has(name)) matches.add(name)
+  if (name.startsWith('tools.')) {
+    const member = name.slice('tools.'.length)
+    if (member.length > 0 && !member.includes('.') && nativeSchemas.has(member)) {
+      matches.add(member)
+    }
+  }
+  return matches.size === 1 ? matches.values().next().value : undefined
+}
+
+function extractCall(chunks, index) {
+  let name
+  let id
+  let deltaArgs = ''
+  let finalArgs
+  let deltaIndex = -1
+  let invalidId = false
+  let inconsistent = false
+  let complete = false
+  for (let position = 0; position < chunks.length; position += 1) {
+    const chunk = chunks[position]
+    if (chunk.index !== index) continue
+    if (chunk.type === 'tool-call-delta') {
+      if (chunk.id === undefined) invalidId = true
+      else if (chunk.id !== '') {
+        if (id !== undefined && id !== chunk.id) inconsistent = true
+        else id = chunk.id
+      }
+      if (typeof chunk.name === 'string' && chunk.name.length > 0) {
+        if (name !== undefined && name !== chunk.name) inconsistent = true
+        else name = chunk.name
+      }
+      if (typeof chunk.argumentsDelta !== 'string') inconsistent = true
+      else deltaArgs += chunk.argumentsDelta
+      if (deltaIndex < 0) deltaIndex = position
+    } else if (chunk.type === 'block-end' && chunk.block?.type === 'tool-call') {
+      const block = chunk.block
+      complete = true
+      if (typeof block.id !== 'string' || block.id.length === 0) invalidId = true
+      else if (id !== undefined && id !== block.id) inconsistent = true
+      else id ??= block.id
+      if (name !== undefined && name !== block.name) inconsistent = true
+      else name ??= block.name
+      if (typeof block.arguments !== 'string') inconsistent = true
+      else if (finalArgs !== undefined && finalArgs !== block.arguments) inconsistent = true
+      else finalArgs = block.arguments
+    }
+  }
+  let args = deltaArgs
+  if (finalArgs !== undefined) {
+    if (deltaArgs.length > 0) {
+      const streamed = parseArguments(deltaArgs)
+      const finalized = parseArguments(finalArgs)
+      if (!streamed.ok || !finalized.ok || !jsonValuesEqual(streamed.value, finalized.value)) {
+        inconsistent = true
+      }
+    }
+    args = finalArgs
+  }
+  return { name, id, args, deltaIndex, invalidId, inconsistent, complete }
+}
+
+function transformedChunks(chunks, replacements) {
+  const byIndex = new Map(replacements.map(replacement => [replacement.index, replacement]))
+  const emitted = new Set()
+  return chunks.flatMap(chunk => {
+    if (chunk.type === 'finish') {
+      const { replayState: _replayState, ...finish } = chunk
+      return [finish]
+    }
+    const replacement = byIndex.get(chunk.index)
+    if (replacement === undefined) return [chunk]
+    if (chunk.type === 'block-start') return [{ ...chunk, blockType: 'tool-call' }]
+    if (chunk.type === 'tool-call-delta') {
+      if (emitted.has(chunk.index)) return []
+      emitted.add(chunk.index)
+      return [{
+        ...chunk,
+        name: 'run_code',
+        argumentsDelta: replacement.arguments,
+      }]
+    }
+    if (chunk.type === 'block-end' && chunk.block?.type === 'tool-call') {
+      return [{
+        ...chunk,
+        block: {
+          type: 'tool-call',
+          id: replacement.id,
+          name: 'run_code',
+          arguments: replacement.arguments,
+        },
+      }]
+    }
+    return [chunk]
+  })
+}
+
+function transformCandidate(chunks, index, nativeSchemas, allowDeltaOnly) {
+  const call = extractCall(chunks, index)
+  const nativeName = resolveCandidateName(call.name, nativeSchemas)
+  if ((!call.complete && !allowDeltaOnly) || nativeName === undefined
+    || call.id === undefined || call.invalidId
+    || call.inconsistent || call.deltaIndex < 0) return undefined
+  const parsed = parseArguments(call.args)
+  if (!parsed.ok) return undefined
+  const argumentsValue = JSON.stringify({
+    code: nativeCallCode(nativeName, call.args, parsed.value),
+    description: `Call ${nativeName} inside the session REPL`,
+  })
+  return { index, id: call.id, arguments: argumentsValue }
+}
+
+function transformCandidates(chunks, indices, nativeSchemas, allowDeltaOnly = false) {
+  const replacements = [...indices].map(index => transformCandidate(
+    chunks, index, nativeSchemas, allowDeltaOnly,
+  ))
+    .filter(replacement => replacement !== undefined)
+  return replacements.length === 0 ? undefined : transformedChunks(chunks, replacements)
+}
+
+/**
+ * Normalize model-emitted native calls into the code-only direct-tool projection without guessing.
+ * Unknown or malformed calls pass through unchanged for the host to diagnose.
+ */
+export async function* canonicalizeToolCallStream(source, options = {}) {
+  const editToolName = typeof options.editToolName === 'string' && options.editToolName.length > 0
+    ? options.editToolName
+    : undefined
+  if (options.enabled === false || !acceptsTransportView(options.tools, editToolName)) {
+    yield* source
+    return
+  }
+  const nativeSchemas = options.nativeSchemas instanceof Map
+    ? new Map([...options.nativeSchemas].filter(([name]) => name !== 'run_code' && name !== editToolName))
+    : new Map()
+  if (nativeSchemas.size === 0) {
+    yield* source
+    return
+  }
+  const passthrough = new Set()
+  const open = new Set()
+  let pending = []
+  let changed = false
+  try {
+    for await (const chunk of source) {
+      if (pending.length > 0) {
+        pending.push(chunk)
+        if (chunk.type === 'block-start' && chunk.blockType === 'tool-call') open.add(chunk.index)
+        if (chunk.type === 'tool-call-delta'
+          && resolveCandidateName(chunk.name, nativeSchemas) !== undefined) open.add(chunk.index)
+        if (chunk.type === 'tool-call-delta' && open.size === 1 && open.has(chunk.index)
+          && typeof chunk.name === 'string'
+          && resolveCandidateName(chunk.name, nativeSchemas) === undefined) {
+          yield* pending
+          pending = []
+          passthrough.add(chunk.index)
+          open.clear()
+        } else if (chunk.type === 'block-end' && chunk.block?.type === 'tool-call') {
+          open.delete(chunk.index)
+          if (open.size > 0) continue
+          const indices = new Set(pending
+            .filter(item => item.type === 'tool-call-delta' || item.type === 'block-end')
+            .map(item => item.index))
+          const transformed = transformCandidates(pending, indices, nativeSchemas)
+          if (transformed === undefined) yield* pending
+          else {
+            changed = true
+            yield* transformed
+          }
+          pending = []
+        } else if (chunk.type === 'finish') {
+          const indices = new Set(pending
+            .filter(item => item.type === 'tool-call-delta' || item.type === 'block-end')
+            .map(item => item.index))
+          const transformed = transformCandidates(pending, indices, nativeSchemas, true)
+          if (transformed !== undefined) {
+            changed = true
+            yield* transformed
+          } else if (changed && Object.hasOwn(chunk, 'replayState')) {
+            const { replayState: _replayState, ...finish } = chunk
+            pending[pending.length - 1] = finish
+            yield* pending
+          } else {
+            yield* pending
+          }
+          pending = []
+          open.clear()
+        }
+        continue
+      }
+      if (passthrough.has(chunk.index)) {
+        yield chunk
+        if (chunk.type === 'block-end') passthrough.delete(chunk.index)
+        continue
+      }
+      if (chunk.type === 'block-start' && chunk.blockType === 'tool-call') {
+        open.add(chunk.index)
+        pending = [chunk]
+      } else if (chunk.type === 'tool-call-delta'
+        && resolveCandidateName(chunk.name, nativeSchemas) !== undefined) {
+        open.add(chunk.index)
+        pending = [chunk]
+      } else if (changed && chunk.type === 'finish') {
+        // Provider replay metadata describes the original response and becomes
+        // stale only when at least one block was normalized.
+        const { replayState: _replayState, ...finish } = chunk
+        yield finish
+      } else {
+        yield chunk
+      }
+    }
+  } catch (error) {
+    yield* pending
+    throw error
+  }
+  yield* pending
+}