Update createAITools() to support callable backends

[aron-cf]

The exec tool in @cloudflare/computer was built for one shape of
work: run a shell command, wait for it to finish, and hand the model a
single object with the drained stdout and stderr. That shape no
longer fits the workspace. The JavaScript backend runs a module rather
than a shell command, takes a structured input value, and returns a
structured value of its own. Both the shell and module backends can now
take per-run environment variables. None of this was reachable through
the tool, and because the tool only ever returned one object at the very
end, a long-running command produced no visible output until it was
completely done.

This change teaches the tool the two things it was missing: how to talk
to a callable backend, and how to stream output as it happens.

A backend is marked callable through its description, which is how the
tool knows it may accept input and produce a result. The tool adds
env and input arguments and forwards them to the runtime. When a
callable backend returns a value, that value comes back on a result
field, present only when there is one to report. If the model aims
input at a backend that is not callable, the tool rejects the call
immediately with a clear message instead of sending it over the wire to
fail there.

createAITools({
  workspace,
  shell: {
    defaultBackend: "shell",
    backends: {
      shell: { description: "just-bash in a Dynamic Worker" },
      container: { description: "full Linux userland" },
      js: {
        description: "JavaScript module runtime; returns a value",
        callable: true,
      },
    },
  },
});

A callable run passes a module as the command, a structured input, and
reads the module's return value back on result.

// tool call
{
  "backend": "js",
  "command": "export default (input) => ({ doubled: input.value * 2 })",
  "input": { "value": 42 },
  "env": { "API_KEY": "secret" }
}

// final tool output
{
  "command": "export default (input) => ({ doubled: input.value * 2 })",
  "cwd": null,
  "backend": "js",
  "exitCode": 0,
  "stdout": "",
  "stderr": "",
  "result": { "doubled": 84 }
}

Pointing input at a plain shell backend never reaches the runtime:

{
  "command": "echo hi",
  "cwd": null,
  "backend": "shell",
  "error": "Backend \"shell\" is not callable; it does not accept structured input."
}

The second half of the change restores streaming. The runtime already
exposes a live stream of output events, and the AI SDK lets a tool yield
a sequence of results rather than a single one. The tool now consumes
that stream and yields a fresh snapshot on every chunk of output, so the
model watches a command's stdout and stderr grow in real time. A
running snapshot carries a null exit code; the final snapshot carries
the real exit code, and for a callable backend, the return value.

sequenceDiagram
  participant Model
  participant Tool
  participant Runtime
  Model->>Tool: exec("npm test")
  Runtime-->>Tool: stdout chunk
  Tool-->>Model: snapshot (exitCode null)
  Runtime-->>Tool: stderr chunk
  Tool-->>Model: snapshot (exitCode null)
  Runtime-->>Tool: exit 0
  Tool-->>Model: final snapshot (exitCode 0)

Loading

A single call now emits several outputs as the work proceeds:

{ "command": "run", "backend": "shell", "exitCode": null, "stdout": "one\n",     "stderr": "" }
{ "command": "run", "backend": "shell", "exitCode": null, "stdout": "one\n",     "stderr": "warn\n" }
{ "command": "run", "backend": "shell", "exitCode": null, "stdout": "one\ntwo\n", "stderr": "warn\n" }
{ "command": "run", "backend": "shell", "exitCode": 0,    "stdout": "one\ntwo\n", "stderr": "warn\n" }

Streaming only engages when the runtime handle can be iterated. A handle
that only exposes a final result still works: the tool drains it and
yields one snapshot, so callers that hand the tool a non-streaming handle
see no change in behavior. Output is still truncated on whole-character
boundaries to keep replies small, and a failure mid-stream yields a
structured error snapshot rather than throwing.

A callable backend's return value settles at the same instant as the
exit code, so the tool carries it on the exit event alongside that code
rather than on a separate event a consumer would have to collect and
correlate. The runtime wire still sends the value on its own event
today, so the tool accepts both forms and reads the value from whichever
arrives; consolidating the wire itself is a follow up, after which the
standalone event can go.

The tool now publishes the types a caller needs to build a handle or
consume the streamed output: ExecStreamEvent for a single output
event, ExecRuntimeHandle for the handle the runtime returns, and
ExecToolOutput for the snapshot shape.

To verify the behavior locally, run the tool tests:

npm test --workspace @cloudflare/computer -- src/tools/ai.test.ts

The suite covers both halves: forwarding env and input, surfacing
result, the fast local rejection of input on a non-callable backend,
streamed stdout and stderr snapshots, the callable value on the final
streamed snapshot, byte-boundary truncation of streamed output, and a
mid-stream failure.

This works on both major versions of the AI SDK the package supports.
The async-iterating tool function and the two-argument Tool type it
relies on are present in the oldest release named in the package's peer
range, so no version bump is required. A continuous integration matrix
that installs each supported major version and runs the tool tests
against both would make that guarantee permanent, and is worth adding as
a follow up.

[aron-cf]

Closed in favor of #46