dsh-ptc-plus 0.4.2 → 0.4.8

package/internal/direct-surface-owner.js

@@ -1,4 +1,7 @@
 /** Own PTC direct presentation, prompt projection, and stream normalization. */
+import { boundContextSummary, createUserMessage } from '@deepseek-ai/dsh-llm'
+import { validateJsonSchemaValue } from '@deepseek-ai/dsh-tools'
+import { PTC_MESSAGE_SOURCE_KIND } from './message-sources.js'
 import { canonicalizeToolCallStream } from './tool-call-canonicalizer.js'
 import { editRunCodeSchema } from './rejected-cell-editor.js'
 import { sessionRuntimeContexts } from './runtime-contexts.js'
@@ -19,6 +22,12 @@ const RUN_CODE_CODE_DESCRIPTION = 'Code for the next REPL cell, parsed as the bo
 const RUN_CODE_DESCRIPTION_DESCRIPTION = 'Short active-voice summary of what this cell does, 5-10 words (shown in the UI).'
 const CODE_TRANSPORT_INSTRUCTION = '`run_code` and `edit_run_code` are the only tools callable directly. Call every native tool declared by the SDK from inside a program.'
 const PTC_COLLAPSE_SECTION_NAMES = Object.freeze(['tools:ptc-only', 'tools:code-only'])
+const INVALID_TOOL_JSON_FAILURE = Object.freeze({
+  code: 'MALFORMED_RESPONSE',
+  message: 'DeepSeek Messages stream: tool input is invalid JSON',
+})
+const MALFORMED_TOOL_REJECTION_ID = 'dsh-ptc-plus-malformed-tool-json'
+const MALFORMED_TOOL_REJECTION_ARGUMENTS = '{"dsh_ptc_plus_malformed_tool_json":'
 
 function adaptRunCodeSchema(tool) {
   const parameters = tool.parameters
@@ -139,6 +148,314 @@ async function* bindCallPolicies(source, policy, calls) {
   }
 }
 
