dsh-ptc-plus 0.2.4 → 0.3.2

package/internal/runtime-bridge-owner.js

@@ -19,6 +19,8 @@ import {
   toolCapabilityMetadata,
 } from './program-bindings.js'
 import { deepFreeze } from './record-utils.js'
+import { withReplMemorySnapshot } from './repl-memory-projection.js'
+import { generatedRunCodeDescriptionMeta } from './run-code-description.js'
 
 export const RUN_CODE = 'run_code'
 
@@ -123,6 +125,7 @@ export function createRuntimeBridgeOwner({
   ctx,
   sessionConfig,
   maxNestedRunCodeDepth,
+  presentationGeneration,
   sessionId,
   toolSchemasForAgent,
 }) {
@@ -247,7 +250,7 @@ export function createRuntimeBridgeOwner({
     return { request: { ...request, bindings: projected }, release }
   }
 
-  const patchResultMetadata = (agent) => {
+  const patchRunCodeDefinition = (agent) => {
     const definition = ctx.tools.get(RUN_CODE, agent)
     if (definition === undefined) {
       throw new Error('ptc-plus: run_code definition is unavailable for the owning session')
@@ -257,28 +260,65 @@ export function createRuntimeBridgeOwner({
     }
     if (patchedDefinitions.has(definition)) return
     const output = definition.output
-    const original = output.presentationMeta
-    const patched = (args, value) => {
-      if (!active) return original === undefined ? undefined : original(args, value)
-      const base = original === undefined ? undefined : original(args, value)
+    const originalPresentationMeta = output.presentationMeta
+    const patchedPresentationMeta = (args, value) => {
+      if (!active) {
+        return originalPresentationMeta === undefined
+          ? undefined
+          : originalPresentationMeta(args, value)
+      }
+      const base = originalPresentationMeta === undefined
+        ? undefined
+        : originalPresentationMeta(args, value)
       const current = scope.getStore()
       const settlement = current?.settlement
-      if (settlement === undefined) return base
+      if (settlement === undefined) return generatedRunCodeDescriptionMeta(args, base)
       let meta = withJournal(base, settlement.journal)
       if (settlement.recoveryBoundaries !== undefined) {
         meta = withRecoveryBoundaries(meta, settlement.recoveryBoundaries)
       }
-      return settlement.rewrites === undefined ? meta : withRewrites(meta, settlement.rewrites)
+      if (settlement.rewrites !== undefined) meta = withRewrites(meta, settlement.rewrites)
+      meta = generatedRunCodeDescriptionMeta(args, meta)
+      return withReplMemorySnapshot(meta, settlement.replMemory, presentationGeneration)
     }
+    const ownExecute = Object.getOwnPropertyDescriptor(definition, 'execute')
+    const originalExecute = definition.execute
+    const patchedExecute = typeof originalExecute !== 'function'
+      ? undefined
+      : function (args, exec) {
+          const executionArguments = scope.getStore()?.executionArguments ?? args
+          return originalExecute.call(this, executionArguments, exec)
+        }
+    let presentationPatched = false
     try {
       Object.defineProperty(output, 'presentationMeta', {
         configurable: true,
         enumerable: true,
         writable: true,
-        value: patched,
+        value: patchedPresentationMeta,
+      })
+      presentationPatched = true
+      if (patchedExecute !== undefined) {
+        Object.defineProperty(definition, 'execute', {
+          configurable: true,
+          enumerable: ownExecute?.enumerable ?? true,
+          writable: true,
+          value: patchedExecute,
+        })
+      }
+      patchedDefinitions.set(definition, {
+        definition,
+        output,
+        originalPresentationMeta,
+        patchedPresentationMeta,
+        ownExecute,
+        patchedExecute,
       })
-      patchedDefinitions.set(definition, { output, original, patched })
     } catch (error) {
+      if (presentationPatched && output.presentationMeta === patchedPresentationMeta) {
+        if (originalPresentationMeta === undefined) delete output.presentationMeta
+        else output.presentationMeta = originalPresentationMeta
+      }
       throw new Error(`ptc-plus: cannot attach the session journal to run_code results: ${error.message}`)
     }
   }
@@ -333,11 +373,11 @@ export function createRuntimeBridgeOwner({
         throw error
       }
     },
-    handleExecute(exec, next) {
+    handleExecute(exec, next, executionArguments = exec.arguments) {
       if (exec.parent !== undefined) return scope.run(undefined, next)
       const id = sessionId(exec.agent)
       if (id === undefined) return next()
-      patchResultMetadata(exec.agent)
+      patchRunCodeDefinition(exec.agent)
       const inherited = scope.getStore()
       const persistedCallSeq = inherited?.persistedCallSeq
       const current = {
@@ -349,6 +389,7 @@ export function createRuntimeBridgeOwner({
           : { deferredSettlement: inherited.deferredSettlement }),
         session: exec.agent?.session,
         agent: exec.agent,
+        executionArguments,
       }
       if (current.deferredSettlement !== undefined) {
         current.deferredSettlement.current = current
@@ -363,6 +404,7 @@ export function createRuntimeBridgeOwner({
             meta = withRecoveryBoundaries(meta, settlement.recoveryBoundaries)
           }
           if (settlement.rewrites !== undefined) meta = withRewrites(meta, settlement.rewrites)
+          meta = withReplMemorySnapshot(meta, settlement.replMemory, presentationGeneration)
           return { ...result, meta }
         }
         return result
@@ -405,10 +447,16 @@ export function createRuntimeBridgeOwner({
         if (ownRun === undefined) delete runtime.run
         else Object.defineProperty(runtime, 'run', ownRun)
       }
-      for (const { output, original, patched } of patchedDefinitions.values()) {
-        if (output.presentationMeta !== patched) continue
-        if (original === undefined) delete output.presentationMeta
-        else output.presentationMeta = original
+      for (const patched of patchedDefinitions.values()) {
+        if (patched.output.presentationMeta === patched.patchedPresentationMeta) {
+          if (patched.originalPresentationMeta === undefined) delete patched.output.presentationMeta
+          else patched.output.presentationMeta = patched.originalPresentationMeta
+        }
+        if (patched.patchedExecute !== undefined
+          && patched.definition.execute === patched.patchedExecute) {
+          if (patched.ownExecute === undefined) delete patched.definition.execute
+          else Object.defineProperty(patched.definition, 'execute', patched.ownExecute)
+        }
       }
       patchedDefinitions.clear()
       await sessions.dispose()

package/internal/runtime-config.js

@@ -18,9 +18,12 @@ const BUDGET_KEYS = Object.freeze([
 
 /** Boolean runtime behavior switches. */
 const BOOLEAN_KEYS = Object.freeze([
+  'enhancedToolView',
+  'autoDescribeRunCode',
   'cordisToolsEnabled',
   'canonicalizeToolCalls',
   'looseTopLevelRedeclarations',
+  'looseTopLevelFunctionClassRedeclarations',
   'durableReplay',
   'autoRewriteImports',
   'autoStripExports',

package/internal/session-cell-executor.js

@@ -12,11 +12,13 @@ import {
   LONG_CELL_CODE_UNITS,
   markBindingFailure,
   messageOf,
+  missingDescriptionPath,
   oneLineMessage,
   safeProperty,
 } from './failure-reporting.js'
 import { assertStateName } from './session-journal.js'
 import { PreflightError, prepareProgram } from './cell-analysis.js'
+import { LIVE_DEFAULT_EXPORT_BINDING } from './repl-rewrite-contract.js'
 import { ModuleRewriteError } from './cell-rewriter.js'
 import { mapSourcePosition } from './source-position-map.js'
 import { durabilityState, transitionDurability } from './session-state.js'
@@ -104,9 +106,47 @@ function preflightDiagnostic(error) {
   })
 }
 
+function committedRedeclarationSet(message, prepared) {
+  if (!Array.isArray(message.committedRedeclarations)) {
+    throw new Error('kernel returned an invalid committed redeclaration set')
+  }
+  const allowed = prepared.commitTargets
+  const committed = new Set()
+  for (const name of message.committedRedeclarations) {
+    if (typeof name !== 'string' || committed.has(name) || !allowed.has(name)) {
+      throw new Error('kernel returned an invalid committed redeclaration set')
+    }
+    committed.add(name)
+  }
+  return committed
+}
+
 function collisionDiagnostic(collisions) {
   const names = [...new Set(collisions.map(item => item.name))]
+  const reasons = new Set(collisions.map(item => item.reason).filter(Boolean))
+  const disabledKinds = new Set(collisions
+    .filter(item => item.reason === 'function-class-redeclarations-disabled')
+    .map(item => item.kind))
   const first = collisions[0]
+  const alternatives = [
+    ...(disabledKinds.size === 2
+      ? ['assign function or class expressions to the existing writable bindings']
+      : disabledKinds.has('function')
+        ? ['assign a function expression to the existing writable binding']
+        : disabledKinds.has('class')
+          ? ['assign a class expression to the existing writable binding']
+          : []),
+    ...((reasons.size === 0 || reasons.has('variable-redeclarations-disabled'))
+      ? ['reuse the existing bindings']
+      : []),
+  ]
+  const help = [
+    ...(reasons.has('binding-not-writable')
+      ? ['use a fresh name because the existing binding is immutable']
+      : []),
+    ...(alternatives.length === 0 ? [] : [alternatives.join('; ')]),
+    'place one-off declarations inside a block',
+  ]
   return diagnostic({
     code: 'PTC-N001',
     severity: 'error',
@@ -114,10 +154,7 @@ function collisionDiagnostic(collisions) {
     message: `top-level bindings already exist: ${names.join(', ')}. This cell was not executed; the REPL state is unchanged.`,
     stateEffect: 'unchanged',
     source: { cell: 'current', start: first.start, end: first.end },
-    help: [
-      'reuse the existing bindings',
-      'place one-off declarations inside a block',
-    ],
+    help,
   })
 }
 
@@ -128,7 +165,11 @@ function exceptionDiagnostic({
   declared,
   longCellFailure = false,
 }) {
-  const message = firstLine(error.message, 'Unknown exception')
+  const missingPath = error.name === 'ToolCallError' ? missingDescriptionPath(error) : undefined
+  const missingDescription = missingPath !== undefined
+  const message = missingDescription
+    ? `nested native tool arguments are missing required \`description\` at JSON path $.${missingPath} (${error.toolName ?? 'unknown tool'}); this does not satisfy the outer run_code transport`
+    : firstLine(error.message, 'Unknown exception')
   const rawName = typeof error.name === 'string' && error.name.length > 0
     ? error.name
     /* c8 ignore next */
@@ -147,7 +188,9 @@ function exceptionDiagnostic({
     ...(cause === undefined ? {} : { cause }),
     ...(source === undefined ? {} : { source }),
     help: [
-      'inspect existing bindings and retry only the failing expression',
+      ...(missingDescription
+        ? ['add a string `description` property to the nested native-tool argument object']
+        : ['inspect existing bindings and retry only the failing expression']),
       ...(error.name === 'ToolCallError'
         && typeof error.toolName === 'string'
         && error.toolName.startsWith('cordis_')
@@ -211,22 +254,28 @@ export class SessionCellExecutor {
     }
 
     const catalog = kernel.bindingCatalog.inputs()
-    const looseTopLevelRedeclarations = replayRecord === undefined
-      ? config.looseTopLevelRedeclarations
-      : replayRecord.bindingMode === 'loose'
+    const bindingPolicy = replayRecord === undefined ? {
+      variableRedeclarations: config.looseTopLevelRedeclarations,
+      functionClassRedeclarations: config.looseTopLevelFunctionClassRedeclarations,
+    } : replayRecord.bindingPolicy
     const rewritesEnabled = replayRecord === undefined ? {
       autoRewriteImports: config.autoRewriteImports,
       autoStripExports: config.autoStripExports,
       autoSplitRedeclarations: config.autoSplitRedeclarations,
     } : replayRecord.rewritePolicy
+    const moduleSemantics = replayRecord === undefined ? {
+      defaultExportBinding: LIVE_DEFAULT_EXPORT_BINDING,
+    } : replayRecord.moduleSemantics
     const prepareCell = program => prepareProgram(
       program,
       catalog.knownBindings,
-      looseTopLevelRedeclarations,
+      bindingPolicy,
       request.bindingDescriptors.reservedNames,
       rewritesEnabled,
       catalog.importBindings,
       catalog.importNamespaces,
+      catalog.writableBindings,
+      moduleSemantics,
     )
     let prepared
     try {
@@ -341,6 +390,7 @@ export class SessionCellExecutor {
           type: 'run', id, program: prepared.code, namespaces: bindings.workerDescriptors,
           moduleLoads: prepared.moduleLoads,
           returnSignal: prepared.returnSignal,
+          commitSignal: prepared.commitSignal,
           maxOutputBytes: config.maxOutputBytes,
           valueLimits,
           durability,
@@ -473,6 +523,20 @@ export class SessionCellExecutor {
       }, true)
       return
     }
+    let committed
+    try {
+      committed = committedRedeclarationSet(message, active.prepared)
+    } catch (error) {
+      active.resolve(earlyResult('worker-exit', messageOf(error)), true)
+      return
+    }
+    active.appliedBindingCatalog = message.moduleLoadFailed === true
+      ? active.priorBindingCatalog
+      : active.priorBindingCatalog.advance(
+          active.prepared,
+          active.request.program,
+          committed,
+        )
     if (typeof message.error === 'string') {
       const rawError = {
         kind: 'exception',
@@ -494,9 +558,6 @@ export class SessionCellExecutor {
         declared: message.moduleLoadFailed === true ? new Set() : active.prepared.declared,
         longCellFailure: active.request.program.length >= LONG_CELL_CODE_UNITS,
       })
-      active.appliedBindingCatalog = message.moduleLoadFailed === true
-        ? active.priorBindingCatalog
-        : active.priorBindingCatalog.advance(active.prepared)
       const recordedFailure = active.replay?.diagnostics?.find(item => item.code === 'PTC-X001')
       const failure = recordedFailure?.message === actualFailure.message ? recordedFailure : actualFailure
       const error = {
@@ -525,7 +586,6 @@ export class SessionCellExecutor {
         hasValue: message.hasValue,
         ...(message.hasValue ? { value } : {}),
       }
-      active.appliedBindingCatalog = active.priorBindingCatalog.advance(active.prepared)
       if (active.replay?.completion?.kind === 'return'
         && (active.replay.completion.hasValue !== message.hasValue
           || (message.hasValue && !valueWiresEqual(active.replay.completion.value, value, active.valueLimits)))) {

package/internal/session-events.js

@@ -0,0 +1,7 @@
+/** Read the immutable session log across current and legacy DSH session APIs. */
+export function sessionEvents(session) {
+  if (typeof session?.snapshotEvents === 'function') {
+    return session.snapshotEvents()
+  }
+  return session?.events
+}