code-mode: define transport-neutral runtime types (#29170)

## Summary

- introduce a private `session_runtime` boundary for cell creation
requests, observation modes, lifecycle events, output items, and tool
metadata
- update the cell actor and in-process service to use those
transport-neutral types
- keep cell ID allocation on the owning session side

## Motivation

Cell lifecycle vocabulary currently lives inside the cell actor
implementation. That makes the service adapter and future session
runtime depend on actor-specific types, increasing the size and
complexity of the runtime ownership change.

This is the first reviewable slice of the session-runtime stack. It
separates the transport-neutral data model without moving lifecycle
ownership or changing behavior.

Later slices will move session state behind this boundary, harden
terminal and shutdown behavior, and split cell creation from
observation.

## Behavior

There are no public API or user-visible behavior changes in this PR.

In particular:

- `CodeModeSession::execute` and `wait` are unchanged
- cell IDs remain allocated by the owning session
- cell admission, observation, termination, and shutdown behavior are
unchanged

codex-rs/code-mode/src/session_runtime/mod.rs

@@ -0,0 +1,10 @@
+mod types;
+
+pub(crate) use self::types::CellEvent;
+pub(crate) use self::types::CreateCellRequest;
+pub(crate) use self::types::ImageDetail;
+pub(crate) use self::types::ObserveMode;
+pub(crate) use self::types::OutputItem;
+pub(crate) use self::types::ToolDefinition;
+pub(crate) use self::types::ToolKind;
+pub(crate) use self::types::ToolName;

codex-rs/code-mode/src/session_runtime/types.rs

@@ -0,0 +1,79 @@
+use std::time::Duration;
+
+/// Selects the next observable frontier for a running cell.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum ObserveMode {
+    YieldAfter(Duration),
+    PendingFrontier,
+}
+
+/// An observable cell lifecycle event.
+#[derive(Clone, Debug, PartialEq)]
+pub(crate) enum CellEvent {
+    Yielded {
+        content_items: Vec<OutputItem>,
+    },
+    Pending {
+        content_items: Vec<OutputItem>,
+        pending_tool_call_ids: Vec<String>,
+    },
+    Completed {
+        content_items: Vec<OutputItem>,
+        error_text: Option<String>,
+    },
+    Terminated {
+        content_items: Vec<OutputItem>,
+    },
+}
+
+/// Output emitted by a cell since its preceding observation.
+#[derive(Clone, Debug, PartialEq)]
+pub(crate) enum OutputItem {
+    Text {
+        text: String,
+    },
+    Image {
+        image_url: String,
+        detail: Option<ImageDetail>,
+    },
+}
+
+/// Requested image fidelity for an output image.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum ImageDetail {
+    Auto,
+    Low,
+    High,
+    Original,
+}
+
+/// Transport-neutral input for creating a cell.
+///
+/// The owning session assigns the cell ID when it admits the request.
+pub(crate) struct CreateCellRequest {
+    pub(crate) tool_call_id: String,
+    pub(crate) enabled_tools: Vec<ToolDefinition>,
+    pub(crate) source: String,
+}
+
+/// Tool metadata exposed to code running inside a cell.
+pub(crate) struct ToolDefinition {
+    pub(crate) name: String,
+    pub(crate) tool_name: ToolName,
+    pub(crate) description: String,
+    pub(crate) kind: ToolKind,
+}
+
+/// A tool name with an optional namespace.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct ToolName {
+    pub(crate) name: String,
+    pub(crate) namespace: Option<String>,
+}
+
+/// The JavaScript calling convention for a tool.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum ToolKind {
+    Function,
+    Freeform,
+}