+function invalidToolJsonFinish(chunk) {
+  const failure = chunk?.reason?.failure
+  return chunk?.type === 'finish'
+    && chunk.reason.kind === 'error'
+    && failure?.code === INVALID_TOOL_JSON_FAILURE.code
+    && failure?.message === INVALID_TOOL_JSON_FAILURE.message
+}
+
+function invalidToolJsonError(error) {
+  const failure = error?.failure ?? error
+  return failure?.code === INVALID_TOOL_JSON_FAILURE.code
+    && failure?.message === INVALID_TOOL_JSON_FAILURE.message
+}
+
+function directToolSchemas(tools) {
+  const schemas = new Map()
+  if (!Array.isArray(tools)) return schemas
+  for (const tool of tools) {
+    if (tool?.name !== RUN_CODE && tool?.name !== EDIT_RUN_CODE) continue
+    if (schemas.has(tool.name) || !isRecord(tool.parameters)) return new Map()
+    schemas.set(tool.name, tool.parameters)
+  }
+  return schemas
+}
+
+function repairableDirectCall(chunks, tools) {
+  const finish = chunks.at(-1)
+  if (!invalidToolJsonFinish(finish)) return undefined
+  const completed = completedToolBlocks(chunks)
+  if (completed?.length !== 1) return undefined
+  const body = chunks.slice(0, -1)
+  const starts = body.filter(chunk => chunk?.type === 'block-start' && chunk.blockType === 'tool-call')
+  const deltas = body.filter(chunk => chunk?.type === 'tool-call-delta')
+  const ends = body.filter(chunk => chunk?.type === 'block-end' && chunk.block?.type === 'tool-call')
+  const usages = body.filter(chunk => chunk?.type === 'usage')
+  if (starts.length !== 1 || deltas.length === 0 || ends.length !== 1
+    || usages.length > 1
+    || body.some(chunk => chunk?.type !== 'usage' && !toolStreamChunk(chunk))) {
+    return undefined
+  }
+  const index = starts[0].index
+  const end = ends[0]
+  const id = end.block.id
+  const name = end.block.name
+  if (!Number.isSafeInteger(index) || index < 0 || typeof id !== 'string' || id.length === 0
+    || (name !== RUN_CODE && name !== EDIT_RUN_CODE)
+    || end.index !== index
+    || typeof end.block.arguments !== 'string'
+    || deltas.some(chunk => chunk.index !== index || chunk.id !== id
+      || (chunk.name !== undefined && chunk.name !== name)
+      || typeof chunk.argumentsDelta !== 'string')) {
+    return undefined
+  }
+  const raw = deltas.map(chunk => chunk.argumentsDelta).join('')
+  if (raw !== end.block.arguments || !raw.endsWith('}')) return undefined
+  const candidate = raw.slice(0, -1)
+  let value
+  try {
+    value = JSON.parse(candidate)
+  } catch {
+    return undefined
+  }
+  const schema = directToolSchemas(tools).get(name)
+  if (!isRecord(value) || schema === undefined
+    || validateJsonSchemaValue(schema, value).length !== 0) return undefined
+  return { index, candidate }
+}
+
+function canonicalToolBlock(index, block) {
+  return [
+    { type: 'block-start', index, blockType: 'tool-call' },
+    {
+      type: 'tool-call-delta', index, id: block.id, name: block.name,
+      argumentsDelta: block.arguments,
+    },
+    { type: 'block-end', index, block },
+  ]
+}
+
+function repairedDirectChunks(chunks, repair, usageAlreadyEmitted) {
+  const end = chunks.find(chunk => chunk?.type === 'block-end'
+    && chunk.index === repair.index && chunk.block?.type === 'tool-call')
+  const block = { ...end.block, arguments: repair.candidate }
+  const usage = usageAlreadyEmitted ? undefined : firstUsageChunk(chunks)
+  return [
+    ...canonicalToolBlock(repair.index, block),
+    ...usage === undefined ? [] : [usage],
+    { type: 'finish', reason: { kind: 'tool-calls' } },
+  ]
+}
+
+function completedToolBlocks(chunks) {
+  const body = chunks.slice(0, -1)
+  if (body.filter(chunk => chunk?.type === 'usage').length > 1
+    || body.some(chunk => chunk?.type !== 'usage' && !toolStreamChunk(chunk))) {
+    return undefined
+  }
+  const calls = new Map()
+  for (const chunk of chunks) {
+    if (chunk?.type === 'block-start' && chunk.blockType === 'tool-call') {
+      if (!Number.isSafeInteger(chunk.index) || chunk.index < 0) return undefined
+      const call = calls.get(chunk.index)
+      if (call?.started === true || call?.block !== undefined) return undefined
+      if (call === undefined) calls.set(chunk.index, {
+        arguments: '', hasDelta: false, started: true,
+      })
+      else call.started = true
+    } else if (chunk?.type === 'tool-call-delta') {
+      if (!Number.isSafeInteger(chunk.index) || chunk.index < 0) return undefined
+      let call = calls.get(chunk.index)
+      if (call === undefined) {
+        call = { arguments: '', hasDelta: false, started: false }
+        calls.set(chunk.index, call)
+      }
+      if (call.block !== undefined
+        || typeof chunk.id !== 'string' || chunk.id.length === 0
+        || (call.id !== undefined && call.id !== chunk.id)
+        || (chunk.name !== undefined && (typeof chunk.name !== 'string' || chunk.name.length === 0
+          || (call.name !== undefined && call.name !== chunk.name)))
+        || typeof chunk.argumentsDelta !== 'string') return undefined
+      call.id ??= chunk.id
+      if (chunk.name !== undefined) call.name ??= chunk.name
+      call.hasDelta = true
+      call.arguments += chunk.argumentsDelta
+    } else if (chunk?.type === 'block-end' && chunk.block?.type === 'tool-call') {
+      if (!Number.isSafeInteger(chunk.index) || chunk.index < 0) return undefined
+      let call = calls.get(chunk.index)
+      if (call === undefined) {
+        call = { arguments: '', hasDelta: false, started: false }
+        calls.set(chunk.index, call)
+      }
+      if (call.block !== undefined
+        || typeof chunk.block.id !== 'string' || chunk.block.id.length === 0
+        || typeof chunk.block.name !== 'string' || chunk.block.name.length === 0
+        || typeof chunk.block.arguments !== 'string'
+        || (call.id !== undefined && call.id !== chunk.block.id)
+        || (call.name !== undefined && call.name !== chunk.block.name)
+        || (call.hasDelta && call.arguments !== chunk.block.arguments)) return undefined
+      call.block = chunk.block
+    }
+  }
+  if (calls.size === 0 || [...calls.values()].some(call => call.block === undefined)) {
+    return undefined
+  }
+  const completed = [...calls].map(([index, call]) => ({ index, block: call.block }))
+  if (new Set(completed.map(call => call.block.id)).size !== completed.length) return undefined
+  return completed
+}
+
+function firstUsageChunk(chunks) {
+  return chunks.find(chunk => chunk?.type === 'usage')
+}
+
+function settleMalformedToolCalls(chunks, priorIndexes, usageAlreadyEmitted) {
+  if (!invalidToolJsonFinish(chunks.at(-1))) return undefined
+  const calls = completedToolBlocks(chunks)
+  if (calls === undefined || calls.some(call => priorIndexes.has(call.index))) return undefined
+  const usage = usageAlreadyEmitted ? undefined : firstUsageChunk(chunks)
+  return [
+    ...calls.flatMap(call => canonicalToolBlock(call.index, call.block)),
+    ...usage === undefined ? [] : [usage],
+    { type: 'finish', reason: { kind: 'tool-calls' } },
+  ]
+}
+
+function toolStreamChunk(chunk) {
+  return chunk?.type === 'tool-call-delta'
+    || (chunk?.type === 'block-start' && chunk.blockType === 'tool-call')
+    || (chunk?.type === 'block-end' && chunk.block?.type === 'tool-call')
+}
+
+function unusedString(base, used) {
+  let value = base
+  for (let suffix = 2; used.has(value); suffix++) value = `${base}-${suffix}`
+  return value
+}
+
+function visibleBlockClosures(openBlocks, chunks) {
+  const closing = new Map([...openBlocks].map(([index, block]) => [index, { ...block }]))
+  for (const chunk of chunks) {
+    const block = closing.get(chunk?.index)
+    if (block === undefined) continue
+    if (chunk.type === `${block.type}-delta` && typeof chunk.text === 'string') {
+      block.text += chunk.text
+    } else if (chunk.type === 'block-end' && chunk.block?.type === block.type) {
+      block.final = chunk.block
+    }
+  }
+  return [...closing].map(([index, block]) => ({
+    type: 'block-end',
+    index,
+    block: block.final ?? { type: block.type, text: block.text },
+  }))
+}
+
+function rejectedMalformedToolStream(
+  chunks,
+  priorIndexes = new Set(),
+  openBlocks = new Map(),
+  usageAlreadyEmitted = false,
+) {
+  const usedIndexes = new Set(priorIndexes)
+  const usedIds = new Set()
+  for (const chunk of chunks) {
+    if (Number.isSafeInteger(chunk?.index) && chunk.index >= 0) usedIndexes.add(chunk.index)
+    if (typeof chunk?.id === 'string') usedIds.add(chunk.id)
+    if (typeof chunk?.block?.id === 'string') usedIds.add(chunk.block.id)
+  }
+  let index = 0
+  while (usedIndexes.has(index)) index++
+  const id = unusedString(MALFORMED_TOOL_REJECTION_ID, usedIds)
+  const usage = usageAlreadyEmitted ? undefined : firstUsageChunk(chunks)
+  return [
+    ...visibleBlockClosures(openBlocks, chunks),
+    { type: 'block-start', index, blockType: 'tool-call' },
+    {
+      type: 'tool-call-delta', index, id, name: RUN_CODE,
+      argumentsDelta: MALFORMED_TOOL_REJECTION_ARGUMENTS,
+    },
+    {
+      type: 'block-end', index,
+      block: {
+        type: 'tool-call', id, name: RUN_CODE,
+        arguments: MALFORMED_TOOL_REJECTION_ARGUMENTS,
+      },
+    },
+    ...usage === undefined ? [] : [usage],
+    { type: 'finish', reason: { kind: 'tool-calls' } },
+  ]
+}
+
+function recoveredMalformedChunks(chunks, tools, priorIndexes, openBlocks, usageAlreadyEmitted) {
+  if (usageAlreadyEmitted && firstUsageChunk(chunks) !== undefined) {
+    return rejectedMalformedToolStream(chunks, priorIndexes, openBlocks, true)
+  }
+  const repair = repairableDirectCall(chunks, tools)
+  const settled = repair !== undefined && !priorIndexes.has(repair.index)
+    ? repairedDirectChunks(chunks, repair, usageAlreadyEmitted)
+    : settleMalformedToolCalls(chunks, priorIndexes, usageAlreadyEmitted)
+  return settled === undefined
+    ? rejectedMalformedToolStream(chunks, priorIndexes, openBlocks, usageAlreadyEmitted)
+    : [...visibleBlockClosures(openBlocks, chunks), ...settled]
+}
+
+function observeVisibleBlock(openBlocks, chunk) {
+  if (chunk?.type === 'block-start'
+    && (chunk.blockType === 'text' || chunk.blockType === 'reasoning')) {
+    openBlocks.set(chunk.index, { type: chunk.blockType, text: '' })
+  } else if (chunk?.type === 'text-delta' || chunk?.type === 'reasoning-delta') {
+    const block = openBlocks.get(chunk.index)
+    const type = chunk.type === 'text-delta' ? 'text' : 'reasoning'
+    if (block?.type === type) block.text += chunk.text
+  } else if (chunk?.type === 'block-end') {
+    openBlocks.delete(chunk.index)
+  }
+}
+
+async function* recoverMalformedToolCallStream(source, tools) {
+  let pending = []
+  const priorIndexes = new Set()
+  const openBlocks = new Map()
+  let usageSeen = false
+  try {
+    for await (const chunk of source) {
+      if (pending.length === 0) {
+        if (toolStreamChunk(chunk)) pending.push(chunk)
+        else if (chunk?.type === 'usage' && usageSeen) pending.push(chunk)
+        else if (invalidToolJsonFinish(chunk)) {
+          yield* rejectedMalformedToolStream([chunk], priorIndexes, openBlocks, usageSeen)
+          openBlocks.clear()
+        } else {
+          if (Number.isSafeInteger(chunk?.index) && chunk.index >= 0) priorIndexes.add(chunk.index)
+          observeVisibleBlock(openBlocks, chunk)
+          if (chunk?.type === 'usage') usageSeen = true
+          yield chunk
+        }
+        continue
+      }
+      pending.push(chunk)
+      if (chunk?.type !== 'finish') continue
+      const output = invalidToolJsonFinish(chunk)
+        ? recoveredMalformedChunks(pending, tools, priorIndexes, openBlocks, usageSeen)
+        : pending
+      for (const outputChunk of output) {
+        if (Number.isSafeInteger(outputChunk?.index) && outputChunk.index >= 0) {
+          priorIndexes.add(outputChunk.index)
+        }
+        if (outputChunk?.type === 'usage') usageSeen = true
+        yield outputChunk
+      }
+      if (invalidToolJsonFinish(chunk)) openBlocks.clear()
+      pending = []
+    }
+  } catch (error) {
+    if (invalidToolJsonError(error)) {
+      yield* recoveredMalformedChunks([
+        ...pending,
+        { type: 'finish', reason: { kind: 'error', failure: INVALID_TOOL_JSON_FAILURE } },
+      ], tools, priorIndexes, openBlocks, usageSeen)
+      return
+    } else {
+      yield* pending
+      throw error
+    }
+  }
+  yield* pending
+}
+
 export function createDirectSurfaceOwner({
   editTransport,
   runtimeConfig,
@@ -383,7 +700,8 @@ export function createDirectSurfaceOwner({
           editToolName: EDIT_RUN_CODE,
         })
         : next()
-      return bindCallPolicies(source, policy, policy.owner.calls)
+      const recovered = recoverMalformedToolCallStream(source, options.tools)
+      return bindCallPolicies(recovered, policy, policy.owner.calls)
     },
     executionRejection(exec) {
       if (exec.name === EDIT_RUN_CODE && exec.parent !== undefined) {
@@ -430,12 +748,18 @@ export function createDirectSurfaceOwner({
       const outer = missingPath === 'description'
         && policy?.autoDescribeRunCode !== true
         && !(isRecord(exec.arguments) && typeof exec.arguments.description === 'string')
-      const context = {
-        name: 'tools:ptc-plus-run-code-arguments',
-        text: outer
-          ? 'The run_code outer transport arguments are invalid at JSON path $.description. Add a sibling string `description` field to run_code; a description nested inside a native-tool argument does not satisfy this outer requirement.'
-          : `A nested native-tool argument is missing required property "${missingPath}". Add a string description at that path in the native-tool arguments; the outer run_code description does not satisfy this nested requirement.`,
-      }
+      const text = outer
+        ? 'The run_code outer transport arguments are invalid at JSON path $.description. Add a sibling string `description` field to run_code; a description nested inside a native-tool argument does not satisfy this outer requirement.'
+        : `A nested native-tool argument is missing required property "${missingPath}". Add a string description at that path in the native-tool arguments; the outer run_code description does not satisfy this nested requirement.`
+      // additionalContexts enter the durable inbox as messages, not prompt sections.
+      const context = createUserMessage({
+        source: {
+          kind: PTC_MESSAGE_SOURCE_KIND,
+          form: 'notice',
+          summary: boundContextSummary('tools:ptc-plus-run-code-arguments'),
+        },
+        content: [{ type: 'text', text }],
+      })
       return {
         ...diagnosed,
         additionalContexts: [...diagnosed.additionalContexts ?? [], context],

package/internal/edit-transport-owner.js

@@ -238,11 +238,34 @@ export function createEditTransportOwner(ctx, {
     }
   }
 
+  const disposeInstalled = (installed) => {
+    const failures = []
+    for (const key of ['disposePresentation', 'disposeRegistration']) {
+      const dispose = installed[key]
+      if (dispose === undefined) continue
+      try {
+        dispose()
+        installed[key] = undefined
+      } catch (error) {
+        failures.push(error)
+      }
+    }
+    if (failures.length > 0) {
+      throw new AggregateError(failures, 'ptc-plus: edit_run_code scope disposal failed')
+    }
+  }
+
   const uninstall = (agent) => {
     const installed = installedScopes.get(agent)
     if (installed === undefined) return
-    installedScopes.delete(agent)
-    installed.dispose()
+    try {
+      disposeInstalled(installed)
+    } finally {
+      if (installed.disposePresentation === undefined
+        && installed.disposeRegistration === undefined) {
+        installedScopes.delete(agent)
+      }
+    }
   }
 
   return Object.freeze({
@@ -251,11 +274,19 @@ export function createEditTransportOwner(ctx, {
       currentDurableReplay = nextConfig.durableReplay
     },
     isInstalled(agent) {
-      return installedScopes.has(agent)
+      const installed = installedScopes.get(agent)
+      return installed?.disposePresentation !== undefined
+        && installed.disposeRegistration !== undefined
     },
     ensureInstalled(agent) {
       const installed = installedScopes.get(agent)
-      if (installed !== undefined) return installed.definition
+      if (installed !== undefined) {
+        if (installed.disposePresentation !== undefined
+          && installed.disposeRegistration !== undefined) {
+          return installed.definition
+        }
+        uninstall(agent)
+      }
       const liveSchemas = typeof toolSchemasForAgent === 'function'
         ? toolSchemasForAgent(agent)
         : []
@@ -271,24 +302,31 @@ export function createEditTransportOwner(ctx, {
       if (typeof disposeRegistration !== 'function') {
         throw new Error('ptc-plus: DSH tools.register did not return a disposer')
       }
-      let disposePresentation
+      const nextInstalled = {
+        definition,
+        disposePresentation: undefined,
+        disposeRegistration,
+        sessionId: sessionId(agent),
+      }
+      installedScopes.set(agent, nextInstalled)
       try {
-        disposePresentation = scopedTools.presentAs('both')
+        const disposePresentation = scopedTools.presentAs('both')
         if (typeof disposePresentation !== 'function') {
           throw new Error('ptc-plus: DSH tools.presentAs did not return a disposer')
         }
+        nextInstalled.disposePresentation = disposePresentation
       } catch (error) {
-        disposeRegistration()
+        try {
+          uninstall(agent)
+        } catch (cleanupError) {
+          throw new AggregateError(
+            [error, cleanupError],
+            'ptc-plus: edit_run_code installation and rollback failed',
+            { cause: error },
+          )
+        }
         throw error
       }
-      let active = true
-      const dispose = () => {
-        if (!active) return
-        active = false
-        disposePresentation()
-        disposeRegistration()
-      }
-      installedScopes.set(agent, { definition, dispose, sessionId: sessionId(agent) })
       return definition
     },
     handleResult(exec, result) {
@@ -305,28 +343,50 @@ export function createEditTransportOwner(ctx, {
       releaseClaim(pending.id, pending.targetCallSeq)
     },
     disposeAgent(agent) {
-      uninstall(agent)
+      let failure
+      try {
+        uninstall(agent)
+      } catch (error) {
+        failure = error
+      }
       const id = sessionId(agent)
       if (id !== undefined) {
         discardSettlements(id)
         editClaims.delete(id)
       }
+      if (failure !== undefined) throw failure
     },
     disposeSession(session) {
       const id = String(session.id)
+      const failures = []
       for (const [agent, installed] of installedScopes) {
         if (installed.sessionId !== id) continue
-        installedScopes.delete(agent)
-        installed.dispose()
+        try {
+          uninstall(agent)
+        } catch (error) {
+          failures.push(error)
+        }
       }
       discardSettlements(id)
       editClaims.delete(id)
+      if (failures.length > 0) {
+        throw new AggregateError(failures, 'ptc-plus: edit_run_code session disposal failed')
+      }
     },
     dispose() {
       discardSettlements()
       editClaims.clear()
-      for (const installed of installedScopes.values()) installed.dispose()
-      installedScopes.clear()
+      const failures = []
+      for (const agent of [...installedScopes.keys()]) {
+        try {
+          uninstall(agent)
+        } catch (error) {
+          failures.push(error)
+        }
+      }
+      if (failures.length > 0) {
+        throw new AggregateError(failures, 'ptc-plus: edit_run_code owner disposal failed')
+      }
     },
   })
 }