dsh-py-codeact 0.3.1 → 0.3.3

package/lib/index.js

@@ -5,16 +5,19 @@
  *
  * So this is NOT a `CodeRuntime` backend — it could not conform. It is an ordinary tool plugin that owns its own kernel: one IPython process per conversation tree with a shell per agent, globals surviving between calls, the model's action space being Python code and its observation that cell's output.
  *
- * It still emits `tool/code-dispatch-start` / `tool/code-dispatch`, so bridged tool calls render as SUBTOOL rows in the existing trajectory UI with no client change.
+ * It emits the session format's PTC dispatch events, so bridged tool calls render as SUBTOOL rows in the existing trajectory UI with no client change.
  *
  * @module dsh-py-codeact
  */
 
-import { CallId } from '@deepseek-ai/dsh-llm/brand'
+import * as brand from '@deepseek-ai/dsh-llm/brand'
 import { contentHasImage, createUserMessage } from '@deepseek-ai/dsh-llm'
 import { defineTool, jsonSchemaToPy, renderToolsSdkPy } from '@deepseek-ai/dsh-tools'
 import { KERNEL_PY, PythonKernel } from './kernel.js'
 
+// dsh renamed this brander in 0.1.2-alpha.2; both names remain in the declared peer range.
+const CallId = brand.ToolCallId ?? brand.CallId
+
 /** Same prompt band as Code Mode's `tools:sdk`: tool guidance is 100–199. */
 const TOOLS_MODULE = '__dsh__.tools'
 
@@ -416,9 +419,11 @@ export function renderToolsSection(schemas) {
   // Python. That collision guard, and the `head` parameter it read, went with the Protocol stubs.
   // `async def f(*, ) -> T` is still a SyntaxError, which is why a parameterless tool emits no `*`.
   // Escaped for the block to stay COMPILABLE, which matters more here than fidelity: one description carrying a `\"\"\"` or ending in a backslash would close its own docstring and take every tool below it with it — the failure class where one tool invalidates the whole block. Neither appears in a live catalogue; a future MCP server is not bound by that.
+  // dsh-system-prompt has no literal `{{...}}` escape, so split whole runs of openers before tool prose enters a prompt section; pairwise replacement leaves a pair behind in odd runs.
+  const escapePromptGroups = (doc) => doc.replace(/\{{2,}/g, (run) => [...run].join(' '))
   const docstring = (doc) => {
     if (!doc) return ['    ...']
-    const text = doc.trim().replaceAll('\\', '\\\\').replaceAll('"""', '\\"\\"\\"')
+    const text = escapePromptGroups(doc.trim()).replaceAll('\\', '\\\\').replaceAll('"""', '\\"\\"\\"')
     // Split on every terminator Python's tokenizer honours, not just `\n`: CPython applies universal-newline translation to source, so a lone `\r` reaching the render becomes a real line break. Inside a COMMENTED MCP entry that break escapes the `# ` prefix and the rest of the description becomes live code.
     //
     // EXACTLY these three, which is narrower than it looks like it should be. `str.splitlines()` splits on eight more (`\v`, `\f`, `\x1c`-`\x1e`, `\x85`, `\u2028`, `\u2029`) and PCRE's `\R` on five of those — and every one of them stays INSIDE a `#` comment as far as the tokenizer is concerned, verified by compiling `# comment<ch>x = 1`. Widening to either would break descriptions apart at characters that never needed it.
@@ -426,7 +431,7 @@ export function renderToolsSection(schemas) {
     return lines.length === 1 ? [`    """${lines[0]}"""`] : ['    """', ...lines.map((line) => `    ${line}`.trimEnd()), '    """']
   }
   // A `#` comment cannot span lines, so a description that carries newlines is collapsed rather than emitted: left alone its second line parses as code.
-  const trailing = (doc) => (doc ? `  # ${doc.trim().replace(/\s*(?:\r\n?|\n)\s*/g, ' ')}` : '')
+  const trailing = (doc) => (doc ? `  # ${escapePromptGroups(doc.trim()).replace(/\s*(?:\r\n?|\n)\s*/g, ' ')}` : '')
   /** @returns the lines to emit, and — separately — the type expressions they spell, which is what the `typing` import is derived from. Kept apart because prose is now emitted too: a description mentioning "Any file" must not import `Any`. */
   const signature = (spec) => {
     const body = docstring(spec.doc)
@@ -655,7 +660,9 @@ export function apply(ctx, config = {}) {
       console.warn(`[dsh-py-codeact] no agent on execution ${exec.callId}: sub-calls will run but not appear as SUBTOOL rows`)
     }
     const trace = { rootCallId: exec.rootCallId, parentCallId: exec.callId, subCallId, name, arguments: args }
-    session?.append('tool/code-dispatch-start', trace)
+    // V3 rejects the old Code Mode tags even though their payload is unchanged. Older hosts in our peer range still require them.
+    const dispatchEvent = session?.header?.version >= 3 ? 'tool/ptc-dispatch' : 'tool/code-dispatch'
+    session?.append(`${dispatchEvent}-start`, trace)
 
     // Every outcome has to emit the terminal event, throws included: if `ctx.tools.execute` rejects rather than returning `{isError:true}` (an abort, a policy wrapper throwing), the Python side is still answered, but the SUBTOOL row would sit in the trajectory as "running" forever.
     try {
@@ -669,7 +676,7 @@ export function apply(ctx, config = {}) {
         signal: exec.signal,
       })
 
-      session?.append('tool/code-dispatch', { ...trace, isError: outcome.isError, content: outcome.content })
+      session?.append(dispatchEvent, { ...trace, isError: outcome.isError, content: outcome.content })
       // Pixels cannot travel through the bridge: `value` is JSON, so a `read_image` result reaches the cell as width/height/attachmentId and NOTHING to look at. Re-attach the blocks the way Code Mode does, and the image lands in the conversation right after this cell — the model sees it on its next step. Without this the model believes the call succeeded, gets metadata, and cannot tell why it still cannot see anything.
       if (!outcome.isError && contentHasImage(outcome.content ?? [])) {
         exec.deferContext(createUserMessage({ content: outcome.content, source: { kind: 'plugin', plugin: 'dsh-py-codeact' } }))
@@ -679,7 +686,7 @@ export function apply(ctx, config = {}) {
       // falling back to the wrapper there would hand the cell the one shape it was promised not to see.
       return toolCallReply(outcome, entry.envelopes.get(from)?.has(name))
     } catch (error) {
-      session?.append('tool/code-dispatch', { ...trace, isError: true, content: [{ type: 'text', text: String(error?.message ?? error) }] })
+      session?.append(dispatchEvent, { ...trace, isError: true, content: [{ type: 'text', text: String(error?.message ?? error) }] })
       throw error
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-py-codeact",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "CodeAct agent loop for the DeepSeek Harness: a persistent IPython session as the model's action space, with harness tools bridged in as a virtual `__dsh__.tools` module.",
   "license": "MIT",
   "repository": {