fix(daytona): stop the lifecycle tools crashing on a non-string sandboxId

start/stop/delete echo sandboxId back as the output id when the API returns
no body, via params.sandboxId.trim() inside transformResponse - after the
request has already gone out. sandboxId is declared type: 'string' but
arrives unvalidated, and now that safeUrlPathSegment accepts a numeric id a
number builds a URL, sends the DELETE/START/STOP, and only then throws an
unnamed TypeError. Both the old and new behaviour fail, so this is not a
regression of a working workflow, but for delete_sandbox the side effect is
irreversible and the caller cannot tell what happened.

Fixed with a shared resolveSandboxId in utils.ts rather than a coercion at
each of the three sites: utils.ts already owns every sandbox-id helper, the
three tools already import from it, and the reasoning belongs in one place.
The encoded value cannot be reused - it is percent-encoded and would be
wrong as an output id. Behaviour for a string is unchanged.

Author: waleedlatif1

apps/sim/tools/daytona/delete_sandbox.ts

@@ -6,6 +6,7 @@ import {
   extractDaytonaError,
   mapDaytonaSandbox,
   parseDaytonaJson,
+  resolveSandboxId,
 } from '@/tools/daytona/utils'
 import type { ToolConfig } from '@/tools/types'
 
@@ -48,7 +49,7 @@ export const daytonaDeleteSandboxTool: ToolConfig<
     const data = await parseDaytonaJson(response)
     const sandbox = mapDaytonaSandbox(data)
     if (!sandbox.id && params) {
-      sandbox.id = params.sandboxId.trim()
+      sandbox.id = resolveSandboxId(params.sandboxId)
     }
     return {
       success: true,

apps/sim/tools/daytona/sandbox_path_safety.test.ts

@@ -180,3 +180,45 @@ describe('encodeSandboxId', () => {
     expect(encodeSandboxId(sandboxId)).toBe(sandboxId)
   })
 })
+
+/**
+ * The lifecycle tools echo `sandboxId` back as the output id when the API
+ * returns no body. That runs in `transformResponse`, so the sandbox has already
+ * been started, stopped, or irreversibly deleted by the time it executes — a
+ * `.trim()` on a non-string id would surface the successful call as an unnamed
+ * `TypeError`. `sandboxId` is declared `type: 'string'` but arrives unvalidated,
+ * and `safeUrlPathSegment` now accepts a numeric id, so a number reaches here.
+ */
+describe('the sandbox id echoed back by the lifecycle tools', () => {
+  const lifecycleTools = [
+    daytonaTools.daytonaStartSandboxTool,
+    daytonaTools.daytonaStopSandboxTool,
+    daytonaTools.daytonaDeleteSandboxTool,
+  ] as AnyTool[]
+
+  const emptyBody = () => new Response('', { status: 200 })
+
+  it.each(lifecycleTools.map((tool) => [tool.id, tool] as const))(
+    '%s reports a numeric sandboxId instead of throwing after the request went out',
+    async (_id, tool) => {
+      const result = await tool.transformResponse!(emptyBody(), {
+        apiKey: 'k',
+        sandboxId: 12345 as unknown as string,
+      })
+
+      expect(result.output.sandbox.id).toBe('12345')
+    }
+  )
+
+  it.each(lifecycleTools.map((tool) => [tool.id, tool] as const))(
+    '%s still trims a string sandboxId',
+    async (_id, tool) => {
+      const result = await tool.transformResponse!(emptyBody(), {
+        apiKey: 'k',
+        sandboxId: '  sbx_abc123  ',
+      })
+
+      expect(result.output.sandbox.id).toBe('sbx_abc123')
+    }
+  )
+})

apps/sim/tools/daytona/start_sandbox.ts

@@ -6,6 +6,7 @@ import {
   extractDaytonaError,
   mapDaytonaSandbox,
   parseDaytonaJson,
+  resolveSandboxId,
 } from '@/tools/daytona/utils'
 import type { ToolConfig } from '@/tools/types'
 
@@ -48,7 +49,7 @@ export const daytonaStartSandboxTool: ToolConfig<
     const data = await parseDaytonaJson(response)
     const sandbox = mapDaytonaSandbox(data)
     if (!sandbox.id && params) {
-      sandbox.id = params.sandboxId.trim()
+      sandbox.id = resolveSandboxId(params.sandboxId)
     }
     return {
       success: true,

apps/sim/tools/daytona/stop_sandbox.ts

@@ -6,6 +6,7 @@ import {
   extractDaytonaError,
   mapDaytonaSandbox,
   parseDaytonaJson,
+  resolveSandboxId,
 } from '@/tools/daytona/utils'
 import type { ToolConfig } from '@/tools/types'
 
@@ -46,7 +47,7 @@ export const daytonaStopSandboxTool: ToolConfig<DaytonaStopSandboxParams, Dayton
       const data = await parseDaytonaJson(response)
       const sandbox = mapDaytonaSandbox(data)
       if (!sandbox.id && params) {
-        sandbox.id = params.sandboxId.trim()
+        sandbox.id = resolveSandboxId(params.sandboxId)
       }
       return {
         success: true,

apps/sim/tools/daytona/utils.ts

@@ -18,6 +18,25 @@ export function encodeSandboxId(sandboxId: string): string {
   return safeUrlPathSegment(sandboxId, 'Sandbox ID')
 }
 
+/**
+ * The sandbox identifier as it should read back in a tool's output, for the
+ * lifecycle responses that return no body of their own.
+ *
+ * `sandboxId` is declared `type: 'string'`, but the value arrives unvalidated
+ * from an LLM tool call or stored workflow state and a numeric-looking id can
+ * land as a JSON number — the same widening {@link safeUrlPathSegment} accepts.
+ * This runs inside `transformResponse`, so the request has *already* been sent:
+ * a bare `.trim()` here would throw an unnamed `TypeError` after the sandbox was
+ * started, stopped, or irreversibly deleted. Stringifying keeps the call's
+ * result reportable.
+ *
+ * Only reached for a value {@link encodeSandboxId} already accepted, so the
+ * rejection of unusable shapes stays where it belongs — before the request.
+ */
+export function resolveSandboxId(sandboxId: string | number | bigint): string {
+  return String(sandboxId).trim()
+}
+
 /**
  * Builds a toolbox API URL for a sandbox-scoped endpoint.
  */