Update pyproject.toml

Co-authored-by: openhands <openhands@all-hands.dev>
Co-authored-by: Engel Nyst <enyst@users.noreply.github.com>

.github/scripts/update_pr_description.sh

@@ -13,9 +13,9 @@ DOCKER_RUN_COMMAND="docker run -it --rm \
   -p 3000:3000 \
   -v /var/run/docker.sock:/var/run/docker.sock \
   --add-host host.docker.internal:host-gateway \
-  -e SANDBOX_RUNTIME_CONTAINER_IMAGE=docker.all-hands.dev/openhands/runtime:${SHORT_SHA}-nikolaik \
+  -e SANDBOX_RUNTIME_CONTAINER_IMAGE=docker.openhands.dev/openhands/runtime:${SHORT_SHA}-nikolaik \
   --name openhands-app-${SHORT_SHA} \
-  docker.all-hands.dev/openhands/openhands:${SHORT_SHA}"
+  docker.openhands.dev/openhands/openhands:${SHORT_SHA}"
 
 # Define the uvx command
 UVX_RUN_COMMAND="uvx --python 3.12 --from git+https://github.com/OpenHands/OpenHands@${BRANCH_NAME}#subdirectory=openhands-cli openhands"

.github/workflows/py-tests.yml

@@ -176,6 +176,7 @@ jobs:
 
   coverage-comment:
     name: Coverage Comment
+    if: github.event_name == 'pull_request'
     runs-on: ubuntu-latest
     needs: [test-on-linux, test-enterprise, test-cli-python]
 
@@ -195,23 +196,8 @@ jobs:
         run: ln -sf openhands-cli/openhands_cli openhands_cli
 
       - name: Coverage comment
-        # In PR mode leaves a comment, otherwise records coverage in branch python-coverage-comment-action-data.
         id: coverage_comment
         uses: py-cov-action/python-coverage-comment-action@v3
         with:
           GITHUB_TOKEN: ${{ github.token }}
           MERGE_COVERAGE_FILES: true
-
-      - name: Enforce coverage
-        # Fail if on PR AND there are uncovered lines AND diff coverage is less than total coverage.
-        # To debug, try a step to log outputs like: `echo ${{ toJSON(steps.coverage_comment.outputs) }}`
-        # Once we track base branch, reference_percent_covered will be better to use than new_percent_covered.
-        if: ${{ github.event_name == 'pull_request' && fromJSON(steps.coverage_comment.outputs.diff_total_num_violations) > 0 && steps.coverage_comment.outputs.diff_total_percent_covered < steps.coverage_comment.outputs.new_percent_covered }}
-        run: |
-          echo "Coverage decreased, which is not allowed."
-          echo "Please add some unit tests for the modified code."
-          echo
-          echo "  diff_total_num_violations: ${{ steps.coverage_comment.outputs.diff_total_num_violations }}"
-          echo "  diff_total_percent_covered: ${{ steps.coverage_comment.outputs.diff_total_percent_covered}}"
-          echo "  new_percent_covered: ${{ steps.coverage_comment.outputs.new_percent_covered}}"
-          exit 1

Development.md

@@ -159,7 +159,7 @@ poetry run pytest ./tests/unit/test_*.py
 To reduce build time (e.g., if no changes were made to the client-runtime component), you can use an existing Docker
 container image by setting the SANDBOX_RUNTIME_CONTAINER_IMAGE environment variable to the desired Docker image.
 
-Example: `export SANDBOX_RUNTIME_CONTAINER_IMAGE=ghcr.io/openhands/runtime:0.59-nikolaik`
+Example: `export SANDBOX_RUNTIME_CONTAINER_IMAGE=ghcr.io/openhands/runtime:0.60-nikolaik`
 
 ## Develop inside Docker container
 

README.md

@@ -66,10 +66,10 @@ See the [uv installation guide](https://docs.astral.sh/uv/getting-started/instal
 **Launch OpenHands**:
 ```bash
 # Launch the GUI server
-uvx --python 3.12 --from openhands-ai openhands serve
+uvx --python 3.12 openhands serve
 
 # Or launch the CLI
-uvx --python 3.12 --from openhands-ai openhands
+uvx --python 3.12 openhands
 ```
 
 You'll find OpenHands running at [http://localhost:3000](http://localhost:3000) (for GUI mode)!
@@ -82,17 +82,17 @@ You'll find OpenHands running at [http://localhost:3000](http://localhost:3000)
 You can also run OpenHands directly with Docker:
 
 ```bash
-docker pull docker.all-hands.dev/all-hands-ai/runtime:0.59-nikolaik
+docker pull docker.openhands.dev/openhands/runtime:0.60-nikolaik
 
 docker run -it --rm --pull=always \
-    -e SANDBOX_RUNTIME_CONTAINER_IMAGE=docker.all-hands.dev/all-hands-ai/runtime:0.59-nikolaik \
+    -e SANDBOX_RUNTIME_CONTAINER_IMAGE=docker.openhands.dev/openhands/runtime:0.60-nikolaik \
     -e LOG_ALL_EVENTS=true \
     -v /var/run/docker.sock:/var/run/docker.sock \
     -v ~/.openhands:/.openhands \
     -p 3000:3000 \
     --add-host host.docker.internal:host-gateway \
     --name openhands-app \
-    docker.all-hands.dev/all-hands-ai/openhands:0.59
+    docker.openhands.dev/openhands/openhands:0.60
 ```
 
 </details>

containers/dev/compose.yml

@@ -12,7 +12,7 @@ services:
       - SANDBOX_API_HOSTNAME=host.docker.internal
       - DOCKER_HOST_ADDR=host.docker.internal
       #
-      - SANDBOX_RUNTIME_CONTAINER_IMAGE=${SANDBOX_RUNTIME_CONTAINER_IMAGE:-ghcr.io/openhands/runtime:0.59-nikolaik}
+      - SANDBOX_RUNTIME_CONTAINER_IMAGE=${SANDBOX_RUNTIME_CONTAINER_IMAGE:-ghcr.io/openhands/runtime:0.60-nikolaik}
       - SANDBOX_USER_ID=${SANDBOX_USER_ID:-1234}
       - WORKSPACE_MOUNT_PATH=${WORKSPACE_BASE:-$PWD/workspace}
     ports:

docker-compose.yml

@@ -7,7 +7,7 @@ services:
     image: openhands:latest
     container_name: openhands-app-${DATE:-}
     environment:
-      - SANDBOX_RUNTIME_CONTAINER_IMAGE=${SANDBOX_RUNTIME_CONTAINER_IMAGE:-docker.all-hands.dev/openhands/runtime:0.59-nikolaik}
+      - SANDBOX_RUNTIME_CONTAINER_IMAGE=${SANDBOX_RUNTIME_CONTAINER_IMAGE:-docker.openhands.dev/openhands/runtime:0.60-nikolaik}
       #- SANDBOX_USER_ID=${SANDBOX_USER_ID:-1234} # enable this only if you want a specific non-root sandbox user but you will have to manually adjust permissions of ~/.openhands for this user
       - WORKSPACE_MOUNT_PATH=${WORKSPACE_BASE:-$PWD/workspace}
     ports:

enterprise/poetry.lock

@@ -5759,8 +5759,8 @@ wsproto = ">=1.2.0"
 [package.source]
 type = "git"
 url = "https://github.com/OpenHands/agent-sdk.git"
-reference = "ce0a71af55dfce101f7419fbdb0116178f01e109"
-resolved_reference = "ce0a71af55dfce101f7419fbdb0116178f01e109"
+reference = "3d8af53b2f0259dc98555a4acd4238f90e0afbce"
+resolved_reference = "3d8af53b2f0259dc98555a4acd4238f90e0afbce"
 subdirectory = "openhands-agent-server"
 
 [[package]]
@@ -5805,9 +5805,9 @@ memory-profiler = "^0.61.0"
 numpy = "*"
 openai = "1.99.9"
 openhands-aci = "0.3.2"
-openhands-agent-server = {git = "https://github.com/OpenHands/agent-sdk.git", rev = "ce0a71af55dfce101f7419fbdb0116178f01e109", subdirectory = "openhands-agent-server"}
-openhands-sdk = {git = "https://github.com/OpenHands/agent-sdk.git", rev = "ce0a71af55dfce101f7419fbdb0116178f01e109", subdirectory = "openhands-sdk"}
-openhands-tools = {git = "https://github.com/OpenHands/agent-sdk.git", rev = "ce0a71af55dfce101f7419fbdb0116178f01e109", subdirectory = "openhands-tools"}
+openhands-agent-server = {git = "https://github.com/OpenHands/agent-sdk.git", rev = "3d8af53b2f0259dc98555a4acd4238f90e0afbce", subdirectory = "openhands-agent-server"}
+openhands-sdk = {git = "https://github.com/OpenHands/agent-sdk.git", rev = "3d8af53b2f0259dc98555a4acd4238f90e0afbce", subdirectory = "openhands-sdk"}
+openhands-tools = {git = "https://github.com/OpenHands/agent-sdk.git", rev = "3d8af53b2f0259dc98555a4acd4238f90e0afbce", subdirectory = "openhands-tools"}
 opentelemetry-api = "^1.33.1"
 opentelemetry-exporter-otlp-proto-grpc = "^1.33.1"
 pathspec = "^0.12.1"
@@ -5887,8 +5887,8 @@ boto3 = ["boto3 (>=1.35.0)"]
 [package.source]
 type = "git"
 url = "https://github.com/OpenHands/agent-sdk.git"
-reference = "ce0a71af55dfce101f7419fbdb0116178f01e109"
-resolved_reference = "ce0a71af55dfce101f7419fbdb0116178f01e109"
+reference = "3d8af53b2f0259dc98555a4acd4238f90e0afbce"
+resolved_reference = "3d8af53b2f0259dc98555a4acd4238f90e0afbce"
 subdirectory = "openhands-sdk"
 
 [[package]]
@@ -5914,8 +5914,8 @@ pydantic = ">=2.11.7"
 [package.source]
 type = "git"
 url = "https://github.com/OpenHands/agent-sdk.git"
-reference = "ce0a71af55dfce101f7419fbdb0116178f01e109"
-resolved_reference = "ce0a71af55dfce101f7419fbdb0116178f01e109"
+reference = "3d8af53b2f0259dc98555a4acd4238f90e0afbce"
+resolved_reference = "3d8af53b2f0259dc98555a4acd4238f90e0afbce"
 subdirectory = "openhands-tools"
 
 [[package]]

evaluation/benchmarks/multi_swe_bench/compute_skip_ids.py

@@ -0,0 +1,79 @@
+import argparse
+import fnmatch
+import json
+from collections import Counter
+from pathlib import Path
+
+
+def find_final_reports(base_dir, pattern=None):
+    base_path = Path(base_dir)
+    if not base_path.exists():
+        raise FileNotFoundError(f'Base directory does not exist: {base_dir}')
+
+    # Find all final_report.json files
+    all_reports = list(base_path.rglob('final_report.json'))
+
+    if pattern is None:
+        return all_reports
+
+    # Filter by pattern
+    filtered_reports = []
+    for report in all_reports:
+        # Get relative path from base_dir for matching
+        rel_path = report.relative_to(base_path)
+        if fnmatch.fnmatch(str(rel_path), pattern):
+            filtered_reports.append(report)
+
+    return filtered_reports
+
+
+def collect_resolved_ids(report_files):
+    id_counter = Counter()
+
+    for report_file in report_files:
+        with open(report_file, 'r') as f:
+            data = json.load(f)
+            if 'resolved_ids' not in data:
+                raise KeyError(f"'resolved_ids' key not found in {report_file}")
+            resolved_ids = data['resolved_ids']
+            id_counter.update(resolved_ids)
+
+    return id_counter
+
+
+def get_skip_ids(id_counter, threshold):
+    return [id_str for id_str, count in id_counter.items() if count >= threshold]
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Compute SKIP_IDS from resolved IDs in final_report.json files'
+    )
+    parser.add_argument(
+        'threshold',
+        type=int,
+        help='Minimum number of times an ID must be resolved to be skipped',
+    )
+    parser.add_argument(
+        '--base-dir',
+        default='evaluation/evaluation_outputs/outputs',
+        help='Base directory to search for final_report.json files (default: evaluation/evaluation_outputs/outputs)',
+    )
+    parser.add_argument(
+        '--pattern',
+        default=None,
+        help='Glob pattern to filter paths (e.g., "*Multi-SWE-RL*/**/*gpt*")',
+    )
+
+    args = parser.parse_args()
+    report_files = find_final_reports(args.base_dir, args.pattern)
+    id_counter = collect_resolved_ids(report_files)
+
+    skip_ids = get_skip_ids(id_counter, args.threshold)
+    skip_ids = [s.replace('/', '__').replace(':pr-', '-') for s in skip_ids]
+    skip_ids = ','.join(sorted(skip_ids))
+    print(skip_ids)
+
+
+if __name__ == '__main__':
+    main()

evaluation/benchmarks/multi_swe_bench/run_infer.py

@@ -747,10 +747,14 @@ def filter_dataset(dataset: pd.DataFrame, filter_column: str) -> pd.DataFrame:
                 subset = dataset[dataset[filter_column].isin(selected_ids)]
                 logger.info(f'Retained {subset.shape[0]} tasks after filtering')
                 return subset
-    skip_ids = os.environ.get('SKIP_IDS', '').split(',')
+    skip_ids = [id for id in os.environ.get('SKIP_IDS', '').split(',') if id]
     if len(skip_ids) > 0:
+        logger.info(f'Dataset size before filtering: {dataset.shape[0]} tasks')
         logger.info(f'Filtering {len(skip_ids)} tasks from "SKIP_IDS"...')
-        return dataset[~dataset[filter_column].isin(skip_ids)]
+        logger.info(f'SKIP_IDS:\n{skip_ids}')
+        filtered_dataset = dataset[~dataset[filter_column].isin(skip_ids)]
+        logger.info(f'Dataset size after filtering: {filtered_dataset.shape[0]} tasks')
+        return filtered_dataset
     return dataset
 
 
@@ -768,6 +772,11 @@ if __name__ == '__main__':
         default='test',
         help='split to evaluate on',
     )
+    parser.add_argument(
+        '--filter_dataset_after_sampling',
+        action='store_true',
+        help='if provided, filter dataset after sampling instead of before',
+    )
     args, _ = parser.parse_known_args()
 
     # NOTE: It is preferable to load datasets from huggingface datasets and perform post-processing
@@ -777,10 +786,24 @@ if __name__ == '__main__':
     logger.info(f'Loading dataset {args.dataset} with split {args.split} ')
     dataset = load_dataset('json', data_files=args.dataset)
     dataset = dataset[args.split]
-    swe_bench_tests = filter_dataset(dataset.to_pandas(), 'instance_id')
-    logger.info(
-        f'Loaded dataset {args.dataset} with split {args.split}: {len(swe_bench_tests)} tasks'
-    )
+    swe_bench_tests = dataset.to_pandas()
+
+    # Determine filter strategy based on flag
+    filter_func = None
+    if args.filter_dataset_after_sampling:
+        # Pass filter as callback to apply after sampling
+        def filter_func(df):
+            return filter_dataset(df, 'instance_id')
+
+        logger.info(
+            f'Loaded dataset {args.dataset} with split {args.split}: {len(swe_bench_tests)} tasks (filtering will occur after sampling)'
+        )
+    else:
+        # Apply filter before sampling
+        swe_bench_tests = filter_dataset(swe_bench_tests, 'instance_id')
+        logger.info(
+            f'Loaded dataset {args.dataset} with split {args.split}: {len(swe_bench_tests)} tasks'
+        )
 
     llm_config = None
     if args.llm_config:
@@ -810,7 +833,9 @@ if __name__ == '__main__':
 
     output_file = os.path.join(metadata.eval_output_dir, 'output.jsonl')
     print(f'### OUTPUT FILE: {output_file} ###')
-    instances = prepare_dataset(swe_bench_tests, output_file, args.eval_n_limit)
+    instances = prepare_dataset(
+        swe_bench_tests, output_file, args.eval_n_limit, filter_func=filter_func
+    )
 
     if len(instances) > 0 and not isinstance(
         instances['FAIL_TO_PASS'][instances['FAIL_TO_PASS'].index[0]], str

evaluation/benchmarks/multi_swe_bench/scripts/rollout_multi_swegym.sh

@@ -8,8 +8,14 @@
 MODEL=$1  # eg your llm config name in config.toml (eg: "llm.claude-3-5-sonnet-20241022-t05")
 EXP_NAME=$2 # "train-t05"
 EVAL_DATASET=$3  # path to original dataset (jsonl file)
-N_WORKERS=${4:-64}
-N_RUNS=${5:-1}
+MAX_ITER=$4
+N_WORKERS=${5:-64}
+N_RUNS=${6:-1}
+EVAL_LIMIT=${7:-}
+SKIP_IDS_THRESHOLD=$8
+SKIP_IDS_PATTERN=$9
+INPUT_SKIP_IDS=${10}
+FILTER_DATASET_AFTER_SAMPLING=${11:-}
 
 export EXP_NAME=$EXP_NAME
 # use 2x resources for rollout since some codebases are pretty resource-intensive
@@ -17,6 +23,7 @@ export DEFAULT_RUNTIME_RESOURCE_FACTOR=2
 echo "MODEL: $MODEL"
 echo "EXP_NAME: $EXP_NAME"
 echo "EVAL_DATASET: $EVAL_DATASET"
+echo "INPUT_SKIP_IDS: $INPUT_SKIP_IDS"
 # Generate DATASET path by adding _with_runtime_ before .jsonl extension
 DATASET="${EVAL_DATASET%.jsonl}_with_runtime_.jsonl"  # path to converted dataset
 
@@ -35,9 +42,6 @@ else
     export SANDBOX_REMOTE_RUNTIME_API_URL="https://runtime.eval.all-hands.dev"
 fi
 
-#EVAL_LIMIT=3000
-MAX_ITER=100
-
 
 # ===== Run inference =====
 source "evaluation/utils/version_control.sh"
@@ -69,17 +73,52 @@ function run_eval() {
     --dataset $DATASET \
     --split $SPLIT"
 
+  # Conditionally add filter flag
+  if [ "$FILTER_DATASET_AFTER_SAMPLING" = "true" ]; then
+    COMMAND="$COMMAND --filter_dataset_after_sampling"
+  fi
+
   echo "Running command: $COMMAND"
   if [ -n "$EVAL_LIMIT" ]; then
     echo "EVAL_LIMIT: $EVAL_LIMIT"
     COMMAND="$COMMAND --eval-n-limit $EVAL_LIMIT"
   fi
 
-  # Run the command
   eval $COMMAND
 }
 
 for run_idx in $(seq 1 $N_RUNS); do
+    if [ -n "$SKIP_IDS_THRESHOLD" ]; then
+        echo "Computing SKIP_IDS for run $run_idx..."
+        SKIP_CMD="poetry run python evaluation/benchmarks/multi_swe_bench/compute_skip_ids.py $SKIP_IDS_THRESHOLD"
+        if [ -n "$SKIP_IDS_PATTERN" ]; then
+            SKIP_CMD="$SKIP_CMD --pattern \"$SKIP_IDS_PATTERN\""
+        fi
+        COMPUTED_SKIP_IDS=$(eval $SKIP_CMD)
+        SKIP_STATUS=$?
+        if [ $SKIP_STATUS -ne 0 ]; then
+            echo "ERROR: Skip IDs computation failed with exit code $SKIP_STATUS"
+            exit $SKIP_STATUS
+        fi
+        echo "COMPUTED_SKIP_IDS: $COMPUTED_SKIP_IDS"
+    else
+        echo "SKIP_IDS_THRESHOLD not provided, skipping SKIP_IDS computation"
+        COMPUTED_SKIP_IDS=""
+    fi
+
+    # Concatenate COMPUTED_SKIP_IDS and INPUT_SKIP_IDS
+    if [ -n "$COMPUTED_SKIP_IDS" ] && [ -n "$INPUT_SKIP_IDS" ]; then
+        export SKIP_IDS="${COMPUTED_SKIP_IDS},${INPUT_SKIP_IDS}"
+    elif [ -n "$COMPUTED_SKIP_IDS" ]; then
+        export SKIP_IDS="$COMPUTED_SKIP_IDS"
+    elif [ -n "$INPUT_SKIP_IDS" ]; then
+        export SKIP_IDS="$INPUT_SKIP_IDS"
+    else
+        unset SKIP_IDS
+    fi
+
+    echo "FINAL SKIP_IDS: $SKIP_IDS"
+    echo ""
 
     while true; do
         echo "### Running inference... ###"

evaluation/utils/shared.py

@@ -9,7 +9,7 @@ import time
 import traceback
 from contextlib import contextmanager
 from inspect import signature
-from typing import Any, Awaitable, Callable, TextIO
+from typing import Any, Awaitable, Callable, Optional, TextIO
 
 import pandas as pd
 from pydantic import BaseModel
@@ -222,6 +222,7 @@ def prepare_dataset(
     eval_n_limit: int,
     eval_ids: list[str] | None = None,
     skip_num: int | None = None,
+    filter_func: Optional[Callable[[pd.DataFrame], pd.DataFrame]] = None,
 ):
     assert 'instance_id' in dataset.columns, (
         "Expected 'instance_id' column in the dataset. You should define your own unique identifier for each instance and use it as the 'instance_id' column."
@@ -265,6 +266,12 @@ def prepare_dataset(
             f'Randomly sampling {eval_n_limit} unique instances with random seed 42.'
         )
 
+    if filter_func is not None:
+        dataset = filter_func(dataset)
+        logger.info(
+            f'Applied filter after sampling: {len(dataset)} instances remaining'
+        )
+
     def make_serializable(instance_dict: dict) -> dict:
         import numpy as np
 

frontend/__tests__/components/features/payment/payment-form.test.tsx

@@ -188,172 +188,4 @@ describe("PaymentForm", () => {
       expect(mockMutate).not.toHaveBeenCalled();
     });
   });
-
-  describe("Cancel Subscription", () => {
-    const getSubscriptionAccessSpy = vi.spyOn(
-      BillingService,
-      "getSubscriptionAccess",
-    );
-    const cancelSubscriptionSpy = vi.spyOn(
-      BillingService,
-      "cancelSubscription",
-    );
-
-    beforeEach(() => {
-      // Mock active subscription
-      getSubscriptionAccessSpy.mockResolvedValue({
-        start_at: "2024-01-01T00:00:00Z",
-        end_at: "2024-12-31T23:59:59Z",
-        created_at: "2024-01-01T00:00:00Z",
-      });
-    });
-
-    it("should render cancel subscription button when user has active subscription", async () => {
-      renderPaymentForm();
-
-      await waitFor(() => {
-        const cancelButton = screen.getByTestId("cancel-subscription-button");
-        expect(cancelButton).toBeInTheDocument();
-        expect(cancelButton).toHaveTextContent("PAYMENT$CANCEL_SUBSCRIPTION");
-      });
-    });
-
-    it("should not render cancel subscription button when user has no subscription", async () => {
-      getSubscriptionAccessSpy.mockResolvedValue(null);
-      renderPaymentForm();
-
-      await waitFor(() => {
-        const cancelButton = screen.queryByTestId("cancel-subscription-button");
-        expect(cancelButton).not.toBeInTheDocument();
-      });
-    });
-
-    it("should show confirmation modal when cancel subscription button is clicked", async () => {
-      const user = userEvent.setup();
-      renderPaymentForm();
-
-      const cancelButton = await screen.findByTestId(
-        "cancel-subscription-button",
-      );
-      await user.click(cancelButton);
-
-      // Should show confirmation modal
-      expect(
-        screen.getByTestId("cancel-subscription-modal"),
-      ).toBeInTheDocument();
-      expect(
-        screen.getByText("PAYMENT$CANCEL_SUBSCRIPTION_TITLE"),
-      ).toBeInTheDocument();
-      // The message should be rendered (either with Trans component or regular text)
-      const modalContent = screen.getByTestId("cancel-subscription-modal");
-      expect(modalContent).toBeInTheDocument();
-      expect(screen.getByTestId("confirm-cancel-button")).toBeInTheDocument();
-      expect(screen.getByTestId("modal-cancel-button")).toBeInTheDocument();
-    });
-
-    it("should close modal when cancel button in modal is clicked", async () => {
-      const user = userEvent.setup();
-      renderPaymentForm();
-
-      const cancelButton = await screen.findByTestId(
-        "cancel-subscription-button",
-      );
-      await user.click(cancelButton);
-
-      // Modal should be visible
-      expect(
-        screen.getByTestId("cancel-subscription-modal"),
-      ).toBeInTheDocument();
-
-      // Click cancel in modal
-      const modalCancelButton = screen.getByTestId("modal-cancel-button");
-      await user.click(modalCancelButton);
-
-      // Modal should be closed
-      expect(
-        screen.queryByTestId("cancel-subscription-modal"),
-      ).not.toBeInTheDocument();
-    });
-
-    it("should call cancel subscription API when confirm button is clicked", async () => {
-      const user = userEvent.setup();
-      renderPaymentForm();
-
-      const cancelButton = await screen.findByTestId(
-        "cancel-subscription-button",
-      );
-      await user.click(cancelButton);
-
-      // Click confirm in modal
-      const confirmButton = screen.getByTestId("confirm-cancel-button");
-      await user.click(confirmButton);
-
-      // Should call the cancel subscription API
-      expect(cancelSubscriptionSpy).toHaveBeenCalled();
-    });
-
-    it("should close modal after successful cancellation", async () => {
-      const user = userEvent.setup();
-      cancelSubscriptionSpy.mockResolvedValue({
-        status: "success",
-        message: "Subscription cancelled successfully",
-      });
-      renderPaymentForm();
-
-      const cancelButton = await screen.findByTestId(
-        "cancel-subscription-button",
-      );
-      await user.click(cancelButton);
-
-      const confirmButton = screen.getByTestId("confirm-cancel-button");
-      await user.click(confirmButton);
-
-      // Wait for API call to complete and modal to close
-      await waitFor(() => {
-        expect(
-          screen.queryByTestId("cancel-subscription-modal"),
-        ).not.toBeInTheDocument();
-      });
-    });
-
-    it("should show next billing date for active subscription", async () => {
-      // Mock active subscription with end_at as next billing date
-      getSubscriptionAccessSpy.mockResolvedValue({
-        start_at: "2024-01-01T00:00:00Z",
-        end_at: "2025-01-01T00:00:00Z",
-        created_at: "2024-01-01T00:00:00Z",
-        cancelled_at: null,
-        stripe_subscription_id: "sub_123",
-      });
-
-      renderPaymentForm();
-
-      await waitFor(() => {
-        const nextBillingInfo = screen.getByTestId("next-billing-date");
-        expect(nextBillingInfo).toBeInTheDocument();
-        // Check that it contains some date-related content (translation key or actual date)
-        expect(nextBillingInfo).toHaveTextContent(
-          /2025|PAYMENT.*BILLING.*DATE/,
-        );
-      });
-    });
-
-    it("should not show next billing date when subscription is cancelled", async () => {
-      // Mock cancelled subscription
-      getSubscriptionAccessSpy.mockResolvedValue({
-        start_at: "2024-01-01T00:00:00Z",
-        end_at: "2025-01-01T00:00:00Z",
-        created_at: "2024-01-01T00:00:00Z",
-        cancelled_at: "2024-06-15T10:30:00Z",
-        stripe_subscription_id: "sub_123",
-      });
-
-      renderPaymentForm();
-
-      await waitFor(() => {
-        const nextBillingInfo = screen.queryByTestId("next-billing-date");
-        expect(nextBillingInfo).not.toBeInTheDocument();
-      });
-    });
-  });
 });

frontend/__tests__/components/jupyter/jupyter.test.tsx

@@ -1,47 +0,0 @@
-import { render, screen } from "@testing-library/react";
-import { JupyterEditor } from "#/components/features/jupyter/jupyter";
-import { vi, describe, it, expect, beforeEach } from "vitest";
-import { AgentState } from "#/types/agent-state";
-import { useAgentState } from "#/hooks/use-agent-state";
-import { useJupyterStore } from "#/state/jupyter-store";
-
-// Mock the agent state hook
-vi.mock("#/hooks/use-agent-state", () => ({
-  useAgentState: vi.fn(),
-}));
-
-// Mock react-i18next
-vi.mock("react-i18next", () => ({
-  useTranslation: () => ({
-    t: (key: string) => key,
-  }),
-}));
-
-describe("JupyterEditor", () => {
-  beforeEach(() => {
-    // Reset the Zustand store before each test
-    useJupyterStore.setState({
-      cells: Array(20).fill({
-        content: "Test cell content",
-        type: "input",
-        imageUrls: undefined,
-      }),
-    });
-  });
-
-  it("should have a scrollable container", () => {
-    // Mock agent state to return RUNNING state (not in RUNTIME_INACTIVE_STATES)
-    vi.mocked(useAgentState).mockReturnValue({
-      curAgentState: AgentState.RUNNING,
-    });
-
-    render(
-      <div style={{ height: "100vh" }}>
-        <JupyterEditor maxWidth={800} />
-      </div>,
-    );
-
-    const container = screen.getByTestId("jupyter-container");
-    expect(container).toHaveClass("flex-1 overflow-y-auto");
-  });
-});

frontend/__tests__/components/terminal/terminal.test.tsx

@@ -11,6 +11,7 @@ const renderTerminal = (commands: Command[] = []) => {
 };
 
 describe.skip("Terminal", () => {
+  // Terminal is now read-only - no user input functionality
   global.ResizeObserver = vi.fn().mockImplementation(() => ({
     observe: vi.fn(),
     disconnect: vi.fn(),
@@ -21,8 +22,6 @@ describe.skip("Terminal", () => {
     write: vi.fn(),
     writeln: vi.fn(),
     dispose: vi.fn(),
-    onKey: vi.fn(),
-    attachCustomKeyEventHandler: vi.fn(),
     loadAddon: vi.fn(),
   };
 

frontend/__tests__/conversation-websocket-handler.test.tsx

@@ -1,6 +1,7 @@
 import { describe, it, expect, beforeAll, afterAll, afterEach } from "vitest";
 import { screen, waitFor, render, cleanup } from "@testing-library/react";
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { http, HttpResponse } from "msw";
 import { useOptimisticUserMessageStore } from "#/stores/optimistic-user-message-store";
 import {
   createMockMessageEvent,
@@ -13,8 +14,12 @@ import {
   OptimisticUserMessageStoreComponent,
   ErrorMessageStoreComponent,
 } from "./helpers/websocket-test-components";
-import { ConversationWebSocketProvider } from "#/contexts/conversation-websocket-context";
+import {
+  ConversationWebSocketProvider,
+  useConversationWebSocket,
+} from "#/contexts/conversation-websocket-context";
 import { conversationWebSocketTestSetup } from "./helpers/msw-websocket-setup";
+import { useEventStore } from "#/stores/use-event-store";
 
 // MSW WebSocket mock setup
 const { wsLink, server: mswServer } = conversationWebSocketTestSetup();
@@ -417,7 +422,206 @@ describe("Conversation WebSocket Handler", () => {
     it.todo("should handle send attempts when disconnected");
   });
 
-  // 8. Terminal I/O Tests (ExecuteBashAction and ExecuteBashObservation)
+  // 8. History Loading State Tests
+  describe("History Loading State", () => {
+    it("should track history loading state using event count from API", async () => {
+      const conversationId = "test-conversation-with-history";
+
+      // Mock the event count API to return 3 events
+      const expectedEventCount = 3;
+
+      // Create 3 mock events to simulate history
+      const mockHistoryEvents = [
+        createMockUserMessageEvent({ id: "history-event-1" }),
+        createMockMessageEvent({ id: "history-event-2" }),
+        createMockMessageEvent({ id: "history-event-3" }),
+      ];
+
+      // Set up MSW to mock both the HTTP API and WebSocket connection
+      mswServer.use(
+        http.get("/api/v1/events/count", ({ request }) => {
+          const url = new URL(request.url);
+          const conversationIdParam = url.searchParams.get(
+            "conversation_id__eq",
+          );
+
+          if (conversationIdParam === conversationId) {
+            return HttpResponse.json(expectedEventCount);
+          }
+
+          return HttpResponse.json(0);
+        }),
+        wsLink.addEventListener("connection", ({ client, server }) => {
+          server.connect();
+          // Send all history events
+          mockHistoryEvents.forEach((event) => {
+            client.send(JSON.stringify(event));
+          });
+        }),
+      );
+
+      // Create a test component that displays loading state
+      const HistoryLoadingComponent = () => {
+        const context = useConversationWebSocket();
+        const { events } = useEventStore();
+
+        return (
+          <div>
+            <div data-testid="is-loading-history">
+              {context?.isLoadingHistory ? "true" : "false"}
+            </div>
+            <div data-testid="events-received">{events.length}</div>
+            <div data-testid="expected-event-count">{expectedEventCount}</div>
+          </div>
+        );
+      };
+
+      // Render with WebSocket context
+      renderWithWebSocketContext(
+        <HistoryLoadingComponent />,
+        conversationId,
+        `http://localhost:3000/api/conversations/${conversationId}`,
+      );
+
+      // Initially should be loading history
+      expect(screen.getByTestId("is-loading-history")).toHaveTextContent("true");
+
+      // Wait for all events to be received
+      await waitFor(() => {
+        expect(screen.getByTestId("events-received")).toHaveTextContent("3");
+      });
+
+      // Once all events are received, loading should be complete
+      await waitFor(() => {
+        expect(screen.getByTestId("is-loading-history")).toHaveTextContent(
+          "false",
+        );
+      });
+    });
+
+    it("should handle empty conversation history", async () => {
+      const conversationId = "test-conversation-empty";
+
+      // Set up MSW to mock both the HTTP API and WebSocket connection
+      mswServer.use(
+        http.get("/api/v1/events/count", ({ request }) => {
+          const url = new URL(request.url);
+          const conversationIdParam = url.searchParams.get(
+            "conversation_id__eq",
+          );
+
+          if (conversationIdParam === conversationId) {
+            return HttpResponse.json(0);
+          }
+
+          return HttpResponse.json(0);
+        }),
+        wsLink.addEventListener("connection", ({ server }) => {
+          server.connect();
+          // No events sent for empty history
+        }),
+      );
+
+      // Create a test component that displays loading state
+      const HistoryLoadingComponent = () => {
+        const context = useConversationWebSocket();
+
+        return (
+          <div>
+            <div data-testid="is-loading-history">
+              {context?.isLoadingHistory ? "true" : "false"}
+            </div>
+          </div>
+        );
+      };
+
+      // Render with WebSocket context
+      renderWithWebSocketContext(
+        <HistoryLoadingComponent />,
+        conversationId,
+        `http://localhost:3000/api/conversations/${conversationId}`,
+      );
+
+      // Should quickly transition from loading to not loading when count is 0
+      await waitFor(() => {
+        expect(screen.getByTestId("is-loading-history")).toHaveTextContent(
+          "false",
+        );
+      });
+    });
+
+    it("should handle history loading with large event count", async () => {
+      const conversationId = "test-conversation-large-history";
+
+      // Create 50 mock events to simulate large history
+      const expectedEventCount = 50;
+      const mockHistoryEvents = Array.from({ length: 50 }, (_, i) =>
+        createMockMessageEvent({ id: `history-event-${i + 1}` }),
+      );
+
+      // Set up MSW to mock both the HTTP API and WebSocket connection
+      mswServer.use(
+        http.get("/api/v1/events/count", ({ request }) => {
+          const url = new URL(request.url);
+          const conversationIdParam = url.searchParams.get(
+            "conversation_id__eq",
+          );
+
+          if (conversationIdParam === conversationId) {
+            return HttpResponse.json(expectedEventCount);
+          }
+
+          return HttpResponse.json(0);
+        }),
+        wsLink.addEventListener("connection", ({ client, server }) => {
+          server.connect();
+          // Send all history events
+          mockHistoryEvents.forEach((event) => {
+            client.send(JSON.stringify(event));
+          });
+        }),
+      );
+
+      // Create a test component that displays loading state
+      const HistoryLoadingComponent = () => {
+        const context = useConversationWebSocket();
+        const { events } = useEventStore();
+
+        return (
+          <div>
+            <div data-testid="is-loading-history">
+              {context?.isLoadingHistory ? "true" : "false"}
+            </div>
+            <div data-testid="events-received">{events.length}</div>
+          </div>
+        );
+      };
+
+      // Render with WebSocket context
+      renderWithWebSocketContext(
+        <HistoryLoadingComponent />,
+        conversationId,
+        `http://localhost:3000/api/conversations/${conversationId}`,
+      );
+
+      // Initially should be loading history
+      expect(screen.getByTestId("is-loading-history")).toHaveTextContent("true");
+
+      // Wait for all events to be received
+      await waitFor(() => {
+        expect(screen.getByTestId("events-received")).toHaveTextContent("50");
+      });
+
+      // Once all events are received, loading should be complete
+      await waitFor(() => {
+        expect(screen.getByTestId("is-loading-history")).toHaveTextContent(
+          "false",
+        );
+      });
+    });
+  });
+
+  // 9. Terminal I/O Tests (ExecuteBashAction and ExecuteBashObservation)
   describe("Terminal I/O Integration", () => {
     it("should append command to store when ExecuteBashAction event is received", async () => {
       const { createMockExecuteBashActionEvent } = await import(

frontend/__tests__/helpers/msw-websocket-setup.ts

@@ -38,8 +38,7 @@ export const createWebSocketTestSetup = (
 /**
  * Standard WebSocket test setup for conversation WebSocket handler tests
  * Updated to use the V1 WebSocket URL pattern: /sockets/events/{conversationId}
+ * Uses a wildcard pattern to match any conversation ID
  */
 export const conversationWebSocketTestSetup = () =>
-  createWebSocketTestSetup(
-    "ws://localhost:3000/sockets/events/test-conversation-default",
-  );
+  createWebSocketTestSetup("ws://localhost:3000/sockets/events/*");

frontend/__tests__/hooks/use-terminal.test.tsx

@@ -35,13 +35,12 @@ function TestTerminalComponent() {
 }
 
 describe("useTerminal", () => {
+  // Terminal is read-only - no longer tests user input functionality
   const mockTerminal = vi.hoisted(() => ({
     loadAddon: vi.fn(),
     open: vi.fn(),
     write: vi.fn(),
     writeln: vi.fn(),
-    onKey: vi.fn(),
-    attachCustomKeyEventHandler: vi.fn(),
     dispose: vi.fn(),
   }));
 

frontend/__tests__/routes/llm-settings.test.tsx

@@ -4,14 +4,12 @@ import { beforeEach, describe, expect, it, vi } from "vitest";
 import { QueryClientProvider, QueryClient } from "@tanstack/react-query";
 import LlmSettingsScreen from "#/routes/llm-settings";
 import SettingsService from "#/settings-service/settings-service.api";
-import OptionService from "#/api/option-service/option-service.api";
 import {
   MOCK_DEFAULT_USER_SETTINGS,
   resetTestHandlersMockSettings,
 } from "#/mocks/handlers";
 import * as AdvancedSettingsUtlls from "#/utils/has-advanced-settings-set";
 import * as ToastHandlers from "#/utils/custom-toast-handlers";
-import BillingService from "#/api/billing-service/billing-service.api";
 
 // Mock react-router hooks
 const mockUseSearchParams = vi.fn();
@@ -25,12 +23,6 @@ vi.mock("#/hooks/query/use-is-authed", () => ({
   useIsAuthed: () => mockUseIsAuthed(),
 }));
 
-// Mock useIsAllHandsSaaSEnvironment hook
-const mockUseIsAllHandsSaaSEnvironment = vi.fn();
-vi.mock("#/hooks/use-is-all-hands-saas-environment", () => ({
-  useIsAllHandsSaaSEnvironment: () => mockUseIsAllHandsSaaSEnvironment(),
-}));
-
 const renderLlmSettingsScreen = () =>
   render(<LlmSettingsScreen />, {
     wrapper: ({ children }) => (
@@ -54,9 +46,6 @@ beforeEach(() => {
 
   // Default mock for useIsAuthed - returns authenticated by default
   mockUseIsAuthed.mockReturnValue({ data: true, isLoading: false });
-
-  // Default mock for useIsAllHandsSaaSEnvironment - returns true for SaaS environment
-  mockUseIsAllHandsSaaSEnvironment.mockReturnValue(true);
 });
 
 describe("Content", () => {
@@ -605,9 +594,14 @@ describe("Form submission", () => {
     renderLlmSettingsScreen();
 
     await screen.findByTestId("llm-settings-screen");
+    // Component automatically shows advanced view when advanced settings exist
+    // Switch to basic view to test clearing advanced settings
     const advancedSwitch = screen.getByTestId("advanced-settings-switch");
     await userEvent.click(advancedSwitch);
 
+    // Now we should be in basic view
+    await screen.findByTestId("llm-settings-form-basic");
+
     const provider = screen.getByTestId("llm-provider-input");
     const model = screen.getByTestId("llm-model-input");
 
@@ -731,405 +725,3 @@ describe("Status toasts", () => {
     });
   });
 });
-
-describe("SaaS mode", () => {
-  describe("SaaS subscription", () => {
-    // Common mock configurations
-    const MOCK_SAAS_CONFIG = {
-      APP_MODE: "saas" as const,
-      GITHUB_CLIENT_ID: "fake-github-client-id",
-      POSTHOG_CLIENT_KEY: "fake-posthog-client-key",
-      FEATURE_FLAGS: {
-        ENABLE_BILLING: true,
-        HIDE_LLM_SETTINGS: false,
-        ENABLE_JIRA: false,
-        ENABLE_JIRA_DC: false,
-        ENABLE_LINEAR: false,
-      },
-    };
-
-    const MOCK_ACTIVE_SUBSCRIPTION = {
-      start_at: "2024-01-01",
-      end_at: "2024-12-31",
-      created_at: "2024-01-01",
-    };
-
-    it("should show upgrade banner and prevent all interactions for unsubscribed SaaS users", async () => {
-      // Mock SaaS mode without subscription
-      const getConfigSpy = vi.spyOn(OptionService, "getConfig");
-      getConfigSpy.mockResolvedValue(MOCK_SAAS_CONFIG);
-
-      // Mock subscription access to return null (no subscription)
-      const getSubscriptionAccessSpy = vi.spyOn(
-        BillingService,
-        "getSubscriptionAccess",
-      );
-      getSubscriptionAccessSpy.mockResolvedValue(null);
-
-      // Mock saveSettings to ensure it's not called
-      const saveSettingsSpy = vi.spyOn(SettingsService, "saveSettings");
-
-      renderLlmSettingsScreen();
-      await screen.findByTestId("llm-settings-screen");
-
-      // Should show upgrade banner
-      expect(screen.getByTestId("upgrade-banner")).toBeInTheDocument();
-
-      // Should have a clickable upgrade button
-      const upgradeButton = screen.getByRole("button", { name: /upgrade/i });
-      expect(upgradeButton).toBeInTheDocument();
-      expect(upgradeButton).not.toBeDisabled();
-
-      // Form should be disabled
-      const form = screen.getByTestId("llm-settings-form-basic");
-      expect(form).toHaveAttribute("aria-disabled", "true");
-
-      // All form inputs should be disabled or non-interactive
-      const providerInput = screen.getByTestId("llm-provider-input");
-      const modelInput = screen.getByTestId("llm-model-input");
-      const apiKeyInput = screen.getByTestId("llm-api-key-input");
-      const advancedSwitch = screen.getByTestId("advanced-settings-switch");
-      const submitButton = screen.getByTestId("submit-button");
-
-      // Inputs should be disabled
-      expect(providerInput).toBeDisabled();
-      expect(modelInput).toBeDisabled();
-      expect(apiKeyInput).toBeDisabled();
-      expect(advancedSwitch).toBeDisabled();
-      expect(submitButton).toBeDisabled();
-
-      // Confirmation mode switch is in advanced view, so it's not visible in basic view
-      expect(
-        screen.queryByTestId("enable-confirmation-mode-switch"),
-      ).not.toBeInTheDocument();
-
-      // Try to interact with inputs - they should not respond
-      await userEvent.click(providerInput);
-      await userEvent.type(apiKeyInput, "test-key");
-
-      // Values should not change
-      expect(apiKeyInput).toHaveValue("");
-
-      // Try to submit form - should not call API
-      await userEvent.click(submitButton);
-      expect(saveSettingsSpy).not.toHaveBeenCalled();
-    });
-
-    it("should call subscription checkout API when upgrade button is clicked", async () => {
-      // Mock SaaS mode without subscription
-      const getConfigSpy = vi.spyOn(OptionService, "getConfig");
-      getConfigSpy.mockResolvedValue(MOCK_SAAS_CONFIG);
-
-      // Mock subscription access to return null (no subscription)
-      const getSubscriptionAccessSpy = vi.spyOn(
-        BillingService,
-        "getSubscriptionAccess",
-      );
-      getSubscriptionAccessSpy.mockResolvedValue(null);
-
-      // Mock the subscription checkout API call
-      const createSubscriptionCheckoutSessionSpy = vi.spyOn(
-        BillingService,
-        "createSubscriptionCheckoutSession",
-      );
-      createSubscriptionCheckoutSessionSpy.mockResolvedValue({});
-
-      renderLlmSettingsScreen();
-      await screen.findByTestId("llm-settings-screen");
-
-      // Click the upgrade button
-      const upgradeButton = screen.getByRole("button", { name: /upgrade/i });
-      await userEvent.click(upgradeButton);
-
-      // Should call the subscription checkout API
-      expect(createSubscriptionCheckoutSessionSpy).toHaveBeenCalled();
-    });
-
-    it("should disable upgrade button for unauthenticated users in SaaS mode", async () => {
-      // Mock SaaS mode without subscription
-      const getConfigSpy = vi.spyOn(OptionService, "getConfig");
-      getConfigSpy.mockResolvedValue(MOCK_SAAS_CONFIG);
-
-      // Mock subscription access to return null (no subscription)
-      const getSubscriptionAccessSpy = vi.spyOn(
-        BillingService,
-        "getSubscriptionAccess",
-      );
-      getSubscriptionAccessSpy.mockResolvedValue(null);
-
-      // Mock subscription checkout API
-      const createSubscriptionCheckoutSessionSpy = vi.spyOn(
-        BillingService,
-        "createSubscriptionCheckoutSession",
-      );
-
-      // Mock authentication to return false (unauthenticated) from the start
-      mockUseIsAuthed.mockReturnValue({ data: false, isLoading: false });
-
-      // Mock settings to return default settings even when unauthenticated
-      // This is necessary because the useSettings hook is disabled when user is not authenticated
-      const getSettingsSpy = vi.spyOn(SettingsService, "getSettings");
-      getSettingsSpy.mockResolvedValue(MOCK_DEFAULT_USER_SETTINGS);
-
-      renderLlmSettingsScreen();
-
-      // Wait for either the settings screen or skeleton to appear
-      await waitFor(() => {
-        const settingsScreen = screen.queryByTestId("llm-settings-screen");
-        const skeleton = screen.queryByTestId("app-settings-skeleton");
-        expect(settingsScreen || skeleton).toBeInTheDocument();
-      });
-
-      // If we get the skeleton, the test scenario isn't valid - skip the rest
-      if (screen.queryByTestId("app-settings-skeleton")) {
-        // For unauthenticated users, the settings don't load, so no upgrade banner is shown
-        // This is the expected behavior - unauthenticated users see a skeleton loading state
-        expect(screen.queryByTestId("upgrade-banner")).not.toBeInTheDocument();
-        return;
-      }
-
-      await screen.findByTestId("llm-settings-screen");
-
-      // Should show upgrade banner
-      expect(screen.getByTestId("upgrade-banner")).toBeInTheDocument();
-
-      // Upgrade button should be disabled for unauthenticated users
-      const upgradeButton = screen.getByRole("button", { name: /upgrade/i });
-      expect(upgradeButton).toBeInTheDocument();
-      expect(upgradeButton).toBeDisabled();
-
-      // Clicking disabled button should not call the API
-      await userEvent.click(upgradeButton);
-      expect(createSubscriptionCheckoutSessionSpy).not.toHaveBeenCalled();
-    });
-
-    it("should not show upgrade banner and allow form interaction for subscribed SaaS users", async () => {
-      // Mock SaaS mode with subscription
-      const getConfigSpy = vi.spyOn(OptionService, "getConfig");
-      getConfigSpy.mockResolvedValue(MOCK_SAAS_CONFIG);
-
-      // Mock subscription access to return active subscription
-      const getSubscriptionAccessSpy = vi.spyOn(
-        BillingService,
-        "getSubscriptionAccess",
-      );
-      getSubscriptionAccessSpy.mockResolvedValue(MOCK_ACTIVE_SUBSCRIPTION);
-
-      renderLlmSettingsScreen();
-      await screen.findByTestId("llm-settings-screen");
-
-      // Wait for subscription data to load
-      await waitFor(() => {
-        expect(getSubscriptionAccessSpy).toHaveBeenCalled();
-      });
-
-      // Should NOT show upgrade banner
-      expect(screen.queryByTestId("upgrade-banner")).not.toBeInTheDocument();
-
-      // Form should NOT be disabled
-      const form = screen.getByTestId("llm-settings-form-basic");
-      expect(form).not.toHaveAttribute("aria-disabled", "true");
-    });
-
-    it("should not call save settings API when making changes in disabled form for unsubscribed users", async () => {
-      // Mock SaaS mode without subscription
-      const getConfigSpy = vi.spyOn(OptionService, "getConfig");
-      getConfigSpy.mockResolvedValue(MOCK_SAAS_CONFIG);
-
-      // Mock subscription access to return null (no subscription)
-      const getSubscriptionAccessSpy = vi.spyOn(
-        BillingService,
-        "getSubscriptionAccess",
-      );
-      getSubscriptionAccessSpy.mockResolvedValue(null);
-
-      // Mock saveSettings to track calls
-      const saveSettingsSpy = vi.spyOn(SettingsService, "saveSettings");
-
-      renderLlmSettingsScreen();
-      await screen.findByTestId("llm-settings-screen");
-
-      // Verify that basic form elements are disabled for unsubscribed users
-      const advancedSwitch = screen.getByTestId("advanced-settings-switch");
-      const submitButton = screen.getByTestId("submit-button");
-
-      expect(advancedSwitch).toBeDisabled();
-      expect(submitButton).toBeDisabled();
-
-      // Confirmation mode switch is in advanced view, which can't be accessed when form is disabled
-      expect(
-        screen.queryByTestId("enable-confirmation-mode-switch"),
-      ).not.toBeInTheDocument();
-
-      // Try to submit the form - button should remain disabled
-      await userEvent.click(submitButton);
-
-      // Should NOT call save settings API for unsubscribed users
-      expect(saveSettingsSpy).not.toHaveBeenCalled();
-    });
-
-    it("should show backdrop overlay for unsubscribed users", async () => {
-      // Mock SaaS mode without subscription
-      const getConfigSpy = vi.spyOn(OptionService, "getConfig");
-      getConfigSpy.mockResolvedValue(MOCK_SAAS_CONFIG);
-
-      // Mock subscription access to return null (no subscription)
-      const getSubscriptionAccessSpy = vi.spyOn(
-        BillingService,
-        "getSubscriptionAccess",
-      );
-      getSubscriptionAccessSpy.mockResolvedValue(null);
-
-      renderLlmSettingsScreen();
-      await screen.findByTestId("llm-settings-screen");
-
-      // Wait for subscription data to load
-      await waitFor(() => {
-        expect(getSubscriptionAccessSpy).toHaveBeenCalled();
-      });
-
-      // Should show upgrade banner
-      expect(screen.getByTestId("upgrade-banner")).toBeInTheDocument();
-
-      // Should show backdrop overlay
-      const backdrop = screen.getByTestId("settings-backdrop");
-      expect(backdrop).toBeInTheDocument();
-    });
-
-    it("should not show backdrop overlay for subscribed users", async () => {
-      // Mock SaaS mode with subscription
-      const getConfigSpy = vi.spyOn(OptionService, "getConfig");
-      getConfigSpy.mockResolvedValue(MOCK_SAAS_CONFIG);
-
-      // Mock subscription access to return active subscription
-      const getSubscriptionAccessSpy = vi.spyOn(
-        BillingService,
-        "getSubscriptionAccess",
-      );
-      getSubscriptionAccessSpy.mockResolvedValue(MOCK_ACTIVE_SUBSCRIPTION);
-
-      renderLlmSettingsScreen();
-      await screen.findByTestId("llm-settings-screen");
-
-      // Wait for subscription data to load
-      await waitFor(() => {
-        expect(getSubscriptionAccessSpy).toHaveBeenCalled();
-      });
-
-      // Should NOT show backdrop overlay
-      expect(screen.queryByTestId("settings-backdrop")).not.toBeInTheDocument();
-    });
-
-    it("should display success toast when redirected back with ?checkout=success parameter", async () => {
-      // Mock SaaS mode
-      const getConfigSpy = vi.spyOn(OptionService, "getConfig");
-      getConfigSpy.mockResolvedValue(MOCK_SAAS_CONFIG);
-
-      // Mock subscription access
-      const getSubscriptionAccessSpy = vi.spyOn(
-        BillingService,
-        "getSubscriptionAccess",
-      );
-      getSubscriptionAccessSpy.mockResolvedValue(MOCK_ACTIVE_SUBSCRIPTION);
-
-      // Mock toast handler
-      const displaySuccessToastSpy = vi.spyOn(
-        ToastHandlers,
-        "displaySuccessToast",
-      );
-
-      // Mock URL search params with ?checkout=success
-      mockUseSearchParams.mockReturnValue([
-        {
-          get: (param: string) => (param === "checkout" ? "success" : null),
-        },
-        vi.fn(),
-      ]);
-
-      // Render component with checkout=success parameter
-      renderLlmSettingsScreen();
-      await screen.findByTestId("llm-settings-screen");
-
-      // Verify success toast is displayed with correct message
-      expect(displaySuccessToastSpy).toHaveBeenCalledWith(
-        "SUBSCRIPTION$SUCCESS",
-      );
-    });
-
-    it("should display error toast when redirected back with ?checkout=cancel parameter", async () => {
-      // Mock SaaS mode
-      const getConfigSpy = vi.spyOn(OptionService, "getConfig");
-      getConfigSpy.mockResolvedValue(MOCK_SAAS_CONFIG);
-
-      // Mock subscription access
-      const getSubscriptionAccessSpy = vi.spyOn(
-        BillingService,
-        "getSubscriptionAccess",
-      );
-      getSubscriptionAccessSpy.mockResolvedValue(MOCK_ACTIVE_SUBSCRIPTION);
-
-      // Mock toast handler
-      const displayErrorToastSpy = vi.spyOn(ToastHandlers, "displayErrorToast");
-
-      // Mock URL search params with ?checkout=cancel
-      mockUseSearchParams.mockReturnValue([
-        {
-          get: (param: string) => (param === "checkout" ? "cancel" : null),
-        },
-        vi.fn(),
-      ]);
-
-      // Render component with checkout=cancel parameter
-      renderLlmSettingsScreen();
-      await screen.findByTestId("llm-settings-screen");
-
-      // Verify error toast is displayed with correct message
-      expect(displayErrorToastSpy).toHaveBeenCalledWith("SUBSCRIPTION$FAILURE");
-    });
-
-    it("should show upgrade banner when subscription is expired or disabled", async () => {
-      // Mock SaaS mode
-      const getConfigSpy = vi.spyOn(OptionService, "getConfig");
-      getConfigSpy.mockResolvedValue(MOCK_SAAS_CONFIG);
-
-      // Mock subscription access to return null (expired/disabled subscriptions return null from backend)
-      // The backend only returns active subscriptions within their validity period
-      const getSubscriptionAccessSpy = vi.spyOn(
-        BillingService,
-        "getSubscriptionAccess",
-      );
-      getSubscriptionAccessSpy.mockResolvedValue(null);
-
-      renderLlmSettingsScreen();
-      await screen.findByTestId("llm-settings-screen");
-
-      // Wait for subscription data to load
-      await waitFor(() => {
-        expect(getSubscriptionAccessSpy).toHaveBeenCalled();
-      });
-
-      // Should show upgrade banner for expired/disabled subscriptions (when API returns null)
-      expect(screen.getByTestId("upgrade-banner")).toBeInTheDocument();
-
-      // Form should be disabled
-      const form = screen.getByTestId("llm-settings-form-basic");
-      expect(form).toHaveAttribute("aria-disabled", "true");
-
-      // All form inputs should be disabled
-      const providerInput = screen.getByTestId("llm-provider-input");
-      const modelInput = screen.getByTestId("llm-model-input");
-      const apiKeyInput = screen.getByTestId("llm-api-key-input");
-      const advancedSwitch = screen.getByTestId("advanced-settings-switch");
-
-      expect(providerInput).toBeDisabled();
-      expect(modelInput).toBeDisabled();
-      expect(apiKeyInput).toBeDisabled();
-      expect(advancedSwitch).toBeDisabled();
-
-      // Confirmation mode switch is in advanced view, which can't be accessed when form is disabled
-      expect(
-        screen.queryByTestId("enable-confirmation-mode-switch"),
-      ).not.toBeInTheDocument();
-    });
-  });
-});

frontend/__tests__/services/actions.test.tsx

@@ -5,7 +5,6 @@ import { ActionMessage } from "#/types/message";
 // Mock the store and actions
 const mockDispatch = vi.fn();
 const mockAppendInput = vi.fn();
-const mockAppendJupyterInput = vi.fn();
 
 vi.mock("#/store", () => ({
   default: {
@@ -21,14 +20,6 @@ vi.mock("#/state/command-store", () => ({
   },
 }));
 
-vi.mock("#/state/jupyter-store", () => ({
-  useJupyterStore: {
-    getState: () => ({
-      appendJupyterInput: mockAppendJupyterInput,
-    }),
-  },
-}));
-
 vi.mock("#/state/metrics-slice", () => ({
   setMetrics: vi.fn(),
 }));
@@ -63,10 +54,9 @@ describe("handleActionMessage", () => {
     // Check that appendInput was called with the command
     expect(mockAppendInput).toHaveBeenCalledWith("ls -la");
     expect(mockDispatch).not.toHaveBeenCalled();
-    expect(mockAppendJupyterInput).not.toHaveBeenCalled();
   });
 
-  it("should handle RUN_IPYTHON actions by adding input to Jupyter", async () => {
+  it("should handle RUN_IPYTHON actions as no-op (Jupyter removed)", async () => {
     const { handleActionMessage } = await import("#/services/actions");
 
     const ipythonAction: ActionMessage = {
@@ -84,10 +74,7 @@ describe("handleActionMessage", () => {
     // Handle the action
     handleActionMessage(ipythonAction);
 
-    // Check that appendJupyterInput was called with the code
-    expect(mockAppendJupyterInput).toHaveBeenCalledWith(
-      "print('Hello from Jupyter!')",
-    );
+    // Jupyter functionality has been removed, so nothing should be called
     expect(mockAppendInput).not.toHaveBeenCalled();
   });
 
@@ -112,6 +99,5 @@ describe("handleActionMessage", () => {
     // Check that nothing was dispatched or called
     expect(mockDispatch).not.toHaveBeenCalled();
     expect(mockAppendInput).not.toHaveBeenCalled();
-    expect(mockAppendJupyterInput).not.toHaveBeenCalled();
   });
 });

frontend/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "openhands-frontend",
-  "version": "0.59.0",
+  "version": "0.60.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "openhands-frontend",
-      "version": "0.59.0",
+      "version": "0.60.0",
       "dependencies": {
         "@heroui/react": "^2.8.4",
         "@heroui/use-infinite-scroll": "^2.2.11",

frontend/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openhands-frontend",
-  "version": "0.59.0",
+  "version": "0.60.0",
   "private": true,
   "type": "module",
   "engines": {

frontend/src/api/conversation-service/conversation-service.api.ts

@@ -187,7 +187,7 @@ class ConversationService {
   static async getRuntimeId(
     conversationId: string,
   ): Promise<{ runtime_id: string }> {
-    const url = `/api/conversations/${conversationId}/config`;
+    const url = `${this.getConversationUrl(conversationId)}/config`;
     const { data } = await openHands.get<{ runtime_id: string }>(url, {
       headers: this.getConversationHeaders(),
     });

frontend/src/api/conversation-service/v1-conversation-service.api.ts

@@ -3,6 +3,7 @@ import { openHands } from "../open-hands-axios";
 import { ConversationTrigger, GetVSCodeUrlResponse } from "../open-hands.types";
 import { Provider } from "#/types/settings";
 import { buildHttpBaseUrl } from "#/utils/websocket-url";
+import { buildSessionHeaders } from "#/utils/utils";
 import type {
   V1SendMessageRequest,
   V1SendMessageResponse,
@@ -10,24 +11,10 @@ import type {
   V1AppConversationStartTask,
   V1AppConversationStartTaskPage,
   V1AppConversation,
+  V1SandboxInfo,
 } from "./v1-conversation-service.types";
 
 class V1ConversationService {
-  /**
-   * Build headers for V1 API requests that require session authentication
-   * @param sessionApiKey Session API key for authentication
-   * @returns Headers object with X-Session-API-Key if provided
-   */
-  private static buildSessionHeaders(
-    sessionApiKey?: string | null,
-  ): Record<string, string> {
-    const headers: Record<string, string> = {};
-    if (sessionApiKey) {
-      headers["X-Session-API-Key"] = sessionApiKey;
-    }
-    return headers;
-  }
-
   /**
    * Build the full URL for V1 runtime-specific endpoints
    * @param conversationUrl The conversation URL (e.g., "http://localhost:54928/api/conversations/...")
@@ -160,7 +147,7 @@ class V1ConversationService {
     sessionApiKey?: string | null,
   ): Promise<GetVSCodeUrlResponse> {
     const url = this.buildRuntimeUrl(conversationUrl, "/api/vscode/url");
-    const headers = this.buildSessionHeaders(sessionApiKey);
+    const headers = buildSessionHeaders(sessionApiKey);
 
     // V1 API returns {url: '...'} instead of {vscode_url: '...'}
     // Map it to match the expected interface
@@ -188,7 +175,7 @@ class V1ConversationService {
       conversationUrl,
       `/api/conversations/${conversationId}/pause`,
     );
-    const headers = this.buildSessionHeaders(sessionApiKey);
+    const headers = buildSessionHeaders(sessionApiKey);
 
     const { data } = await axios.post<{ success: boolean }>(
       url,
@@ -216,7 +203,7 @@ class V1ConversationService {
       conversationUrl,
       `/api/conversations/${conversationId}/run`,
     );
-    const headers = this.buildSessionHeaders(sessionApiKey);
+    const headers = buildSessionHeaders(sessionApiKey);
 
     const { data } = await axios.post<{ success: boolean }>(
       url,
@@ -282,6 +269,32 @@ class V1ConversationService {
     return data;
   }
 
+  /**
+   * Batch get V1 sandboxes by their IDs
+   * Returns null for any missing sandboxes
+   *
+   * @param ids Array of sandbox IDs (max 100)
+   * @returns Array of sandboxes or null for missing ones
+   */
+  static async batchGetSandboxes(
+    ids: string[],
+  ): Promise<(V1SandboxInfo | null)[]> {
+    if (ids.length === 0) {
+      return [];
+    }
+    if (ids.length > 100) {
+      throw new Error("Cannot request more than 100 sandboxes at once");
+    }
+
+    const params = new URLSearchParams();
+    ids.forEach((id) => params.append("id", id));
+
+    const { data } = await openHands.get<(V1SandboxInfo | null)[]>(
+      `/api/v1/sandboxes?${params.toString()}`,
+    );
+    return data;
+  }
+
   /**
    * Upload a single file to the V1 conversation workspace
    * V1 API endpoint: POST /api/file/upload/{path}
@@ -305,7 +318,7 @@ class V1ConversationService {
       conversationUrl,
       `/api/file/upload/${encodedPath}`,
     );
-    const headers = this.buildSessionHeaders(sessionApiKey);
+    const headers = buildSessionHeaders(sessionApiKey);
 
     // Create FormData with the file
     const formData = new FormData();
@@ -319,6 +332,37 @@ class V1ConversationService {
       },
     });
   }
+
+  /**
+   * Get the conversation config (runtime_id) for a V1 conversation
+   * @param conversationId The conversation ID
+   * @returns Object containing runtime_id
+   */
+  static async getConversationConfig(
+    conversationId: string,
+  ): Promise<{ runtime_id: string }> {
+    const url = `/api/conversations/${conversationId}/config`;
+    const { data } = await openHands.get<{ runtime_id: string }>(url);
+    return data;
+  }
+
+  /**
+   * Get the count of events for a conversation
+   * Uses the V1 API endpoint: GET /api/v1/events/count
+   *
+   * @param conversationId The conversation ID to get event count for
+   * @returns The number of events in the conversation
+   */
+  static async getEventCount(conversationId: string): Promise<number> {
+    const params = new URLSearchParams();
+    params.append("conversation_id__eq", conversationId);
+
+    const { data } = await openHands.get<number>(
+      `/api/v1/events/count?${params.toString()}`,
+    );
+
+    return data;
+  }
 }
 
 export default V1ConversationService;

frontend/src/api/conversation-service/v1-conversation-service.types.ts

@@ -98,3 +98,18 @@ export interface V1AppConversation {
   conversation_url: string | null;
   session_api_key: string | null;
 }
+
+export interface V1ExposedUrl {
+  name: string;
+  url: string;
+}
+
+export interface V1SandboxInfo {
+  id: string;
+  created_by_user_id: string | null;
+  sandbox_spec_id: string;
+  status: V1SandboxStatus;
+  session_api_key: string | null;
+  exposed_urls: V1ExposedUrl[] | null;
+  created_at: string;
+}

frontend/src/api/event-service/event-service.api.ts

@@ -0,0 +1,41 @@
+import axios from "axios";
+import { buildHttpBaseUrl } from "#/utils/websocket-url";
+import { buildSessionHeaders } from "#/utils/utils";
+import type {
+  ConfirmationResponseRequest,
+  ConfirmationResponseResponse,
+} from "./event-service.types";
+
+class EventService {
+  /**
+   * Respond to a confirmation request in a V1 conversation
+   * @param conversationId The conversation ID
+   * @param conversationUrl The conversation URL (e.g., "http://localhost:54928/api/conversations/...")
+   * @param request The confirmation response request
+   * @param sessionApiKey Session API key for authentication (required for V1)
+   * @returns The confirmation response
+   */
+  static async respondToConfirmation(
+    conversationId: string,
+    conversationUrl: string,
+    request: ConfirmationResponseRequest,
+    sessionApiKey?: string | null,
+  ): Promise<ConfirmationResponseResponse> {
+    // Build the runtime URL using the conversation URL
+    const runtimeUrl = buildHttpBaseUrl(conversationUrl);
+
+    // Build session headers for authentication
+    const headers = buildSessionHeaders(sessionApiKey);
+
+    // Make the API call to the runtime endpoint
+    const { data } = await axios.post<ConfirmationResponseResponse>(
+      `${runtimeUrl}/api/conversations/${conversationId}/events/respond_to_confirmation`,
+      request,
+      { headers },
+    );
+
+    return data;
+  }
+}
+
+export default EventService;

frontend/src/api/event-service/event-service.types.ts

@@ -0,0 +1,8 @@
+export interface ConfirmationResponseRequest {
+  accept: boolean;
+  reason?: string;
+}
+
+export interface ConfirmationResponseResponse {
+  success: boolean;
+}

frontend/src/api/git-service/v1-git-service.api.ts

@@ -0,0 +1,89 @@
+import axios from "axios";
+import { buildHttpBaseUrl } from "#/utils/websocket-url";
+import { buildSessionHeaders } from "#/utils/utils";
+import { mapV1ToV0Status } from "#/utils/git-status-mapper";
+import type {
+  GitChange,
+  GitChangeDiff,
+  V1GitChangeStatus,
+} from "../open-hands.types";
+
+interface V1GitChange {
+  status: V1GitChangeStatus;
+  path: string;
+}
+
+class V1GitService {
+  /**
+   * Build the full URL for V1 runtime-specific endpoints
+   * @param conversationUrl The conversation URL (e.g., "http://localhost:54928/api/conversations/...")
+   * @param path The API path (e.g., "/api/git/changes")
+   * @returns Full URL to the runtime endpoint
+   */
+  private static buildRuntimeUrl(
+    conversationUrl: string | null | undefined,
+    path: string,
+  ): string {
+    const baseUrl = buildHttpBaseUrl(conversationUrl);
+    return `${baseUrl}${path}`;
+  }
+
+  /**
+   * Get git changes for a V1 conversation
+   * Uses the agent server endpoint: GET /api/git/changes/{path}
+   * Maps V1 status types (ADDED, DELETED, etc.) to V0 format (A, D, etc.)
+   *
+   * @param conversationUrl The conversation URL (e.g., "http://localhost:54928/api/conversations/...")
+   * @param sessionApiKey Session API key for authentication (required for V1)
+   * @param path The git repository path (e.g., /workspace/project or /workspace/project/OpenHands)
+   * @returns List of git changes with V0-compatible status types
+   */
+  static async getGitChanges(
+    conversationUrl: string | null | undefined,
+    sessionApiKey: string | null | undefined,
+    path: string,
+  ): Promise<GitChange[]> {
+    const encodedPath = encodeURIComponent(path);
+    const url = this.buildRuntimeUrl(
+      conversationUrl,
+      `/api/git/changes/${encodedPath}`,
+    );
+    const headers = buildSessionHeaders(sessionApiKey);
+
+    // V1 API returns V1GitChangeStatus types, we need to map them to V0 format
+    const { data } = await axios.get<V1GitChange[]>(url, { headers });
+
+    // Map V1 statuses to V0 format for compatibility
+    return data.map((change) => ({
+      status: mapV1ToV0Status(change.status),
+      path: change.path,
+    }));
+  }
+
+  /**
+   * Get git change diff for a specific file in a V1 conversation
+   * Uses the agent server endpoint: GET /api/git/diff/{path}
+   *
+   * @param conversationUrl The conversation URL (e.g., "http://localhost:54928/api/conversations/...")
+   * @param sessionApiKey Session API key for authentication (required for V1)
+   * @param path The file path to get diff for
+   * @returns Git change diff
+   */
+  static async getGitChangeDiff(
+    conversationUrl: string | null | undefined,
+    sessionApiKey: string | null | undefined,
+    path: string,
+  ): Promise<GitChangeDiff> {
+    const encodedPath = encodeURIComponent(path);
+    const url = this.buildRuntimeUrl(
+      conversationUrl,
+      `/api/git/diff/${encodedPath}`,
+    );
+    const headers = buildSessionHeaders(sessionApiKey);
+
+    const { data } = await axios.get<GitChangeDiff>(url, { headers });
+    return data;
+  }
+}
+
+export default V1GitService;

frontend/src/api/open-hands.types.ts

@@ -84,8 +84,13 @@ export interface ResultSet<T> {
   next_page_id: string | null;
 }
 
+/**
+ * @deprecated Use V1GitChangeStatus for new code. This type is maintained for backward compatibility with V0 API.
+ */
 export type GitChangeStatus = "M" | "A" | "D" | "R" | "U";
 
+export type V1GitChangeStatus = "MOVED" | "ADDED" | "DELETED" | "UPDATED";
+
 export interface GitChange {
   status: GitChangeStatus;
   path: string;

frontend/src/components/features/chat/chat-interface.tsx

@@ -48,6 +48,7 @@ import {
 } from "#/types/v1/type-guards";
 import { useActiveConversation } from "#/hooks/query/use-active-conversation";
 import { useTaskPolling } from "#/hooks/query/use-task-polling";
+import { useConversationWebSocket } from "#/contexts/conversation-websocket-context";
 
 function getEntryPoint(
   hasRepository: boolean | null,
@@ -64,6 +65,7 @@ export function ChatInterface() {
   const { errorMessage } = useErrorMessageStore();
   const { isLoadingMessages } = useWsClient();
   const { isTask } = useTaskPolling();
+  const conversationWebSocket = useConversationWebSocket();
   const { send } = useSendMessage();
   const storeEvents = useEventStore((state) => state.events);
   const { setOptimisticUserMessage, getOptimisticUserMessage } =
@@ -94,6 +96,25 @@ export function ChatInterface() {
 
   const isV1Conversation = conversation?.conversation_version === "V1";
 
+  // Instantly scroll to bottom when history loading completes
+  const prevLoadingHistoryRef = React.useRef(
+    conversationWebSocket?.isLoadingHistory,
+  );
+  React.useEffect(() => {
+    const wasLoading = prevLoadingHistoryRef.current;
+    const isLoading = conversationWebSocket?.isLoadingHistory;
+
+    // When history loading transitions from true to false, instantly scroll to bottom
+    if (wasLoading && !isLoading && scrollRef.current) {
+      scrollRef.current.scrollTo({
+        top: scrollRef.current.scrollHeight,
+        behavior: "instant",
+      });
+    }
+
+    prevLoadingHistoryRef.current = isLoading;
+  }, [conversationWebSocket?.isLoadingHistory, scrollRef]);
+
   // Filter V0 events
   const v0Events = storeEvents
     .filter(isV0Event)
@@ -228,6 +249,14 @@ export function ChatInterface() {
             </div>
           )}
 
+          {conversationWebSocket?.isLoadingHistory &&
+            isV1Conversation &&
+            !isTask && (
+              <div className="flex justify-center">
+                <LoadingSpinner size="small" />
+              </div>
+            )}
+
           {!isLoadingMessages && v0UserEventsExist && (
             <V0Messages
               messages={v0Events}
@@ -237,13 +266,8 @@ export function ChatInterface() {
             />
           )}
 
-          {v1UserEventsExist && (
-            <V1Messages
-              messages={v1Events}
-              isAwaitingUserConfirmation={
-                curAgentState === AgentState.AWAITING_USER_CONFIRMATION
-              }
-            />
+          {!conversationWebSocket?.isLoadingHistory && v1UserEventsExist && (
+            <V1Messages messages={v1Events} />
           )}
         </div>
 

frontend/src/components/features/conversation/conversation-tabs/conversation-tab-content/conversation-tab-content.tsx

@@ -12,7 +12,6 @@ import { useConversationStore } from "#/state/conversation-store";
 // Lazy load all tab components
 const EditorTab = lazy(() => import("#/routes/changes-tab"));
 const BrowserTab = lazy(() => import("#/routes/browser-tab"));
-const JupyterTab = lazy(() => import("#/routes/jupyter-tab"));
 const ServedTab = lazy(() => import("#/routes/served-tab"));
 const VSCodeTab = lazy(() => import("#/routes/vscode-tab"));
 
@@ -24,7 +23,6 @@ export function ConversationTabContent() {
   // Determine which tab is active based on the current path
   const isEditorActive = selectedTab === "editor";
   const isBrowserActive = selectedTab === "browser";
-  const isJupyterActive = selectedTab === "jupyter";
   const isServedActive = selectedTab === "served";
   const isVSCodeActive = selectedTab === "vscode";
   const isTerminalActive = selectedTab === "terminal";
@@ -37,11 +35,6 @@ export function ConversationTabContent() {
       component: BrowserTab,
       isActive: isBrowserActive,
     },
-    {
-      key: "jupyter",
-      component: JupyterTab,
-      isActive: isJupyterActive,
-    },
     { key: "served", component: ServedTab, isActive: isServedActive },
     { key: "vscode", component: VSCodeTab, isActive: isVSCodeActive },
     {
@@ -58,9 +51,6 @@ export function ConversationTabContent() {
     if (isBrowserActive) {
       return t(I18nKey.COMMON$BROWSER);
     }
-    if (isJupyterActive) {
-      return t(I18nKey.COMMON$JUPYTER);
-    }
     if (isServedActive) {
       return t(I18nKey.COMMON$APP);
     }
@@ -74,7 +64,6 @@ export function ConversationTabContent() {
   }, [
     isEditorActive,
     isBrowserActive,
-    isJupyterActive,
     isServedActive,
     isVSCodeActive,
     isTerminalActive,

frontend/src/components/features/conversation/conversation-tabs/conversation-tabs.tsx

@@ -1,7 +1,6 @@
 import { useEffect } from "react";
 import { useTranslation } from "react-i18next";
 import { useLocalStorage } from "@uidotdev/usehooks";
-import JupyterIcon from "#/icons/jupyter.svg?react";
 import TerminalIcon from "#/icons/terminal.svg?react";
 import GlobeIcon from "#/icons/globe.svg?react";
 import ServerIcon from "#/icons/server.svg?react";
@@ -108,13 +107,6 @@ export function ConversationTabs() {
       tooltipContent: t(I18nKey.COMMON$TERMINAL),
       tooltipAriaLabel: t(I18nKey.COMMON$TERMINAL),
     },
-    {
-      isActive: isTabActive("jupyter"),
-      icon: JupyterIcon,
-      onClick: () => onTabSelected("jupyter"),
-      tooltipContent: t(I18nKey.COMMON$JUPYTER),
-      tooltipAriaLabel: t(I18nKey.COMMON$JUPYTER),
-    },
     {
       isActive: isTabActive("served"),
       icon: ServerIcon,

frontend/src/components/features/diff-viewer/file-diff-viewer.tsx

@@ -7,7 +7,7 @@ import { GitChangeStatus } from "#/api/open-hands.types";
 import { getLanguageFromPath } from "#/utils/get-language-from-path";
 import { cn } from "#/utils/utils";
 import ChevronUp from "#/icons/chveron-up.svg?react";
-import { useGitDiff } from "#/hooks/query/use-get-diff";
+import { useUnifiedGitDiff } from "#/hooks/query/use-unified-git-diff";
 
 interface LoadingSpinnerProps {
   className?: string;
@@ -64,7 +64,7 @@ export function FileDiffViewer({ path, type }: FileDiffViewerProps) {
     isLoading,
     isSuccess,
     isRefetching,
-  } = useGitDiff({
+  } = useUnifiedGitDiff({
     filePath,
     type,
     enabled: !isCollapsed,

frontend/src/components/features/jupyter/jupyter-cell-input.tsx

@@ -1,22 +0,0 @@
-import SyntaxHighlighter from "react-syntax-highlighter";
-import { atomOneDark } from "react-syntax-highlighter/dist/esm/styles/hljs";
-
-interface JupytrerCellInputProps {
-  code: string;
-}
-
-export function JupytrerCellInput({ code }: JupytrerCellInputProps) {
-  return (
-    <div className="rounded-lg bg-gray-800 dark:bg-gray-900 p-2 text-xs">
-      <div className="mb-1 text-gray-400">EXECUTE</div>
-      <pre
-        className="scrollbar-custom scrollbar-thumb-gray-500 hover:scrollbar-thumb-gray-400 dark:scrollbar-thumb-white/10 dark:hover:scrollbar-thumb-white/20 overflow-auto px-5"
-        style={{ padding: 0, marginBottom: 0, fontSize: "0.75rem" }}
-      >
-        <SyntaxHighlighter language="python" style={atomOneDark} wrapLongLines>
-          {code}
-        </SyntaxHighlighter>
-      </pre>
-    </div>
-  );
-}

frontend/src/components/features/jupyter/jupyter-cell-output.tsx

@@ -1,55 +0,0 @@
-import Markdown from "react-markdown";
-import SyntaxHighlighter from "react-syntax-highlighter";
-import { atomOneDark } from "react-syntax-highlighter/dist/esm/styles/hljs";
-import { useTranslation } from "react-i18next";
-import { I18nKey } from "#/i18n/declaration";
-import { JupyterLine } from "#/utils/parse-cell-content";
-import { paragraph } from "../markdown/paragraph";
-
-interface JupyterCellOutputProps {
-  lines: JupyterLine[];
-}
-
-export function JupyterCellOutput({ lines }: JupyterCellOutputProps) {
-  const { t } = useTranslation();
-  return (
-    <div className="rounded-lg bg-gray-800 dark:bg-gray-900 p-2 text-xs">
-      <div className="mb-1 text-gray-400">
-        {t(I18nKey.JUPYTER$OUTPUT_LABEL)}
-      </div>
-      <pre
-        className="scrollbar-custom scrollbar-thumb-gray-500 hover:scrollbar-thumb-gray-400 dark:scrollbar-thumb-white/10 dark:hover:scrollbar-thumb-white/20 overflow-auto px-5 max-h-[60vh] bg-gray-800"
-        style={{ padding: 0, marginBottom: 0, fontSize: "0.75rem" }}
-      >
-        {/* display the lines as plaintext or image */}
-        {lines.map((line, index) => {
-          if (line.type === "image") {
-            // Use markdown to display the image
-            const imageMarkdown = line.url
-              ? `![image](${line.url})`
-              : line.content;
-            return (
-              <div key={index}>
-                <Markdown
-                  components={{
-                    p: paragraph,
-                  }}
-                  urlTransform={(value: string) => value}
-                >
-                  {imageMarkdown}
-                </Markdown>
-              </div>
-            );
-          }
-          return (
-            <div key={index}>
-              <SyntaxHighlighter language="plaintext" style={atomOneDark}>
-                {line.content}
-              </SyntaxHighlighter>
-            </div>
-          );
-        })}
-      </pre>
-    </div>
-  );
-}

frontend/src/components/features/jupyter/jupyter-cell.tsx

@@ -1,23 +0,0 @@
-import React from "react";
-import { Cell } from "#/state/jupyter-store";
-import { JupyterLine, parseCellContent } from "#/utils/parse-cell-content";
-import { JupytrerCellInput } from "./jupyter-cell-input";
-import { JupyterCellOutput } from "./jupyter-cell-output";
-
-interface JupyterCellProps {
-  cell: Cell;
-}
-
-export function JupyterCell({ cell }: JupyterCellProps) {
-  const [lines, setLines] = React.useState<JupyterLine[]>([]);
-
-  React.useEffect(() => {
-    setLines(parseCellContent(cell.content, cell.imageUrls));
-  }, [cell.content, cell.imageUrls]);
-
-  if (cell.type === "input") {
-    return <JupytrerCellInput code={cell.content} />;
-  }
-
-  return <JupyterCellOutput lines={lines} />;
-}

frontend/src/components/features/jupyter/jupyter.tsx

@@ -1,63 +0,0 @@
-import React from "react";
-import { useTranslation } from "react-i18next";
-import { useScrollToBottom } from "#/hooks/use-scroll-to-bottom";
-import { JupyterCell } from "./jupyter-cell";
-import { ScrollToBottomButton } from "#/components/shared/buttons/scroll-to-bottom-button";
-import { RUNTIME_INACTIVE_STATES } from "#/types/agent-state";
-import { I18nKey } from "#/i18n/declaration";
-import JupyterLargeIcon from "#/icons/jupyter-large.svg?react";
-import { WaitingForRuntimeMessage } from "../chat/waiting-for-runtime-message";
-import { useAgentState } from "#/hooks/use-agent-state";
-import { useJupyterStore } from "#/state/jupyter-store";
-
-interface JupyterEditorProps {
-  maxWidth: number;
-}
-
-export function JupyterEditor({ maxWidth }: JupyterEditorProps) {
-  const { curAgentState } = useAgentState();
-
-  const cells = useJupyterStore((state) => state.cells);
-
-  const jupyterRef = React.useRef<HTMLDivElement>(null);
-
-  const { t } = useTranslation();
-
-  const isRuntimeInactive = RUNTIME_INACTIVE_STATES.includes(curAgentState);
-
-  const { hitBottom, scrollDomToBottom, onChatBodyScroll } =
-    useScrollToBottom(jupyterRef);
-
-  return (
-    <>
-      {isRuntimeInactive && <WaitingForRuntimeMessage />}
-      {!isRuntimeInactive && cells.length > 0 && (
-        <div className="flex-1 h-full flex flex-col" style={{ maxWidth }}>
-          <div
-            data-testid="jupyter-container"
-            className="flex-1 overflow-y-auto fast-smooth-scroll custom-scrollbar-always rounded-xl"
-            ref={jupyterRef}
-            onScroll={(e) => onChatBodyScroll(e.currentTarget)}
-          >
-            {cells.map((cell, index) => (
-              <JupyterCell key={index} cell={cell} />
-            ))}
-          </div>
-          {!hitBottom && (
-            <div className="sticky bottom-2 flex items-center justify-center">
-              <ScrollToBottomButton onClick={scrollDomToBottom} />
-            </div>
-          )}
-        </div>
-      )}
-      {!isRuntimeInactive && cells.length === 0 && (
-        <div className="flex flex-col items-center justify-center w-full h-full p-10 gap-4">
-          <JupyterLargeIcon width={113} height={113} color="#A1A1A1" />
-          <span className="text-[#8D95A9] text-[19px] font-normal leading-5">
-            {t(I18nKey.COMMON$JUPYTER_EMPTY_MESSAGE)}
-          </span>
-        </div>
-      )}
-    </>
-  );
-}

frontend/src/components/features/payment/payment-form.tsx

@@ -1,8 +1,7 @@
 import React from "react";
-import { useTranslation, Trans } from "react-i18next";
+import { useTranslation } from "react-i18next";
 import { useCreateStripeCheckoutSession } from "#/hooks/mutation/stripe/use-create-stripe-checkout-session";
 import { useBalance } from "#/hooks/query/use-balance";
-import { useSubscriptionAccess } from "#/hooks/query/use-subscription-access";
 import { cn } from "#/utils/utils";
 import MoneyIcon from "#/icons/money.svg?react";
 import { SettingsInput } from "../settings/settings-input";
@@ -11,24 +10,13 @@ import { LoadingSpinner } from "#/components/shared/loading-spinner";
 import { amountIsValid } from "#/utils/amount-is-valid";
 import { I18nKey } from "#/i18n/declaration";
 import { PoweredByStripeTag } from "./powered-by-stripe-tag";
-import { CancelSubscriptionModal } from "./cancel-subscription-modal";
 
 export function PaymentForm() {
   const { t } = useTranslation();
   const { data: balance, isLoading } = useBalance();
-  const { data: subscriptionAccess } = useSubscriptionAccess();
   const { mutate: addBalance, isPending } = useCreateStripeCheckoutSession();
 
   const [buttonIsDisabled, setButtonIsDisabled] = React.useState(true);
-  const [showCancelModal, setShowCancelModal] = React.useState(false);
-
-  const subscriptionExpiredDate =
-    subscriptionAccess?.end_at &&
-    new Date(subscriptionAccess.end_at).toLocaleDateString("en-US", {
-      year: "numeric",
-      month: "long",
-      day: "numeric",
-    });
 
   const billingFormAction = async (formData: FormData) => {
     const amount = formData.get("top-up-input")?.toString();
@@ -94,50 +82,7 @@ export function PaymentForm() {
           {isPending && <LoadingSpinner size="small" />}
           <PoweredByStripeTag />
         </div>
-
-        {/* Cancel Subscription Button or Cancellation Message */}
-        {subscriptionAccess && (
-          <div className="flex flex-col w-[680px] gap-2 mt-4">
-            {subscriptionAccess.cancelled_at ? (
-              <div className="text-red-500 text-sm">
-                <Trans
-                  i18nKey={I18nKey.PAYMENT$SUBSCRIPTION_CANCELLED_EXPIRES}
-                  values={{ date: subscriptionExpiredDate }}
-                  components={{ date: <span className="underline" /> }}
-                />
-              </div>
-            ) : (
-              <div className="flex items-center gap-4">
-                <BrandButton
-                  testId="cancel-subscription-button"
-                  variant="ghost-danger"
-                  type="button"
-                  onClick={() => setShowCancelModal(true)}
-                >
-                  {t(I18nKey.PAYMENT$CANCEL_SUBSCRIPTION)}
-                </BrandButton>
-                <div
-                  className="text-sm text-gray-300"
-                  data-testid="next-billing-date"
-                >
-                  <Trans
-                    i18nKey={I18nKey.PAYMENT$NEXT_BILLING_DATE}
-                    values={{ date: subscriptionExpiredDate }}
-                    components={{ date: <span className="underline" /> }}
-                  />
-                </div>
-              </div>
-            )}
-          </div>
-        )}
       </div>
-
-      {/* Cancel Subscription Modal */}
-      <CancelSubscriptionModal
-        isOpen={showCancelModal}
-        onClose={() => setShowCancelModal(false)}
-        endDate={subscriptionExpiredDate}
-      />
     </form>
   );
 }

frontend/src/components/features/settings/settings-layout.tsx

@@ -11,13 +11,11 @@ interface NavigationItem {
 interface SettingsLayoutProps {
   children: React.ReactNode;
   navigationItems: NavigationItem[];
-  isSaas: boolean;
 }
 
 export function SettingsLayout({
   children,
   navigationItems,
-  isSaas,
 }: SettingsLayoutProps) {
   const [isMobileMenuOpen, setIsMobileMenuOpen] = useState(false);
 
@@ -44,7 +42,6 @@ export function SettingsLayout({
           isMobileMenuOpen={isMobileMenuOpen}
           onCloseMobileMenu={closeMobileMenu}
           navigationItems={navigationItems}
-          isSaas={isSaas}
         />
 
         {/* Main content */}

frontend/src/components/features/settings/settings-navigation.tsx

@@ -5,7 +5,6 @@ import { Typography } from "#/ui/typography";
 import { I18nKey } from "#/i18n/declaration";
 import SettingsIcon from "#/icons/settings-gear.svg?react";
 import CloseIcon from "#/icons/close.svg?react";
-import { ProPill } from "./pro-pill";
 
 interface NavigationItem {
   to: string;
@@ -17,14 +16,12 @@ interface SettingsNavigationProps {
   isMobileMenuOpen: boolean;
   onCloseMobileMenu: () => void;
   navigationItems: NavigationItem[];
-  isSaas: boolean;
 }
 
 export function SettingsNavigation({
   isMobileMenuOpen,
   onCloseMobileMenu,
   navigationItems,
-  isSaas,
 }: SettingsNavigationProps) {
   const { t } = useTranslation();
 
@@ -85,7 +82,6 @@ export function SettingsNavigation({
                 <Typography.Text className="text-[#A3A3A3] whitespace-nowrap">
                   {t(text as I18nKey)}
                 </Typography.Text>
-                {isSaas && to === "/settings" && <ProPill />}
               </div>
             </NavLink>
           ))}

frontend/src/components/shared/buttons/v1-confirmation-buttons.tsx

@@ -0,0 +1,141 @@
+import { useCallback, useEffect } from "react";
+import { useTranslation } from "react-i18next";
+import { I18nKey } from "#/i18n/declaration";
+import { AgentState } from "#/types/agent-state";
+import { ActionTooltip } from "../action-tooltip";
+import { RiskAlert } from "#/components/shared/risk-alert";
+import WarningIcon from "#/icons/u-warning.svg?react";
+import { useEventMessageStore } from "#/stores/event-message-store";
+import { useEventStore } from "#/stores/use-event-store";
+import { isV1Event, isActionEvent } from "#/types/v1/type-guards";
+import { useActiveConversation } from "#/hooks/query/use-active-conversation";
+import { useAgentState } from "#/hooks/use-agent-state";
+import { useRespondToConfirmation } from "#/hooks/mutation/use-respond-to-confirmation";
+import { SecurityRisk } from "#/types/v1/core/base/common";
+
+export function V1ConfirmationButtons() {
+  const v1SubmittedEventIds = useEventMessageStore(
+    (state) => state.v1SubmittedEventIds,
+  );
+  const addV1SubmittedEventId = useEventMessageStore(
+    (state) => state.addV1SubmittedEventId,
+  );
+
+  const { t } = useTranslation();
+  const { data: conversation } = useActiveConversation();
+  const { curAgentState } = useAgentState();
+  const { mutate: respondToConfirmation } = useRespondToConfirmation();
+  const events = useEventStore((state) => state.events);
+
+  // Find the most recent V1 action awaiting confirmation
+  const awaitingAction = events
+    .filter(isV1Event)
+    .slice()
+    .reverse()
+    .find((ev) => {
+      if (ev.source !== "agent") return false;
+      // For V1, we check if the agent state is waiting for confirmation
+      return curAgentState === AgentState.AWAITING_USER_CONFIRMATION;
+    });
+
+  const handleConfirmation = useCallback(
+    (accept: boolean) => {
+      if (!awaitingAction || !conversation) {
+        return;
+      }
+
+      // Mark event as submitted to prevent duplicate submissions
+      addV1SubmittedEventId(awaitingAction.id);
+
+      // Call the V1 API endpoint
+      respondToConfirmation({
+        conversationId: conversation.conversation_id,
+        conversationUrl: conversation.url || "",
+        sessionApiKey: conversation.session_api_key,
+        accept,
+      });
+    },
+    [
+      awaitingAction,
+      conversation,
+      addV1SubmittedEventId,
+      respondToConfirmation,
+    ],
+  );
+
+  // Handle keyboard shortcuts
+  useEffect(() => {
+    if (!awaitingAction) {
+      return undefined;
+    }
+
+    const handleCancelShortcut = (event: KeyboardEvent) => {
+      if (event.shiftKey && event.metaKey && event.key === "Backspace") {
+        event.preventDefault();
+        handleConfirmation(false);
+      }
+    };
+
+    const handleContinueShortcut = (event: KeyboardEvent) => {
+      if (event.metaKey && event.key === "Enter") {
+        event.preventDefault();
+        handleConfirmation(true);
+      }
+    };
+
+    const handleKeyDown = (event: KeyboardEvent) => {
+      // Cancel: Shift+Cmd+Backspace (⇧⌘⌫)
+      handleCancelShortcut(event);
+      // Continue: Cmd+Enter (⌘↩)
+      handleContinueShortcut(event);
+    };
+
+    document.addEventListener("keydown", handleKeyDown);
+
+    return () => document.removeEventListener("keydown", handleKeyDown);
+  }, [awaitingAction, handleConfirmation]);
+
+  // Only show if agent is waiting for confirmation and we haven't already submitted
+  if (
+    curAgentState !== AgentState.AWAITING_USER_CONFIRMATION ||
+    !awaitingAction ||
+    v1SubmittedEventIds.includes(awaitingAction.id)
+  ) {
+    return null;
+  }
+
+  // Get security risk from the action (only ActionEvent has security_risk)
+  const risk = isActionEvent(awaitingAction)
+    ? awaitingAction.security_risk
+    : SecurityRisk.UNKNOWN;
+
+  const isHighRisk = risk === SecurityRisk.HIGH;
+
+  return (
+    <div className="flex flex-col gap-2 pt-4">
+      {isHighRisk && (
+        <RiskAlert
+          content={t(I18nKey.CHAT_INTERFACE$HIGH_RISK_WARNING)}
+          icon={<WarningIcon width={16} height={16} color="#fff" />}
+          severity="high"
+          title={t(I18nKey.COMMON$HIGH_RISK)}
+        />
+      )}
+      <div className="flex justify-between items-center">
+        <p className="text-sm font-normal text-white">
+          {t(I18nKey.CHAT_INTERFACE$USER_ASK_CONFIRMATION)}
+        </p>
+        <div className="flex items-center gap-3">
+          <ActionTooltip
+            type="reject"
+            onClick={() => handleConfirmation(false)}
+          />
+          <ActionTooltip
+            type="confirm"
+            onClick={() => handleConfirmation(true)}
+          />
+        </div>
+      </div>
+    </div>
+  );
+}

frontend/src/components/v1/chat/event-content-helpers/get-observation-content.ts

@@ -19,6 +19,10 @@ const getFileEditorObservationContent = (
 ): string => {
   const { observation } = event;
 
+  if (observation.error) {
+    return `**Error:**\n${observation.error}`;
+  }
+
   const successMessage = getObservationResult(event) === "success";
 
   // For view commands or successful edits with content changes, format as code block

frontend/src/components/v1/chat/event-content-helpers/get-observation-result.ts

@@ -11,9 +11,10 @@ export const getObservationResult = (
   switch (observationType) {
     case "ExecuteBashObservation": {
       const exitCode = observation.exit_code;
+      const { metadata } = observation;
 
-      if (exitCode === -1) return "timeout"; // Command timed out
-      if (exitCode === 0) return "success"; // Command executed successfully
+      if (exitCode === -1 || metadata.exit_code === -1) return "timeout"; // Command timed out
+      if (exitCode === 0 || metadata.exit_code === 0) return "success"; // Command executed successfully
       return "error"; // Command failed
     }
     case "FileEditorObservation":

frontend/src/components/v1/chat/event-message-components/generic-event-message-wrapper.tsx

@@ -1,19 +1,18 @@
-import React from "react";
 import { OpenHandsEvent } from "#/types/v1/core";
 import { GenericEventMessage } from "../../../features/chat/generic-event-message";
 import { getEventContent } from "../event-content-helpers/get-event-content";
 import { getObservationResult } from "../event-content-helpers/get-observation-result";
 import { isObservationEvent } from "#/types/v1/type-guards";
-import { ConfirmationButtons } from "#/components/shared/buttons/confirmation-buttons";
+import { V1ConfirmationButtons } from "#/components/shared/buttons/v1-confirmation-buttons";
 
 interface GenericEventMessageWrapperProps {
   event: OpenHandsEvent;
-  shouldShowConfirmationButtons: boolean;
+  isLastMessage: boolean;
 }
 
 export function GenericEventMessageWrapper({
   event,
-  shouldShowConfirmationButtons,
+  isLastMessage,
 }: GenericEventMessageWrapperProps) {
   const { title, details } = getEventContent(event);
 
@@ -27,7 +26,7 @@ export function GenericEventMessageWrapper({
         }
         initiallyExpanded={false}
       />
-      {shouldShowConfirmationButtons && <ConfirmationButtons />}
+      {isLastMessage && <V1ConfirmationButtons />}
     </div>
   );
 }

frontend/src/components/v1/chat/event-message-components/user-assistant-event-message.tsx

@@ -4,7 +4,7 @@ import { ChatMessage } from "../../../features/chat/chat-message";
 import { ImageCarousel } from "../../../features/images/image-carousel";
 // TODO: Implement file_urls support for V1 messages
 // import { FileList } from "../../../features/files/file-list";
-import { ConfirmationButtons } from "#/components/shared/buttons/confirmation-buttons";
+import { V1ConfirmationButtons } from "#/components/shared/buttons/v1-confirmation-buttons";
 import { MicroagentStatusWrapper } from "../../../features/chat/event-message-components/microagent-status-wrapper";
 // TODO: Implement V1 LikertScaleWrapper when API supports V1 event IDs
 // import { LikertScaleWrapper } from "../../../features/chat/event-message-components/likert-scale-wrapper";
@@ -13,7 +13,6 @@ import { MicroagentStatus } from "#/types/microagent-status";
 
 interface UserAssistantEventMessageProps {
   event: MessageEvent;
-  shouldShowConfirmationButtons: boolean;
   microagentStatus?: MicroagentStatus | null;
   microagentConversationId?: string;
   microagentPRUrl?: string;
@@ -22,15 +21,16 @@ interface UserAssistantEventMessageProps {
     onClick: () => void;
     tooltip?: string;
   }>;
+  isLastMessage: boolean;
 }
 
 export function UserAssistantEventMessage({
   event,
-  shouldShowConfirmationButtons,
   microagentStatus,
   microagentConversationId,
   microagentPRUrl,
   actions,
+  isLastMessage,
 }: UserAssistantEventMessageProps) {
   const message = parseMessageFromEvent(event);
 
@@ -51,7 +51,7 @@ export function UserAssistantEventMessage({
           <ImageCarousel size="small" images={imageUrls} />
         )}
         {/* TODO: Handle file_urls if V1 messages support them */}
-        {shouldShowConfirmationButtons && <ConfirmationButtons />}
+        {isLastMessage && <V1ConfirmationButtons />}
       </ChatMessage>
       <MicroagentStatusWrapper
         microagentStatus={microagentStatus}

frontend/src/components/v1/chat/event-message.tsx

@@ -21,7 +21,6 @@ import {
 interface EventMessageProps {
   event: OpenHandsEvent;
   hasObservationPair: boolean;
-  isAwaitingUserConfirmation: boolean;
   isLastMessage: boolean;
   microagentStatus?: MicroagentStatus | null;
   microagentConversationId?: string;
@@ -38,7 +37,6 @@ interface EventMessageProps {
 export function EventMessage({
   event,
   hasObservationPair,
-  isAwaitingUserConfirmation,
   isLastMessage,
   microagentStatus,
   microagentConversationId,
@@ -46,9 +44,6 @@ export function EventMessage({
   actions,
   isInLast10Actions,
 }: EventMessageProps) {
-  const shouldShowConfirmationButtons =
-    isLastMessage && event.source === "agent" && isAwaitingUserConfirmation;
-
   const { data: config } = useConfig();
 
   // V1 events use string IDs, but useFeedbackExists expects number
@@ -103,17 +98,14 @@ export function EventMessage({
     return (
       <UserAssistantEventMessage
         event={event as MessageEvent}
-        shouldShowConfirmationButtons={shouldShowConfirmationButtons}
         {...commonProps}
+        isLastMessage={isLastMessage}
       />
     );
   }
 
   // Generic fallback for all other events (including observation events)
   return (
-    <GenericEventMessageWrapper
-      event={event}
-      shouldShowConfirmationButtons={shouldShowConfirmationButtons}
-    />
+    <GenericEventMessageWrapper event={event} isLastMessage={isLastMessage} />
   );
 }

frontend/src/components/v1/chat/messages.tsx

@@ -10,11 +10,10 @@ import { useOptimisticUserMessageStore } from "#/stores/optimistic-user-message-
 
 interface MessagesProps {
   messages: OpenHandsEvent[];
-  isAwaitingUserConfirmation: boolean;
 }
 
 export const Messages: React.FC<MessagesProps> = React.memo(
-  ({ messages, isAwaitingUserConfirmation }) => {
+  ({ messages }) => {
     const { getOptimisticUserMessage } = useOptimisticUserMessageStore();
 
     const optimisticUserMessage = getOptimisticUserMessage();
@@ -43,7 +42,6 @@ export const Messages: React.FC<MessagesProps> = React.memo(
             key={message.id}
             event={message}
             hasObservationPair={actionHasObservationPair(message)}
-            isAwaitingUserConfirmation={isAwaitingUserConfirmation}
             isLastMessage={messages.length - 1 === index}
             isInLast10Actions={messages.length - 1 - index < 10}
             // Microagent props - not implemented yet for V1

frontend/src/contexts/conversation-websocket-context.tsx

@@ -5,6 +5,7 @@ import React, {
   useState,
   useCallback,
   useMemo,
+  useRef,
 } from "react";
 import { useQueryClient } from "@tanstack/react-query";
 import { useWebSocket, WebSocketHookOptions } from "#/hooks/use-websocket";
@@ -27,6 +28,7 @@ import {
 import { handleActionEventCacheInvalidation } from "#/utils/cache-utils";
 import { buildWebSocketUrl } from "#/utils/websocket-url";
 import type { V1SendMessageRequest } from "#/api/conversation-service/v1-conversation-service.types";
+import V1ConversationService from "#/api/conversation-service/v1-conversation-service.api";
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
 export type V1_WebSocketConnectionState =
@@ -38,6 +40,7 @@ export type V1_WebSocketConnectionState =
 interface ConversationWebSocketContextType {
   connectionState: V1_WebSocketConnectionState;
   sendMessage: (message: V1SendMessageRequest) => Promise<void>;
+  isLoadingHistory: boolean;
 }
 
 const ConversationWebSocketContext = createContext<
@@ -67,6 +70,13 @@ export function ConversationWebSocketProvider({
   const { setAgentStatus } = useV1ConversationStateStore();
   const { appendInput, appendOutput } = useCommandStore();
 
+  // History loading state
+  const [isLoadingHistory, setIsLoadingHistory] = useState(true);
+  const [expectedEventCount, setExpectedEventCount] = useState<number | null>(
+    null,
+  );
+  const receivedEventCountRef = useRef(0);
+
   // Build WebSocket URL from props
   // Only build URL if we have both conversationId and conversationUrl
   // This prevents connection attempts during task polling phase
@@ -78,16 +88,43 @@ export function ConversationWebSocketProvider({
     return buildWebSocketUrl(conversationId, conversationUrl);
   }, [conversationId, conversationUrl]);
 
-  // Reset hasConnected flag when conversation changes
+  // Reset hasConnected flag and history loading state when conversation changes
   useEffect(() => {
     hasConnectedRef.current = false;
+    setIsLoadingHistory(true);
+    setExpectedEventCount(null);
+    receivedEventCountRef.current = 0;
   }, [conversationId]);
 
+  // Check if we've received all events when expectedEventCount becomes available
+  useEffect(() => {
+    if (
+      expectedEventCount !== null &&
+      receivedEventCountRef.current >= expectedEventCount &&
+      isLoadingHistory
+    ) {
+      setIsLoadingHistory(false);
+    }
+  }, [expectedEventCount, isLoadingHistory]);
+
   const handleMessage = useCallback(
     (messageEvent: MessageEvent) => {
       try {
         const event = JSON.parse(messageEvent.data);
 
+        // Track received events for history loading (count ALL events from WebSocket)
+        // Always count when loading, even if we don't have the expected count yet
+        if (isLoadingHistory) {
+          receivedEventCountRef.current += 1;
+
+          if (
+            expectedEventCount !== null &&
+            receivedEventCountRef.current >= expectedEventCount
+          ) {
+            setIsLoadingHistory(false);
+          }
+        }
+
         // Use type guard to validate v1 event structure
         if (isV1Event(event)) {
           addEvent(event);
@@ -141,6 +178,8 @@ export function ConversationWebSocketProvider({
     },
     [
       addEvent,
+      isLoadingHistory,
+      expectedEventCount,
       setErrorMessage,
       removeOptimisticUserMessage,
       queryClient,
@@ -164,10 +203,27 @@ export function ConversationWebSocketProvider({
     return {
       queryParams,
       reconnect: { enabled: true },
-      onOpen: () => {
+      onOpen: async () => {
         setConnectionState("OPEN");
         hasConnectedRef.current = true; // Mark that we've successfully connected
         removeErrorMessage(); // Clear any previous error messages on successful connection
+
+        // Fetch expected event count for history loading detection
+        if (conversationId) {
+          try {
+            const count =
+              await V1ConversationService.getEventCount(conversationId);
+            setExpectedEventCount(count);
+
+            // If no events expected, mark as loaded immediately
+            if (count === 0) {
+              setIsLoadingHistory(false);
+            }
+          } catch (error) {
+            // Fall back to marking as loaded to avoid infinite loading state
+            setIsLoadingHistory(false);
+          }
+        }
       },
       onClose: (event: CloseEvent) => {
         setConnectionState("CLOSED");
@@ -188,7 +244,13 @@ export function ConversationWebSocketProvider({
       },
       onMessage: handleMessage,
     };
-  }, [handleMessage, setErrorMessage, removeErrorMessage, sessionApiKey]);
+  }, [
+    handleMessage,
+    setErrorMessage,
+    removeErrorMessage,
+    sessionApiKey,
+    conversationId,
+  ]);
 
   // Only attempt WebSocket connection when we have a valid URL
   // This prevents connection attempts during task polling phase
@@ -246,8 +308,8 @@ export function ConversationWebSocketProvider({
   }, [socket, wsUrl]);
 
   const contextValue = useMemo(
-    () => ({ connectionState, sendMessage }),
-    [connectionState, sendMessage],
+    () => ({ connectionState, sendMessage, isLoadingHistory }),
+    [connectionState, sendMessage, isLoadingHistory],
   );
 
   return (

frontend/src/hooks/mutation/use-respond-to-confirmation.ts

@@ -0,0 +1,32 @@
+import { useMutation } from "@tanstack/react-query";
+import EventService from "#/api/event-service/event-service.api";
+import type { ConfirmationResponseRequest } from "#/api/event-service/event-service.types";
+
+interface UseRespondToConfirmationVariables {
+  conversationId: string;
+  conversationUrl: string;
+  sessionApiKey?: string | null;
+  accept: boolean;
+}
+
+export const useRespondToConfirmation = () =>
+  useMutation({
+    mutationKey: ["respond-to-confirmation"],
+    mutationFn: async ({
+      conversationId,
+      conversationUrl,
+      sessionApiKey,
+      accept,
+    }: UseRespondToConfirmationVariables) => {
+      const request: ConfirmationResponseRequest = {
+        accept,
+      };
+
+      return EventService.respondToConfirmation(
+        conversationId,
+        conversationUrl,
+        request,
+        sessionApiKey,
+      );
+    },
+  });

frontend/src/hooks/mutation/use-update-conversation.ts

@@ -26,6 +26,13 @@ export const useUpdateConversation = () => {
           ),
       );
 
+      // Also optimistically update the active conversation query
+      queryClient.setQueryData(
+        ["user", "conversation", variables.conversationId],
+        (old: { title: string } | undefined) =>
+          old ? { ...old, title: variables.newTitle } : old,
+      );
+
       return { previousConversations };
     },
     onError: (err, variables, context) => {

frontend/src/hooks/query/use-batch-app-conversations.ts

@@ -0,0 +1,11 @@
+import { useQuery } from "@tanstack/react-query";
+import V1ConversationService from "#/api/conversation-service/v1-conversation-service.api";
+
+export const useBatchAppConversations = (ids: string[]) =>
+  useQuery({
+    queryKey: ["v1-batch-get-app-conversations", ids],
+    queryFn: () => V1ConversationService.batchGetAppConversations(ids),
+    enabled: ids.length > 0,
+    staleTime: 1000 * 60 * 5, // 5 minutes
+    gcTime: 1000 * 60 * 15, // 15 minutes
+  });

frontend/src/hooks/query/use-batch-sandboxes.ts

@@ -0,0 +1,11 @@
+import { useQuery } from "@tanstack/react-query";
+import V1ConversationService from "#/api/conversation-service/v1-conversation-service.api";
+
+export const useBatchSandboxes = (ids: string[]) =>
+  useQuery({
+    queryKey: ["sandboxes", "batch", ids],
+    queryFn: () => V1ConversationService.batchGetSandboxes(ids),
+    enabled: ids.length > 0,
+    staleTime: 1000 * 60 * 5, // 5 minutes
+    gcTime: 1000 * 60 * 15, // 15 minutes
+  });

frontend/src/hooks/query/use-conversation-config.ts

@@ -2,14 +2,20 @@ import { useQuery } from "@tanstack/react-query";
 import React from "react";
 import { useConversationId } from "#/hooks/use-conversation-id";
 import ConversationService from "#/api/conversation-service/conversation-service.api";
+import V1ConversationService from "#/api/conversation-service/v1-conversation-service.api";
 import { useRuntimeIsReady } from "../use-runtime-is-ready";
+import { useActiveConversation } from "./use-active-conversation";
 
-export const useConversationConfig = () => {
+/**
+ * @deprecated This hook is for V0 conversations only. Use useUnifiedConversationConfig instead,
+ * or useV1ConversationConfig once we fully migrate to V1.
+ */
+export const useV0ConversationConfig = () => {
   const { conversationId } = useConversationId();
   const runtimeIsReady = useRuntimeIsReady();
 
   const query = useQuery({
-    queryKey: ["conversation_config", conversationId],
+    queryKey: ["v0_conversation_config", conversationId],
     queryFn: () => {
       if (!conversationId) throw new Error("No conversation ID");
       return ConversationService.getRuntimeId(conversationId);
@@ -34,3 +40,80 @@ export const useConversationConfig = () => {
 
   return query;
 };
+
+export const useV1ConversationConfig = () => {
+  const { conversationId } = useConversationId();
+  const runtimeIsReady = useRuntimeIsReady();
+
+  const query = useQuery({
+    queryKey: ["v1_conversation_config", conversationId],
+    queryFn: () => {
+      if (!conversationId) throw new Error("No conversation ID");
+      return V1ConversationService.getConversationConfig(conversationId);
+    },
+    enabled: runtimeIsReady && !!conversationId,
+    staleTime: 1000 * 60 * 5, // 5 minutes
+    gcTime: 1000 * 60 * 15, // 15 minutes
+  });
+
+  React.useEffect(() => {
+    if (query.data) {
+      const { runtime_id: runtimeId } = query.data;
+
+      // eslint-disable-next-line no-console
+      console.log(
+        "Runtime ID: %c%s",
+        "background: #444; color: #ffeb3b; font-weight: bold; padding: 2px 4px; border-radius: 4px;",
+        runtimeId,
+      );
+    }
+  }, [query.data]);
+
+  return query;
+};
+
+/**
+ * Unified hook that switches between V0 and V1 conversation config endpoints based on conversation version.
+ *
+ * @temporary This hook is temporary during the V0 to V1 migration period.
+ * Once we fully migrate to V1, all code should use useV1ConversationConfig directly.
+ */
+export const useUnifiedConversationConfig = () => {
+  const { conversationId } = useConversationId();
+  const { data: conversation } = useActiveConversation();
+  const runtimeIsReady = useRuntimeIsReady();
+  const isV1Conversation = conversation?.conversation_version === "V1";
+
+  const query = useQuery({
+    queryKey: ["conversation_config", conversationId, isV1Conversation],
+    queryFn: () => {
+      if (!conversationId) throw new Error("No conversation ID");
+
+      if (isV1Conversation) {
+        return V1ConversationService.getConversationConfig(conversationId);
+      }
+      return ConversationService.getRuntimeId(conversationId);
+    },
+    enabled: runtimeIsReady && !!conversationId && conversation !== undefined,
+    staleTime: 1000 * 60 * 5, // 5 minutes
+    gcTime: 1000 * 60 * 15, // 15 minutes
+  });
+
+  React.useEffect(() => {
+    if (query.data) {
+      const { runtime_id: runtimeId } = query.data;
+
+      // eslint-disable-next-line no-console
+      console.log(
+        "Runtime ID: %c%s",
+        "background: #444; color: #ffeb3b; font-weight: bold; padding: 2px 4px; border-radius: 4px;",
+        runtimeId,
+      );
+    }
+  }, [query.data]);
+
+  return query;
+};
+
+// Keep the old export name for backward compatibility (uses unified approach)
+export const useConversationConfig = useUnifiedConversationConfig;

frontend/src/hooks/query/use-unified-active-host.ts

@@ -0,0 +1,99 @@
+import { useQueries, useQuery } from "@tanstack/react-query";
+import axios from "axios";
+import React from "react";
+import ConversationService from "#/api/conversation-service/conversation-service.api";
+import { useConversationId } from "#/hooks/use-conversation-id";
+import { useRuntimeIsReady } from "#/hooks/use-runtime-is-ready";
+import { useActiveConversation } from "#/hooks/query/use-active-conversation";
+import { useBatchSandboxes } from "./use-batch-sandboxes";
+import { useConversationConfig } from "./use-conversation-config";
+
+/**
+ * Unified hook to get active web host for both legacy (V0) and V1 conversations
+ * - V0: Uses the legacy getWebHosts API endpoint and polls them
+ * - V1: Gets worker URLs from sandbox exposed_urls (WORKER_1, WORKER_2, etc.)
+ */
+export const useUnifiedActiveHost = () => {
+  const [activeHost, setActiveHost] = React.useState<string | null>(null);
+  const { conversationId } = useConversationId();
+  const runtimeIsReady = useRuntimeIsReady();
+  const { data: conversation } = useActiveConversation();
+  const { data: conversationConfig, isLoading: isLoadingConfig } =
+    useConversationConfig();
+
+  const isV1Conversation = conversation?.conversation_version === "V1";
+  const sandboxId = conversationConfig?.runtime_id;
+
+  // Fetch sandbox data for V1 conversations
+  const sandboxesQuery = useBatchSandboxes(sandboxId ? [sandboxId] : []);
+
+  // Get worker URLs from V1 sandbox or legacy web hosts from V0
+  const { data, isLoading: hostsQueryLoading } = useQuery({
+    queryKey: [conversationId, "unified", "hosts", isV1Conversation, sandboxId],
+    queryFn: async () => {
+      // V1: Get worker URLs from sandbox exposed_urls
+      if (isV1Conversation) {
+        if (
+          !sandboxesQuery.data ||
+          sandboxesQuery.data.length === 0 ||
+          !sandboxesQuery.data[0]
+        ) {
+          return { hosts: [] };
+        }
+
+        const sandbox = sandboxesQuery.data[0];
+        const workerUrls =
+          sandbox.exposed_urls
+            ?.filter((url) => url.name.startsWith("WORKER_"))
+            .map((url) => url.url) || [];
+
+        return { hosts: workerUrls };
+      }
+
+      // V0 (Legacy): Use the legacy API endpoint
+      const hosts = await ConversationService.getWebHosts(conversationId);
+      return { hosts };
+    },
+    enabled:
+      runtimeIsReady &&
+      !!conversationId &&
+      (!isV1Conversation || !!sandboxesQuery.data),
+    initialData: { hosts: [] },
+    meta: {
+      disableToast: true,
+    },
+  });
+
+  // Poll all hosts to find which one is active
+  const apps = useQueries({
+    queries: data.hosts.map((host) => ({
+      queryKey: [conversationId, "unified", "hosts", host],
+      queryFn: async () => {
+        try {
+          await axios.get(host);
+          return host;
+        } catch (e) {
+          return "";
+        }
+      },
+      refetchInterval: 3000,
+      meta: {
+        disableToast: true,
+      },
+    })),
+  });
+
+  const appsData = apps.map((app) => app.data);
+
+  React.useEffect(() => {
+    const successfulApp = appsData.find((app) => app);
+    setActiveHost(successfulApp || "");
+  }, [appsData]);
+
+  // Calculate overall loading state including dependent queries for V1
+  const isLoading = isV1Conversation
+    ? isLoadingConfig || sandboxesQuery.isLoading || hostsQueryLoading
+    : hostsQueryLoading;
+
+  return { activeHost, isLoading };
+};

frontend/src/hooks/query/use-unified-get-git-changes.ts

@@ -0,0 +1,107 @@
+import React from "react";
+import { useQuery } from "@tanstack/react-query";
+import GitService from "#/api/git-service/git-service.api";
+import V1GitService from "#/api/git-service/v1-git-service.api";
+import { useConversationId } from "#/hooks/use-conversation-id";
+import { useActiveConversation } from "#/hooks/query/use-active-conversation";
+import { useRuntimeIsReady } from "#/hooks/use-runtime-is-ready";
+import { getGitPath } from "#/utils/get-git-path";
+import type { GitChange } from "#/api/open-hands.types";
+
+/**
+ * Unified hook to get git changes for both legacy (V0) and V1 conversations
+ * - V0: Uses the legacy GitService.getGitChanges API endpoint
+ * - V1: Uses the V1GitService.getGitChanges API endpoint with runtime URL
+ */
+export const useUnifiedGetGitChanges = () => {
+  const { conversationId } = useConversationId();
+  const { data: conversation } = useActiveConversation();
+  const [orderedChanges, setOrderedChanges] = React.useState<GitChange[]>([]);
+  const previousDataRef = React.useRef<GitChange[] | null>(null);
+  const runtimeIsReady = useRuntimeIsReady();
+
+  const isV1Conversation = conversation?.conversation_version === "V1";
+  const conversationUrl = conversation?.url;
+  const sessionApiKey = conversation?.session_api_key;
+  const selectedRepository = conversation?.selected_repository;
+
+  // Calculate git path based on selected repository
+  const gitPath = React.useMemo(
+    () => getGitPath(selectedRepository),
+    [selectedRepository],
+  );
+
+  const result = useQuery({
+    queryKey: [
+      "file_changes",
+      conversationId,
+      isV1Conversation,
+      conversationUrl,
+      gitPath,
+    ],
+    queryFn: async () => {
+      if (!conversationId) throw new Error("No conversation ID");
+
+      // V1: Use the V1 API endpoint with runtime URL
+      if (isV1Conversation) {
+        return V1GitService.getGitChanges(
+          conversationUrl,
+          sessionApiKey,
+          gitPath,
+        );
+      }
+
+      // V0 (Legacy): Use the legacy API endpoint
+      return GitService.getGitChanges(conversationId);
+    },
+    retry: false,
+    staleTime: 1000 * 60 * 5, // 5 minutes
+    gcTime: 1000 * 60 * 15, // 15 minutes
+    enabled: runtimeIsReady && !!conversationId,
+    meta: {
+      disableToast: true,
+    },
+  });
+
+  // Latest changes should be on top
+  React.useEffect(() => {
+    if (!result.isFetching && result.isSuccess && result.data) {
+      const currentData = result.data;
+
+      // If this is new data (not the same reference as before)
+      if (currentData !== previousDataRef.current) {
+        previousDataRef.current = currentData;
+
+        // Figure out new items by comparing with what we already have
+        if (Array.isArray(currentData)) {
+          const currentIds = new Set(currentData.map((item) => item.path));
+          const existingIds = new Set(orderedChanges.map((item) => item.path));
+
+          // Filter out items that already exist in orderedChanges
+          const newItems = currentData.filter(
+            (item) => !existingIds.has(item.path),
+          );
+
+          // Filter out items that no longer exist in the API response
+          const existingItems = orderedChanges.filter((item) =>
+            currentIds.has(item.path),
+          );
+
+          // Add new items to the beginning
+          setOrderedChanges([...newItems, ...existingItems]);
+        } else {
+          // If not an array, just use the data directly
+          setOrderedChanges([currentData]);
+        }
+      }
+    }
+  }, [result.isFetching, result.isSuccess, result.data]);
+
+  return {
+    data: orderedChanges,
+    isLoading: result.isLoading,
+    isSuccess: result.isSuccess,
+    isError: result.isError,
+    error: result.error,
+  };
+};

frontend/src/hooks/query/use-unified-git-diff.ts

@@ -0,0 +1,67 @@
+import React from "react";
+import { useQuery } from "@tanstack/react-query";
+import GitService from "#/api/git-service/git-service.api";
+import V1GitService from "#/api/git-service/v1-git-service.api";
+import { useConversationId } from "#/hooks/use-conversation-id";
+import { useActiveConversation } from "#/hooks/query/use-active-conversation";
+import { getGitPath } from "#/utils/get-git-path";
+import type { GitChangeStatus } from "#/api/open-hands.types";
+
+type UseUnifiedGitDiffConfig = {
+  filePath: string;
+  type: GitChangeStatus;
+  enabled: boolean;
+};
+
+/**
+ * Unified hook to get git diff for both legacy (V0) and V1 conversations
+ * - V0: Uses the legacy GitService.getGitChangeDiff API endpoint
+ * - V1: Uses the V1GitService.getGitChangeDiff API endpoint with runtime URL
+ */
+export const useUnifiedGitDiff = (config: UseUnifiedGitDiffConfig) => {
+  const { conversationId } = useConversationId();
+  const { data: conversation } = useActiveConversation();
+
+  const isV1Conversation = conversation?.conversation_version === "V1";
+  const conversationUrl = conversation?.url;
+  const sessionApiKey = conversation?.session_api_key;
+  const selectedRepository = conversation?.selected_repository;
+
+  // For V1, we need to convert the relative file path to an absolute path
+  // The diff endpoint expects: /workspace/project/RepoName/relative/path
+  const absoluteFilePath = React.useMemo(() => {
+    if (!isV1Conversation) return config.filePath;
+
+    const gitPath = getGitPath(selectedRepository);
+    return `${gitPath}/${config.filePath}`;
+  }, [isV1Conversation, selectedRepository, config.filePath]);
+
+  return useQuery({
+    queryKey: [
+      "file_diff",
+      conversationId,
+      config.filePath,
+      config.type,
+      isV1Conversation,
+      conversationUrl,
+    ],
+    queryFn: async () => {
+      if (!conversationId) throw new Error("No conversation ID");
+
+      // V1: Use the V1 API endpoint with runtime URL and absolute path
+      if (isV1Conversation) {
+        return V1GitService.getGitChangeDiff(
+          conversationUrl,
+          sessionApiKey,
+          absoluteFilePath,
+        );
+      }
+
+      // V0 (Legacy): Use the legacy API endpoint with relative path
+      return GitService.getGitChangeDiff(conversationId, config.filePath);
+    },
+    enabled: config.enabled,
+    staleTime: 1000 * 60 * 5, // 5 minutes
+    gcTime: 1000 * 60 * 15, // 15 minutes
+  });
+};

frontend/src/hooks/query/use-unified-vscode-url.ts

@@ -0,0 +1,122 @@
+import { useQuery } from "@tanstack/react-query";
+import { useTranslation } from "react-i18next";
+import ConversationService from "#/api/conversation-service/conversation-service.api";
+import { useConversationId } from "#/hooks/use-conversation-id";
+import { useActiveConversation } from "#/hooks/query/use-active-conversation";
+import { I18nKey } from "#/i18n/declaration";
+import { transformVSCodeUrl } from "#/utils/vscode-url-helper";
+import { useRuntimeIsReady } from "#/hooks/use-runtime-is-ready";
+import { useBatchAppConversations } from "./use-batch-app-conversations";
+import { useBatchSandboxes } from "./use-batch-sandboxes";
+
+interface VSCodeUrlResult {
+  url: string | null;
+  error: string | null;
+}
+
+/**
+ * Unified hook to get VSCode URL for both legacy (V0) and V1 conversations
+ * - V0: Uses the legacy getVSCodeUrl API endpoint
+ * - V1: Gets the VSCode URL from sandbox exposed_urls
+ */
+export const useUnifiedVSCodeUrl = () => {
+  const { t } = useTranslation();
+  const { conversationId } = useConversationId();
+  const { data: conversation } = useActiveConversation();
+  const runtimeIsReady = useRuntimeIsReady();
+
+  const isV1Conversation = conversation?.conversation_version === "V1";
+
+  // Fetch V1 app conversation to get sandbox_id
+  const appConversationsQuery = useBatchAppConversations(
+    isV1Conversation && conversationId ? [conversationId] : [],
+  );
+  const appConversation = appConversationsQuery.data?.[0];
+  const sandboxId = appConversation?.sandbox_id;
+
+  // Fetch sandbox data for V1 conversations
+  const sandboxesQuery = useBatchSandboxes(sandboxId ? [sandboxId] : []);
+
+  const mainQuery = useQuery<VSCodeUrlResult>({
+    queryKey: [
+      "unified",
+      "vscode_url",
+      conversationId,
+      isV1Conversation,
+      sandboxId,
+    ],
+    queryFn: async () => {
+      if (!conversationId) throw new Error("No conversation ID");
+
+      // V1: Get VSCode URL from sandbox exposed_urls
+      if (isV1Conversation) {
+        if (
+          !sandboxesQuery.data ||
+          sandboxesQuery.data.length === 0 ||
+          !sandboxesQuery.data[0]
+        ) {
+          return {
+            url: null,
+            error: t(I18nKey.VSCODE$URL_NOT_AVAILABLE),
+          };
+        }
+
+        const sandbox = sandboxesQuery.data[0];
+        const vscodeUrl = sandbox.exposed_urls?.find(
+          (url) => url.name === "VSCODE",
+        );
+
+        if (!vscodeUrl) {
+          return {
+            url: null,
+            error: t(I18nKey.VSCODE$URL_NOT_AVAILABLE),
+          };
+        }
+
+        return {
+          url: transformVSCodeUrl(vscodeUrl.url),
+          error: null,
+        };
+      }
+
+      // V0 (Legacy): Use the legacy API endpoint
+      const data = await ConversationService.getVSCodeUrl(conversationId);
+
+      if (data.vscode_url) {
+        return {
+          url: transformVSCodeUrl(data.vscode_url),
+          error: null,
+        };
+      }
+
+      return {
+        url: null,
+        error: t(I18nKey.VSCODE$URL_NOT_AVAILABLE),
+      };
+    },
+    enabled:
+      runtimeIsReady &&
+      !!conversationId &&
+      (!isV1Conversation || !!sandboxesQuery.data),
+    refetchOnMount: true,
+    retry: 3,
+  });
+
+  // Calculate overall loading state including dependent queries for V1
+  const isLoading = isV1Conversation
+    ? appConversationsQuery.isLoading ||
+      sandboxesQuery.isLoading ||
+      mainQuery.isLoading
+    : mainQuery.isLoading;
+
+  // Explicitly destructure to avoid excessive re-renders from spreading the entire query object
+  return {
+    data: mainQuery.data,
+    error: mainQuery.error,
+    isLoading,
+    isError: mainQuery.isError,
+    isSuccess: mainQuery.isSuccess,
+    status: mainQuery.status,
+    refetch: mainQuery.refetch,
+  };
+};

frontend/src/hooks/use-terminal.ts

@@ -2,11 +2,7 @@ import { FitAddon } from "@xterm/addon-fit";
 import { Terminal } from "@xterm/xterm";
 import React from "react";
 import { Command, useCommandStore } from "#/state/command-store";
-import { RUNTIME_INACTIVE_STATES } from "#/types/agent-state";
-import { getTerminalCommand } from "#/services/terminal-service";
 import { parseTerminalOutput } from "#/utils/parse-terminal-output";
-import { useSendMessage } from "#/hooks/use-send-message";
-import { useAgentState } from "#/hooks/use-agent-state";
 
 /*
   NOTE: Tests for this hook are indirectly covered by the tests for the XTermTerminal component.
@@ -38,15 +34,11 @@ const renderCommand = (
 const persistentLastCommandIndex = { current: 0 };
 
 export const useTerminal = () => {
-  const { send } = useSendMessage();
-  const { curAgentState } = useAgentState();
   const commands = useCommandStore((state) => state.commands);
   const terminal = React.useRef<Terminal | null>(null);
   const fitAddon = React.useRef<FitAddon | null>(null);
   const ref = React.useRef<HTMLDivElement>(null);
   const lastCommandIndex = persistentLastCommandIndex; // Use the persistent reference
-  const keyEventDisposable = React.useRef<{ dispose: () => void } | null>(null);
-  const disabled = RUNTIME_INACTIVE_STATES.includes(curAgentState);
 
   const createTerminal = () =>
     new Terminal({
@@ -57,6 +49,7 @@ export const useTerminal = () => {
       fastScrollModifier: "alt",
       fastScrollSensitivity: 5,
       allowTransparency: true,
+      disableStdin: true, // Make terminal read-only
       theme: {
         background: "transparent",
       },
@@ -65,55 +58,12 @@ export const useTerminal = () => {
   const initializeTerminal = () => {
     if (terminal.current) {
       if (fitAddon.current) terminal.current.loadAddon(fitAddon.current);
-      if (ref.current) terminal.current.open(ref.current);
-    }
-  };
-
-  const copySelection = (selection: string) => {
-    const clipboardItem = new ClipboardItem({
-      "text/plain": new Blob([selection], { type: "text/plain" }),
-    });
-
-    navigator.clipboard.write([clipboardItem]);
-  };
-
-  const pasteSelection = (callback: (text: string) => void) => {
-    navigator.clipboard.readText().then(callback);
-  };
-
-  const pasteHandler = (event: KeyboardEvent, cb: (text: string) => void) => {
-    const isControlOrMetaPressed =
-      event.type === "keydown" && (event.ctrlKey || event.metaKey);
-
-    if (isControlOrMetaPressed) {
-      if (event.code === "KeyV") {
-        pasteSelection((text: string) => {
-          terminal.current?.write(text);
-          cb(text);
-        });
-      }
-
-      if (event.code === "KeyC") {
-        const selection = terminal.current?.getSelection();
-        if (selection) copySelection(selection);
+      if (ref.current) {
+        terminal.current.open(ref.current);
+        // Hide cursor for read-only terminal using ANSI escape sequence
+        terminal.current.write("\x1b[?25l");
       }
     }
-
-    return true;
-  };
-
-  const handleEnter = (command: string) => {
-    terminal.current?.write("\r\n");
-    // Don't write the command again as it will be added to the commands array
-    // and rendered by the useEffect that watches commands
-    send(getTerminalCommand(command));
-    // Don't add the prompt here as it will be added when the command is processed
-    // and the commands array is updated
-  };
-
-  const handleBackspace = (command: string) => {
-    terminal.current?.write("\b \b");
-    return command.slice(0, -1);
   };
 
   // Initialize terminal and handle cleanup
@@ -136,7 +86,7 @@ export const useTerminal = () => {
         }
         lastCommandIndex.current = commands.length;
       }
-      terminal.current.write("$ ");
+      // Don't show prompt in read-only terminal
     }
 
     return () => {
@@ -150,19 +100,17 @@ export const useTerminal = () => {
       commands.length > 0 &&
       lastCommandIndex.current < commands.length
     ) {
-      let lastCommandType = "";
       for (let i = lastCommandIndex.current; i < commands.length; i += 1) {
-        lastCommandType = commands[i].type;
+        if (commands[i].type === "input") {
+          terminal.current.write("$ ");
+        }
         // Pass true for isUserInput to skip rendering user input commands
         // that have already been displayed as the user typed
         renderCommand(commands[i], terminal.current, false);
       }
       lastCommandIndex.current = commands.length;
-      if (lastCommandType === "output") {
-        terminal.current.write("$ ");
-      }
     }
-  }, [commands, disabled]);
+  }, [commands]);
 
   React.useEffect(() => {
     let resizeObserver: ResizeObserver | null = null;
@@ -180,60 +128,5 @@ export const useTerminal = () => {
     };
   }, []);
 
-  React.useEffect(() => {
-    if (terminal.current) {
-      // Dispose of existing listeners if they exist
-      if (keyEventDisposable.current) {
-        keyEventDisposable.current.dispose();
-        keyEventDisposable.current = null;
-      }
-
-      let commandBuffer = "";
-
-      if (!disabled) {
-        // Add new key event listener and store the disposable
-        keyEventDisposable.current = terminal.current.onKey(
-          ({ key, domEvent }) => {
-            if (domEvent.key === "Enter") {
-              handleEnter(commandBuffer);
-              commandBuffer = "";
-            } else if (domEvent.key === "Backspace") {
-              if (commandBuffer.length > 0) {
-                commandBuffer = handleBackspace(commandBuffer);
-              }
-            } else {
-              // Ignore paste event
-              if (key.charCodeAt(0) === 22) {
-                return;
-              }
-              commandBuffer += key;
-              terminal.current?.write(key);
-            }
-          },
-        );
-
-        // Add custom key handler and store the disposable
-        terminal.current.attachCustomKeyEventHandler((event) =>
-          pasteHandler(event, (text) => {
-            commandBuffer += text;
-          }),
-        );
-      } else {
-        // Add a noop handler when disabled
-        keyEventDisposable.current = terminal.current.onKey((e) => {
-          e.domEvent.preventDefault();
-          e.domEvent.stopPropagation();
-        });
-      }
-    }
-
-    return () => {
-      if (keyEventDisposable.current) {
-        keyEventDisposable.current.dispose();
-        keyEventDisposable.current = null;
-      }
-    };
-  }, [disabled]);
-
   return ref;
 };

frontend/src/i18n/declaration.ts

@@ -930,4 +930,5 @@ export enum I18nKey {
   TOAST$STOPPING_CONVERSATION = "TOAST$STOPPING_CONVERSATION",
   TOAST$FAILED_TO_STOP_CONVERSATION = "TOAST$FAILED_TO_STOP_CONVERSATION",
   TOAST$CONVERSATION_STOPPED = "TOAST$CONVERSATION_STOPPED",
+  AGENT_STATUS$WAITING_FOR_USER_CONFIRMATION = "AGENT_STATUS$WAITING_FOR_USER_CONFIRMATION",
 }

frontend/src/i18n/translation.json

@@ -6160,20 +6160,20 @@
     "uk": "Введіть свій ключ API."
   },
   "SETTINGS$LLM_API_KEY": {
-    "en": "LLM API Key",
-    "zh-CN": "LLM API 密钥",
-    "zh-TW": "LLM API 金鑰",
-    "de": "LLM API Schlüssel",
-    "ko-KR": "LLM API 키",
-    "no": "LLM API-nøkkel",
-    "it": "Chiave API LLM",
-    "pt": "Chave API LLM",
-    "es": "Clave API LLM",
-    "ar": "مفتاح API للنماذج اللغوية الكبيرة",
-    "fr": "Clé API LLM",
-    "tr": "LLM API Anahtarı",
-    "ja": "LLM APIキー",
-    "uk": "Ключ API LLM"
+    "en": "OpenHands LLM Key",
+    "zh-CN": "OpenHands LLM 密钥",
+    "zh-TW": "OpenHands LLM 金鑰",
+    "de": "OpenHands LLM Schlüssel",
+    "ko-KR": "OpenHands LLM 키",
+    "no": "OpenHands LLM-nøkkel",
+    "it": "Chiave LLM OpenHands",
+    "pt": "Chave LLM OpenHands",
+    "es": "Clave LLM OpenHands",
+    "ar": "مفتاح LLM OpenHands",
+    "fr": "Clé LLM OpenHands",
+    "tr": "OpenHands LLM Anahtarı",
+    "ja": "OpenHands LLMキー",
+    "uk": "Ключ LLM OpenHands"
   },
   "SETTINGS$LLM_API_KEY_DESCRIPTION": {
     "en": "You can use this API Key as the LLM API Key for OpenHands open-source and CLI. It will incur cost on your OpenHands Cloud account. Do NOT share this key elsewhere.",
@@ -14320,20 +14320,20 @@
     "uk": "Зупинити сервер"
   },
   "COMMON$TERMINAL": {
-    "en": "Terminal",
-    "ja": "ターミナル",
-    "zh-CN": "终端",
-    "zh-TW": "終端機",
-    "ko-KR": "터미널",
-    "no": "Terminal",
-    "it": "Terminale",
-    "pt": "Terminal",
-    "es": "Terminal",
-    "ar": "الطرفية",
-    "fr": "Terminal",
-    "tr": "Terminal",
-    "de": "Terminal",
-    "uk": "Термінал"
+    "en": "Terminal (read-only)",
+    "ja": "ターミナル (読み取り専用)",
+    "zh-CN": "终端（只读）",
+    "zh-TW": "終端機（唯讀）",
+    "ko-KR": "터미널 (읽기 전용)",
+    "no": "Terminal (skrivebeskyttet)",
+    "it": "Terminale (sola lettura)",
+    "pt": "Terminal (somente leitura)",
+    "es": "Terminal (solo lectura)",
+    "ar": "الطرفية (للقراءة فقط)",
+    "fr": "Terminal (lecture seule)",
+    "tr": "Terminal (salt okunur)",
+    "de": "Terminal (schreibgeschützt)",
+    "uk": "Термінал (тільки читання)"
   },
   "COMMON$UNKNOWN": {
     "en": "Unknown",
@@ -14878,5 +14878,21 @@
     "tr": "Konuşma durduruldu",
     "de": "Konversation gestoppt",
     "uk": "Розмову зупинено"
+  },
+  "AGENT_STATUS$WAITING_FOR_USER_CONFIRMATION": {
+    "en": "Waiting for user confirmation",
+    "ja": "ユーザーの確認を待っています",
+    "zh-CN": "等待用户确认",
+    "zh-TW": "等待使用者確認",
+    "ko-KR": "사용자 확인 대기 중",
+    "no": "Venter på brukerbekreftelse",
+    "it": "In attesa di conferma dell'utente",
+    "pt": "Aguardando confirmação do usuário",
+    "es": "Esperando confirmación del usuario",
+    "ar": "في انتظار تأكيد المستخدم",
+    "fr": "En attente de la confirmation de l'utilisateur",
+    "tr": "Kullanıcı onayı bekleniyor",
+    "de": "Warte auf Benutzerbestätigung",
+    "uk": "Очікується підтвердження користувача"
   }
 }

frontend/src/icons/jupyter-large.svg

@@ -1,3 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="113" height="113" viewBox="0 0 113 113" fill="none">
-  <path d="M57.9521 83.6306C57.2282 83.6659 56.3772 83.6871 55.5226 83.6871C41.334 83.6871 28.5015 77.8853 19.2672 68.5204L19.2602 68.5134C22.177 76.7765 27.3821 83.6271 34.1162 88.4967L34.2362 88.5814C40.8185 93.3522 49.0569 96.216 57.9627 96.216C66.8685 96.216 75.1034 93.3557 81.8022 88.5038L81.6821 88.585C88.5327 83.6306 93.7378 76.7835 96.5663 68.81L96.6546 68.5204C87.4062 77.8888 74.5631 83.6907 60.3675 83.6907C59.5164 83.6907 58.6689 83.6695 57.8285 83.6271L57.9521 83.6306ZM57.9486 24.9624C58.676 24.9236 59.527 24.9024 60.3851 24.9024C74.5702 24.9024 87.4027 30.7043 96.6334 40.0656L96.6405 40.0727C93.7237 31.8095 88.5186 24.9589 81.788 20.0893L81.668 20.0046C75.0857 15.2374 66.8473 12.3806 57.9415 12.3806C49.0357 12.3806 40.8008 15.2374 34.0985 20.0893L34.2186 20.0081C27.3644 24.9589 22.1593 31.8095 19.3308 39.7831L19.2425 40.0727C28.5015 30.7078 41.3517 24.9059 55.5579 24.9059C56.3983 24.9059 57.2388 24.9271 58.0686 24.966L57.9486 24.9624ZM25.5776 18.2672C25.5776 19.549 25.0585 20.7108 24.2216 21.5548C23.3882 22.3952 22.2335 22.9178 20.9587 22.9178C19.6839 22.9178 18.5257 22.3952 17.6958 21.5548C16.8589 20.7108 16.3398 19.5455 16.3398 18.2637C16.3398 16.9818 16.8589 15.8165 17.6958 14.9725C18.5292 14.1321 19.6839 13.6095 20.9587 13.6095C22.2335 13.6095 23.3918 14.1321 24.2251 14.9761C25.062 15.82 25.5776 16.9818 25.5776 18.2672ZM94.3734 9.84516C94.3734 9.84869 94.3734 9.85222 94.3734 9.85222C94.3734 11.5861 93.6742 13.1575 92.5442 14.2981C91.4178 15.4387 89.8534 16.1449 88.1266 16.1449C86.3998 16.1449 84.8355 15.4387 83.709 14.3016C82.579 13.1575 81.8798 11.5825 81.8798 9.84516C81.8798 8.10779 82.579 6.53285 83.709 5.38872C84.8355 4.25166 86.3963 3.54541 88.1266 3.54541C89.8569 3.54541 91.4178 4.25166 92.5442 5.38872C93.6742 6.52932 94.3734 8.10072 94.3734 9.8381V9.84516ZM35.1296 101.516C35.1296 101.516 35.1296 101.52 35.1296 101.523C35.1296 103.709 34.2503 105.69 32.8237 107.131C31.4042 108.568 29.4337 109.458 27.2585 109.458C25.0832 109.458 23.1128 108.568 21.6932 107.135C20.2666 105.694 19.3873 103.709 19.3873 101.52C19.3873 99.3306 20.2666 97.3495 21.6932 95.9053C23.1128 94.468 25.0797 93.5817 27.2585 93.5817C29.4372 93.5817 31.4042 94.4716 32.8237 95.9088C34.2468 97.3495 35.1296 99.3306 35.1296 101.516C35.1296 101.52 35.1296 101.52 35.1296 101.523V101.516Z" fill="currentColor"/>
-</svg>

frontend/src/icons/jupyter.svg

@@ -1,9 +0,0 @@
-<svg  viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
-  <g transform="scale(0.85) translate(1.8, 1.8)">
-    <path d="M19.5 1.5C18.67 1.5 18 2.17 18 3C18 3.83 18.67 4.5 19.5 4.5C20.33 4.5 21 3.83 21 3C21 2.17 20.33 1.5 19.5 1.5Z" fill="currentColor"/>
-    <path d="M12 18C8.5 18 5.5 16.8 4 15C4 18.3137 7.13401 21 12 21C16.866 21 20 18.3137 20 15C18.5 16.8 15.5 18 12 18Z" fill="currentColor"/>
-    <path d="M12 6C15.5 6 18.5 7.2 20 9C20 5.68629 16.866 3 12 3C7.13401 3 4 5.68629 4 9C5.5 7.2 8.5 6 12 6Z" fill="currentColor"/>
-    <path d="M7.5 21C6.67 21 6 21.67 6 22.5C6 23.33 6.67 24 7.5 24C8.33 24 9 23.33 9 22.5C9 21.67 8.33 21 7.5 21Z" fill="currentColor"/>
-    <path d="M4.5 5.5C3.67 5.5 3 4.83 3 4C3 3.17 3.67 2.5 4.5 2.5C5.33 2.5 6 3.17 6 4C6 4.83 5.33 5.5 4.5 5.5Z" fill="currentColor"/>
-  </g>
-</svg>

frontend/src/routes/changes-tab.tsx

@@ -2,7 +2,7 @@ import { useTranslation } from "react-i18next";
 import React from "react";
 import { FileDiffViewer } from "#/components/features/diff-viewer/file-diff-viewer";
 import { retrieveAxiosErrorMessage } from "#/utils/retrieve-axios-error-message";
-import { useGetGitChanges } from "#/hooks/query/use-get-git-changes";
+import { useUnifiedGetGitChanges } from "#/hooks/query/use-unified-get-git-changes";
 import { I18nKey } from "#/i18n/declaration";
 import { RUNTIME_INACTIVE_STATES } from "#/types/agent-state";
 import { RandomTip } from "#/components/features/tips/random-tip";
@@ -27,7 +27,7 @@ function GitChanges() {
     isError,
     error,
     isLoading: loadingGitChanges,
-  } = useGetGitChanges();
+  } = useUnifiedGetGitChanges();
 
   const [statusMessage, setStatusMessage] = React.useState<string[] | null>(
     null,

frontend/src/routes/conversation.tsx

@@ -4,7 +4,6 @@ import { useTranslation } from "react-i18next";
 
 import { useConversationId } from "#/hooks/use-conversation-id";
 import { useCommandStore } from "#/state/command-store";
-import { useJupyterStore } from "#/state/jupyter-store";
 import { useConversationStore } from "#/state/conversation-store";
 import { useAgentStore } from "#/stores/agent-store";
 import { AgentState } from "#/types/agent-state";
@@ -53,7 +52,6 @@ function AppContent() {
   const setCurrentAgentState = useAgentStore(
     (state) => state.setCurrentAgentState,
   );
-  const clearJupyter = useJupyterStore((state) => state.clearJupyter);
   const removeErrorMessage = useErrorMessageStore(
     (state) => state.removeErrorMessage,
   );
@@ -70,7 +68,6 @@ function AppContent() {
   // 1. Cleanup Effect - runs when navigating to a different conversation
   React.useEffect(() => {
     clearTerminal();
-    clearJupyter();
     resetConversationState();
     setCurrentAgentState(AgentState.LOADING);
     removeErrorMessage();
@@ -84,7 +81,6 @@ function AppContent() {
   }, [
     conversationId,
     clearTerminal,
-    clearJupyter,
     resetConversationState,
     setCurrentAgentState,
     removeErrorMessage,

frontend/src/routes/jupyter-tab.tsx

@@ -1,44 +0,0 @@
-import React from "react";
-import { JupyterEditor } from "#/components/features/jupyter/jupyter";
-
-function Jupyter() {
-  const parentRef = React.useRef<HTMLDivElement>(null);
-  const [parentWidth, setParentWidth] = React.useState(0);
-
-  // This is a hack to prevent the editor from overflowing
-  // Should be removed after revising the parent and containers
-  // Use ResizeObserver to properly track parent width changes
-  React.useEffect(() => {
-    let resizeObserver: ResizeObserver | null = null;
-
-    resizeObserver = new ResizeObserver((entries) => {
-      for (const entry of entries) {
-        // Use contentRect.width for more accurate measurements
-        const { width } = entry.contentRect;
-        if (width > 0) {
-          setParentWidth(width);
-        }
-      }
-    });
-
-    if (parentRef.current) {
-      resizeObserver.observe(parentRef.current);
-    }
-
-    return () => {
-      resizeObserver?.disconnect();
-    };
-  }, []);
-
-  // Provide a fallback width to prevent the editor from being hidden
-  // Use parentWidth if available, otherwise use a large default
-  const maxWidth = parentWidth > 0 ? parentWidth : 9999;
-
-  return (
-    <div ref={parentRef} className="h-full">
-      <JupyterEditor maxWidth={maxWidth} />
-    </div>
-  );
-}
-
-export default Jupyter;

frontend/src/routes/llm-settings.tsx

@@ -28,12 +28,6 @@ import { KeyStatusIcon } from "#/components/features/settings/key-status-icon";
 import { DEFAULT_SETTINGS } from "#/services/settings";
 import { getProviderId } from "#/utils/map-provider";
 import { DEFAULT_OPENHANDS_MODEL } from "#/utils/verified-models";
-import { useSubscriptionAccess } from "#/hooks/query/use-subscription-access";
-import { UpgradeBannerWithBackdrop } from "#/components/features/settings/upgrade-banner-with-backdrop";
-import { useCreateSubscriptionCheckoutSession } from "#/hooks/mutation/stripe/use-create-subscription-checkout-session";
-import { useIsAuthed } from "#/hooks/query/use-is-authed";
-import { cn } from "#/utils/utils";
-import { useIsAllHandsSaaSEnvironment } from "#/hooks/use-is-all-hands-saas-environment";
 
 interface OpenHandsApiKeyHelpProps {
   testId: string;
@@ -75,11 +69,6 @@ function LlmSettingsScreen() {
   const { data: resources } = useAIConfigOptions();
   const { data: settings, isLoading, isFetching } = useSettings();
   const { data: config } = useConfig();
-  const { data: subscriptionAccess } = useSubscriptionAccess();
-  const { data: isAuthed } = useIsAuthed();
-  const { mutate: createSubscriptionCheckoutSession } =
-    useCreateSubscriptionCheckoutSession();
-  const isAllHandsSaaSEnvironment = useIsAllHandsSaaSEnvironment();
 
   const [view, setView] = React.useState<"basic" | "advanced">("basic");
 
@@ -442,44 +431,16 @@ function LlmSettingsScreen() {
 
   if (!settings || isFetching) return <LlmSettingsInputsSkeleton />;
 
-  // Show upgrade banner and disable form in SaaS mode when user doesn't have an active subscription
-  // Exclude self-hosted enterprise customers (those not on all-hands.dev domains)
-  const shouldShowUpgradeBanner =
-    config?.APP_MODE === "saas" &&
-    !subscriptionAccess &&
-    isAllHandsSaaSEnvironment;
-
   const formAction = (formData: FormData) => {
-    // Prevent form submission for unsubscribed SaaS users
-    if (shouldShowUpgradeBanner) return;
-
     if (view === "basic") basicFormAction(formData);
     else advancedFormAction(formData);
   };
 
   return (
-    <div
-      data-testid="llm-settings-screen"
-      className={cn(
-        "h-full relative",
-        shouldShowUpgradeBanner && "overflow-hidden",
-      )}
-    >
-      {shouldShowUpgradeBanner && (
-        <UpgradeBannerWithBackdrop
-          onUpgradeClick={() => {
-            createSubscriptionCheckoutSession();
-          }}
-          isDisabled={!isAuthed}
-        />
-      )}
+    <div data-testid="llm-settings-screen" className="h-full relative">
       <form
         action={formAction}
-        className={cn(
-          "flex flex-col h-full justify-between",
-          shouldShowUpgradeBanner && "h-[calc(100%-theme(spacing.12))]",
-        )}
-        inert={shouldShowUpgradeBanner}
+        className="flex flex-col h-full justify-between"
       >
         <div className="flex flex-col gap-6">
           <SettingsSwitch
@@ -487,7 +448,6 @@ function LlmSettingsScreen() {
             defaultIsToggled={view === "advanced"}
             onToggle={handleToggleAdvancedSettings}
             isToggled={view === "advanced"}
-            isDisabled={shouldShowUpgradeBanner}
           >
             {t(I18nKey.SETTINGS$ADVANCED)}
           </SettingsSwitch>
@@ -496,7 +456,6 @@ function LlmSettingsScreen() {
             <div
               data-testid="llm-settings-form-basic"
               className="flex flex-col gap-6"
-              aria-disabled={shouldShowUpgradeBanner ? "true" : undefined}
             >
               {!isLoading && !isFetching && (
                 <>
@@ -504,7 +463,6 @@ function LlmSettingsScreen() {
                     models={modelsAndProviders}
                     currentModel={settings.LLM_MODEL || DEFAULT_OPENHANDS_MODEL}
                     onChange={handleModelIsDirty}
-                    isDisabled={shouldShowUpgradeBanner}
                     wrapperClassName="!flex-col !gap-6"
                   />
                   {(settings.LLM_MODEL?.startsWith("openhands/") ||
@@ -522,7 +480,6 @@ function LlmSettingsScreen() {
                 className="w-full max-w-[680px]"
                 placeholder={settings.LLM_API_KEY_SET ? "<hidden>" : ""}
                 onChange={handleApiKeyIsDirty}
-                isDisabled={shouldShowUpgradeBanner}
                 startContent={
                   settings.LLM_API_KEY_SET && (
                     <KeyStatusIcon isSet={settings.LLM_API_KEY_SET} />
@@ -602,7 +559,6 @@ function LlmSettingsScreen() {
                     defaultValue={settings.SEARCH_API_KEY || ""}
                     onChange={handleSearchApiKeyIsDirty}
                     placeholder={t(I18nKey.API$TVLY_KEY_EXAMPLE)}
-                    isDisabled={shouldShowUpgradeBanner}
                     startContent={
                       settings.SEARCH_API_KEY_SET && (
                         <KeyStatusIcon isSet={settings.SEARCH_API_KEY_SET} />
@@ -672,7 +628,6 @@ function LlmSettingsScreen() {
                   onToggle={handleConfirmationModeIsDirty}
                   defaultIsToggled={settings.CONFIRMATION_MODE}
                   isBeta
-                  isDisabled={shouldShowUpgradeBanner}
                 >
                   {t(I18nKey.SETTINGS$CONFIRMATION_MODE)}
                 </SettingsSwitch>

frontend/src/routes/served-tab.tsx

@@ -2,14 +2,14 @@ import React from "react";
 import { FaArrowRotateRight } from "react-icons/fa6";
 import { FaExternalLinkAlt, FaHome } from "react-icons/fa";
 import { useTranslation } from "react-i18next";
-import { useActiveHost } from "#/hooks/query/use-active-host";
+import { useUnifiedActiveHost } from "#/hooks/query/use-unified-active-host";
 import { PathForm } from "#/components/features/served-host/path-form";
 import { I18nKey } from "#/i18n/declaration";
 import ServerProcessIcon from "#/icons/server-process.svg?react";
 
 function ServedApp() {
   const { t } = useTranslation();
-  const { activeHost } = useActiveHost();
+  const { activeHost } = useUnifiedActiveHost();
   const [refreshKey, setRefreshKey] = React.useState(0);
   const [currentActiveHost, setCurrentActiveHost] = React.useState<
     string | null

frontend/src/routes/settings.tsx

@@ -6,7 +6,6 @@ import { Route } from "./+types/settings";
 import OptionService from "#/api/option-service/option-service.api";
 import { queryClient } from "#/query-client-config";
 import { GetConfigResponse } from "#/api/option-service/option.types";
-import { useSubscriptionAccess } from "#/hooks/query/use-subscription-access";
 import { SAAS_NAV_ITEMS, OSS_NAV_ITEMS } from "#/constants/settings-nav";
 import { Typography } from "#/ui/typography";
 import { SettingsLayout } from "#/components/features/settings/settings-layout";
@@ -41,7 +40,6 @@ export const clientLoader = async ({ request }: Route.ClientLoaderArgs) => {
 function SettingsScreen() {
   const { t } = useTranslation();
   const { data: config } = useConfig();
-  const { data: subscriptionAccess } = useSubscriptionAccess();
   const location = useLocation();
 
   const isSaas = config?.APP_MODE === "saas";
@@ -55,7 +53,7 @@ function SettingsScreen() {
       items.push(...OSS_NAV_ITEMS);
     }
     return items;
-  }, [isSaas, !!subscriptionAccess]);
+  }, [isSaas]);
 
   // Current section title for the main content area
   const currentSectionTitle = useMemo(() => {
@@ -65,7 +63,7 @@ function SettingsScreen() {
 
   return (
     <main data-testid="settings-screen" className="h-full">
-      <SettingsLayout navigationItems={navItems} isSaas={isSaas}>
+      <SettingsLayout navigationItems={navItems}>
         <div className="flex flex-col gap-6 h-full">
           <Typography.H2>{t(currentSectionTitle)}</Typography.H2>
           <div className="flex-1 overflow-auto custom-scrollbar-always">

frontend/src/routes/vscode-tab.tsx

@@ -2,14 +2,14 @@ import React, { useState, useEffect } from "react";
 import { useTranslation } from "react-i18next";
 import { I18nKey } from "#/i18n/declaration";
 import { RUNTIME_INACTIVE_STATES } from "#/types/agent-state";
-import { useVSCodeUrl } from "#/hooks/query/use-vscode-url";
+import { useUnifiedVSCodeUrl } from "#/hooks/query/use-unified-vscode-url";
 import { VSCODE_IN_NEW_TAB } from "#/utils/feature-flags";
 import { WaitingForRuntimeMessage } from "#/components/features/chat/waiting-for-runtime-message";
 import { useAgentState } from "#/hooks/use-agent-state";
 
 function VSCodeTab() {
   const { t } = useTranslation();
-  const { data, isLoading, error } = useVSCodeUrl();
+  const { data, isLoading, error } = useUnifiedVSCodeUrl();
   const { curAgentState } = useAgentState();
   const isRuntimeInactive = RUNTIME_INACTIVE_STATES.includes(curAgentState);
   const iframeRef = React.useRef<HTMLIFrameElement>(null);
@@ -39,10 +39,18 @@ function VSCodeTab() {
     }
   };
 
-  if (isRuntimeInactive || isLoading) {
+  if (isRuntimeInactive) {
     return <WaitingForRuntimeMessage />;
   }
 
+  if (isLoading) {
+    return (
+      <div className="w-full h-full flex items-center text-center justify-center text-2xl text-tertiary-light">
+        {t(I18nKey.VSCODE$LOADING)}
+      </div>
+    );
+  }
+
   if (error || (data && data.error) || !data?.url || iframeError) {
     return (
       <div className="w-full h-full flex items-center text-center justify-center text-2xl text-tertiary-light">

frontend/src/services/actions.ts

@@ -8,7 +8,6 @@ import {
   StatusMessage,
 } from "#/types/message";
 import { handleObservationMessage } from "./observations";
-import { useJupyterStore } from "#/state/jupyter-store";
 import { useCommandStore } from "#/state/command-store";
 import { queryClient } from "#/query-client-config";
 import {
@@ -35,10 +34,6 @@ export function handleActionMessage(message: ActionMessage) {
     useCommandStore.getState().appendInput(message.args.command);
   }
 
-  if (message.action === ActionType.RUN_IPYTHON) {
-    useJupyterStore.getState().appendJupyterInput(message.args.code);
-  }
-
   if ("args" in message && "security_risk" in message.args) {
     useSecurityAnalyzerStore.getState().appendSecurityAnalyzerInput({
       id: message.id,

frontend/src/services/observations.ts

@@ -1,5 +1,4 @@
 import { ObservationMessage } from "#/types/message";
-import { useJupyterStore } from "#/state/jupyter-store";
 import { useCommandStore } from "#/state/command-store";
 import ObservationType from "#/types/observation-type";
 import { useBrowserStore } from "#/stores/browser-store";
@@ -22,14 +21,6 @@ export function handleObservationMessage(message: ObservationMessage) {
       useCommandStore.getState().appendOutput(content);
       break;
     }
-    case ObservationType.RUN_IPYTHON:
-      useJupyterStore.getState().appendJupyterOutput({
-        content: message.content,
-        imageUrls: Array.isArray(message.extras?.image_urls)
-          ? message.extras.image_urls
-          : undefined,
-      });
-      break;
     case ObservationType.BROWSE:
     case ObservationType.BROWSE_INTERACTIVE:
       if (

frontend/src/state/conversation-store.ts

@@ -4,7 +4,6 @@ import { devtools } from "zustand/middleware";
 export type ConversationTab =
   | "editor"
   | "browser"
-  | "jupyter"
   | "served"
   | "vscode"
   | "terminal";

frontend/src/state/jupyter-store.ts

@@ -1,40 +0,0 @@
-import { create } from "zustand";
-
-export type Cell = {
-  content: string;
-  type: "input" | "output";
-  imageUrls?: string[];
-};
-
-interface JupyterState {
-  cells: Cell[];
-  appendJupyterInput: (content: string) => void;
-  appendJupyterOutput: (payload: {
-    content: string;
-    imageUrls?: string[];
-  }) => void;
-  clearJupyter: () => void;
-}
-
-export const useJupyterStore = create<JupyterState>((set) => ({
-  cells: [],
-  appendJupyterInput: (content: string) =>
-    set((state) => ({
-      cells: [...state.cells, { content, type: "input" }],
-    })),
-  appendJupyterOutput: (payload: { content: string; imageUrls?: string[] }) =>
-    set((state) => ({
-      cells: [
-        ...state.cells,
-        {
-          content: payload.content,
-          type: "output",
-          imageUrls: payload.imageUrls,
-        },
-      ],
-    })),
-  clearJupyter: () =>
-    set(() => ({
-      cells: [],
-    })),
-}));

frontend/src/stores/event-message-store.ts

@@ -2,15 +2,19 @@ import { create } from "zustand";
 
 interface EventMessageState {
   submittedEventIds: number[]; // Avoid the flashing issue of the confirmation buttons
+  v1SubmittedEventIds: string[]; // V1 event IDs (V1 uses string IDs)
 }
 
 interface EventMessageStore extends EventMessageState {
   addSubmittedEventId: (id: number) => void;
   removeSubmittedEventId: (id: number) => void;
+  addV1SubmittedEventId: (id: string) => void;
+  removeV1SubmittedEventId: (id: string) => void;
 }
 
 export const useEventMessageStore = create<EventMessageStore>((set) => ({
   submittedEventIds: [],
+  v1SubmittedEventIds: [],
   addSubmittedEventId: (id: number) =>
     set((state) => ({
       submittedEventIds: [...state.submittedEventIds, id],
@@ -21,4 +25,14 @@ export const useEventMessageStore = create<EventMessageStore>((set) => ({
         (eventId) => eventId !== id,
       ),
     })),
+  addV1SubmittedEventId: (id: string) =>
+    set((state) => ({
+      v1SubmittedEventIds: [...state.v1SubmittedEventIds, id],
+    })),
+  removeV1SubmittedEventId: (id: string) =>
+    set((state) => ({
+      v1SubmittedEventIds: state.v1SubmittedEventIds.filter(
+        (eventId) => eventId !== id,
+      ),
+    })),
 }));

frontend/src/types/tab-option.tsx

@@ -1,21 +1,10 @@
 enum TabOption {
   PLANNER = "planner",
   BROWSER = "browser",
-  JUPYTER = "jupyter",
   VSCODE = "vscode",
 }
 
-type TabType =
-  | TabOption.PLANNER
-  | TabOption.BROWSER
-  | TabOption.JUPYTER
-  | TabOption.VSCODE;
-
-const AllTabs = [
-  TabOption.VSCODE,
-  TabOption.BROWSER,
-  TabOption.PLANNER,
-  TabOption.JUPYTER,
-];
+type TabType = TabOption.PLANNER | TabOption.BROWSER | TabOption.VSCODE;
+const AllTabs = [TabOption.VSCODE, TabOption.BROWSER, TabOption.PLANNER];
 
 export { AllTabs, TabOption, type TabType };

frontend/src/utils/cache-utils.ts

@@ -24,6 +24,7 @@ export const handleActionEventCacheInvalidation = (
   // Invalidate file_changes cache for file-related actions
   if (
     action.kind === "StrReplaceEditorAction" ||
+    action.kind === "FileEditorAction" ||
     action.kind === "ExecuteBashAction"
   ) {
     queryClient.invalidateQueries(
@@ -35,7 +36,11 @@ export const handleActionEventCacheInvalidation = (
   }
 
   // Invalidate specific file diff cache for file modifications
-  if (action.kind === "StrReplaceEditorAction" && action.path) {
+  if (
+    (action.kind === "StrReplaceEditorAction" ||
+      action.kind === "FileEditorAction") &&
+    action.path
+  ) {
     const strippedPath = stripWorkspacePrefix(action.path);
     queryClient.invalidateQueries({
       queryKey: ["file_diff", conversationId, strippedPath],

frontend/src/utils/get-git-path.ts

@@ -0,0 +1,22 @@
+/**
+ * Get the git repository path for a conversation
+ * If a repository is selected, returns /workspace/project/{repo-name}
+ * Otherwise, returns /workspace/project
+ *
+ * @param selectedRepository The selected repository (e.g., "OpenHands/OpenHands" or "owner/repo")
+ * @returns The git path to use
+ */
+export function getGitPath(
+  selectedRepository: string | null | undefined,
+): string {
+  if (!selectedRepository) {
+    return "/workspace/project";
+  }
+
+  // Extract the repository name from "owner/repo" format
+  // The folder name is the second part after "/"
+  const parts = selectedRepository.split("/");
+  const repoName = parts.length > 1 ? parts[1] : parts[0];
+
+  return `/workspace/project/${repoName}`;
+}

frontend/src/utils/git-status-mapper.ts

@@ -0,0 +1,27 @@
+import type {
+  GitChangeStatus,
+  V1GitChangeStatus,
+} from "#/api/open-hands.types";
+
+/**
+ * Maps V1 git change status to legacy V0 status format
+ *
+ * V1 -> V0 mapping:
+ * - ADDED -> A (Added)
+ * - DELETED -> D (Deleted)
+ * - UPDATED -> M (Modified)
+ * - MOVED -> R (Renamed)
+ *
+ * @param v1Status The V1 git change status
+ * @returns The equivalent V0 git change status
+ */
+export function mapV1ToV0Status(v1Status: V1GitChangeStatus): GitChangeStatus {
+  const statusMap: Record<V1GitChangeStatus, GitChangeStatus> = {
+    ADDED: "A",
+    DELETED: "D",
+    UPDATED: "M",
+    MOVED: "R",
+  };
+
+  return statusMap[v1Status];
+}

frontend/src/utils/parse-cell-content.ts

@@ -1,32 +0,0 @@
-export type JupyterLine = {
-  type: "plaintext" | "image";
-  content: string;
-  url?: string;
-};
-
-export const parseCellContent = (content: string, imageUrls?: string[]) => {
-  const lines: JupyterLine[] = [];
-  let currentText = "";
-
-  // First, process the text content
-  for (const line of content.split("\n")) {
-    currentText += `${line}\n`;
-  }
-
-  if (currentText) {
-    lines.push({ type: "plaintext", content: currentText });
-  }
-
-  // Then, add image lines if we have image URLs
-  if (imageUrls && imageUrls.length > 0) {
-    imageUrls.forEach((url) => {
-      lines.push({
-        type: "image",
-        content: `![image](${url})`,
-        url,
-      });
-    });
-  }
-
-  return lines;
-};

frontend/src/utils/status.ts

@@ -24,7 +24,7 @@ export const AGENT_STATUS_MAP: {
   // Ready/Idle/Waiting for user input states
   [AgentState.AWAITING_USER_INPUT]: I18nKey.AGENT_STATUS$WAITING_FOR_TASK,
   [AgentState.AWAITING_USER_CONFIRMATION]:
-    I18nKey.AGENT_STATUS$WAITING_FOR_TASK,
+    I18nKey.AGENT_STATUS$WAITING_FOR_USER_CONFIRMATION,
   [AgentState.USER_CONFIRMED]: I18nKey.AGENT_STATUS$WAITING_FOR_TASK,
   [AgentState.USER_REJECTED]: I18nKey.AGENT_STATUS$WAITING_FOR_TASK,
   [AgentState.FINISHED]: I18nKey.AGENT_STATUS$WAITING_FOR_TASK,

frontend/src/utils/utils.ts

@@ -594,3 +594,18 @@ export const hasOpenHandsSuffix = (
   }
   return repo.full_name.endsWith("/.openhands");
 };
+
+/**
+ * Build headers for V1 API requests that require session authentication
+ * @param sessionApiKey Session API key for authentication
+ * @returns Headers object with X-Session-API-Key if provided
+ */
+export const buildSessionHeaders = (
+  sessionApiKey?: string | null,
+): Record<string, string> => {
+  const headers: Record<string, string> = {};
+  if (sessionApiKey) {
+    headers["X-Session-API-Key"] = sessionApiKey;
+  }
+  return headers;
+};

openhands-cli/build.py

@@ -15,13 +15,12 @@ import sys
 import time
 from pathlib import Path
 
-from openhands_cli.llm_utils import get_llm_metadata
-from openhands_cli.locations import AGENT_SETTINGS_PATH, PERSISTENCE_DIR, WORK_DIR
+from openhands_cli.utils import get_llm_metadata, get_default_cli_agent
+from openhands_cli.locations import AGENT_SETTINGS_PATH, PERSISTENCE_DIR
 
 from openhands.sdk import LLM
-from openhands.tools.preset.default import get_default_agent
 
-dummy_agent = get_default_agent(
+dummy_agent = get_default_cli_agent(
     llm=LLM(
         model='dummy-model',
         api_key='dummy-key',

openhands-cli/openhands_cli/agent_chat.py

@@ -6,6 +6,7 @@ Provides a conversation interface with an AI agent using OpenHands patterns.
 
 import sys
 from datetime import datetime
+import uuid
 
 from openhands.sdk import (
     Message,
@@ -16,7 +17,11 @@ from prompt_toolkit import print_formatted_text
 from prompt_toolkit.formatted_text import HTML
 
 from openhands_cli.runner import ConversationRunner
-from openhands_cli.setup import MissingAgentSpec, setup_conversation, start_fresh_conversation
+from openhands_cli.setup import (
+    MissingAgentSpec,
+    setup_conversation,
+    verify_agent_exists_or_setup_agent
+)
 from openhands_cli.tui.settings.mcp_screen import MCPScreen
 from openhands_cli.tui.settings.settings_screen import SettingsScreen
 from openhands_cli.tui.status import display_status
@@ -65,21 +70,33 @@ def run_cli_entry(resume_conversation_id: str | None = None) -> None:
         EOFError: If EOF is encountered
     """
 
+    conversation_id = uuid.uuid4()
+    if resume_conversation_id:
+        try:
+            conversation_id = uuid.UUID(resume_conversation_id)
+        except ValueError as e:
+            print_formatted_text(
+                HTML(
+                    f"<yellow>Warning: '{resume_conversation_id}' is not a valid UUID.</yellow>"
+                )
+            )
+            return
+
     try:
-        conversation = start_fresh_conversation(resume_conversation_id)
+        initialized_agent = verify_agent_exists_or_setup_agent()
     except MissingAgentSpec:
         print_formatted_text(HTML('\n<yellow>Setup is required to use OpenHands CLI.</yellow>'))
         print_formatted_text(HTML('\n<yellow>Goodbye! 👋</yellow>'))
         return
 
 
-    display_welcome(conversation.id, bool(resume_conversation_id))
+    display_welcome(conversation_id, bool(resume_conversation_id))
 
     # Track session start time for uptime calculation
     session_start_time = datetime.now()
 
     # Create conversation runner to handle state machine logic
-    runner = ConversationRunner(conversation)
+    runner = None
     session = get_session_prompter()
 
     # Main chat loop
@@ -106,7 +123,7 @@ def run_cli_entry(resume_conversation_id: str | None = None) -> None:
                 exit_confirmation = exit_session_confirmation()
                 if exit_confirmation == UserConfirmation.ACCEPT:
                     print_formatted_text(HTML('\n<yellow>Goodbye! 👋</yellow>'))
-                    _print_exit_hint(conversation.id)
+                    _print_exit_hint(conversation_id)
                     break
 
             elif command == '/settings':
@@ -116,19 +133,19 @@ def run_cli_entry(resume_conversation_id: str | None = None) -> None:
 
             elif command == '/mcp':
                 mcp_screen = MCPScreen()
-                mcp_screen.display_mcp_info(conversation.agent)
+                mcp_screen.display_mcp_info(initialized_agent)
                 continue
 
             elif command == '/clear':
-                display_welcome(conversation.id)
+                display_welcome(conversation_id)
                 continue
 
             elif command == '/new':
                 try:
                     # Start a fresh conversation (no resume ID = new conversation)
-                    conversation = setup_conversation()
+                    conversation = setup_conversation(conversation_id)
                     runner = ConversationRunner(conversation)
-                    display_welcome(conversation.id, resume=False)
+                    display_welcome(conversation_id, resume=False)
                     print_formatted_text(
                         HTML('<green>✓ Started fresh conversation</green>')
                     )
@@ -158,6 +175,13 @@ def run_cli_entry(resume_conversation_id: str | None = None) -> None:
                 continue
 
             elif command == '/resume':
+                if not runner:
+                    print_formatted_text(
+                        HTML('<yellow>No active conversation running...</yellow>')
+                    )
+                    continue
+
+                conversation = runner.conversation
                 if not (
                     conversation.state.agent_status == AgentExecutionStatus.PAUSED
                     or conversation.state.agent_status
@@ -171,6 +195,9 @@ def run_cli_entry(resume_conversation_id: str | None = None) -> None:
                 # Resume without new message
                 message = None
 
+            if not runner:
+                conversation = setup_conversation(conversation_id)
+                runner = ConversationRunner(conversation)
             runner.process_message(message)
 
             print()  # Add spacing
@@ -179,7 +206,7 @@ def run_cli_entry(resume_conversation_id: str | None = None) -> None:
             exit_confirmation = exit_session_confirmation()
             if exit_confirmation == UserConfirmation.ACCEPT:
                 print_formatted_text(HTML('\n<yellow>Goodbye! 👋</yellow>'))
-                _print_exit_hint(conversation.id)
+                _print_exit_hint(conversation_id)
                 break
 
     # Clean up terminal state

openhands-cli/openhands_cli/gui_launcher.py

@@ -104,8 +104,8 @@ def launch_gui_server(mount_cwd: bool = False, gpu: bool = False) -> None:
 
     # Get the current version for the Docker image
     version = get_openhands_version()
-    runtime_image = f'docker.all-hands.dev/openhands/runtime:{version}-nikolaik'
-    app_image = f'docker.all-hands.dev/openhands/openhands:{version}'
+    runtime_image = f'docker.openhands.dev/openhands/runtime:{version}-nikolaik'
+    app_image = f'docker.openhands.dev/openhands/openhands:{version}'
 
     print_formatted_text(HTML('<grey>Pulling required Docker images...</grey>'))
 

openhands-cli/openhands_cli/runner.py

@@ -120,6 +120,7 @@ class ConversationRunner:
             else:
                 raise Exception('Infinite loop')
 
+
     def _handle_confirmation_request(self) -> UserConfirmation:
         """Handle confirmation request from user.
 

openhands-cli/openhands_cli/setup.py

@@ -2,7 +2,7 @@ import uuid
 
 from prompt_toolkit import HTML, print_formatted_text
 
-from openhands.sdk import BaseConversation, Conversation, Workspace, register_tool
+from openhands.sdk import Agent, BaseConversation, Conversation, Workspace, register_tool
 from openhands.tools.execute_bash import BashTool
 from openhands.tools.file_editor import FileEditorTool
 from openhands.tools.task_tracker import TaskTrackerTool
@@ -26,8 +26,38 @@ class MissingAgentSpec(Exception):
     pass
 
 
-def setup_conversation(
+
+def load_agent_specs(
     conversation_id: str | None = None,
+) -> Agent:
+    agent_store = AgentStore()
+    agent = agent_store.load(session_id=conversation_id)
+    if not agent:
+        raise MissingAgentSpec(
+            'Agent specification not found. Please configure your agent settings.'
+        )
+    return agent
+
+
+def verify_agent_exists_or_setup_agent() -> Agent:
+    """Verify agent specs exists by attempting to load it.
+
+    """
+    settings_screen = SettingsScreen()
+    try:
+        agent = load_agent_specs()
+        return agent
+    except MissingAgentSpec:
+        # For first-time users, show the full settings flow with choice between basic/advanced
+        settings_screen.configure_settings(first_time=True)
+
+
+    # Try once again after settings setup attempt
+    return load_agent_specs()
+
+
+def setup_conversation(
+    conversation_id: uuid,
     include_security_analyzer: bool = True
 ) -> BaseConversation:
     """
@@ -40,28 +70,8 @@ def setup_conversation(
         MissingAgentSpec: If agent specification is not found or invalid.
     """
 
-    # Use provided conversation_id or generate a random one
-    if conversation_id is None:
-        conversation_id = uuid.uuid4()
-    elif isinstance(conversation_id, str):
-        try:
-            conversation_id = uuid.UUID(conversation_id)
-        except ValueError as e:
-            print_formatted_text(
-                HTML(
-                    f"<yellow>Warning: '{conversation_id}' is not a valid UUID.</yellow>"
-                )
-            )
-            raise e
-
     with LoadingContext('Initializing OpenHands agent...'):
-        agent_store = AgentStore()
-        agent = agent_store.load(session_id=str(conversation_id))
-        if not agent:
-            raise MissingAgentSpec(
-                'Agent specification not found. Please configure your agent settings.'
-            )
-
+        agent = load_agent_specs(str(conversation_id))
 
         if not include_security_analyzer:
             # Remove security analyzer from agent spec
@@ -86,31 +96,3 @@ def setup_conversation(
     )
     return conversation
 
-
-
-def start_fresh_conversation(
-    resume_conversation_id: str | None = None
-) -> BaseConversation:
-    """Start a fresh conversation by creating a new conversation instance.
-
-    Handles the complete conversation setup process including settings screen
-    if agent configuration is missing.
-
-    Args:
-        resume_conversation_id: Optional conversation ID to resume
-
-    Returns:
-        BaseConversation: A new conversation instance
-    """
-    conversation = None
-    settings_screen = SettingsScreen()
-    try:
-        conversation = setup_conversation(resume_conversation_id)
-        return conversation
-    except MissingAgentSpec:
-        # For first-time users, show the full settings flow with choice between basic/advanced
-        settings_screen.configure_settings(first_time=True)
-
-
-    # Try once again after settings setup attempt
-    return setup_conversation(resume_conversation_id)

openhands-cli/openhands_cli/tui/settings/settings_screen.py

@@ -1,13 +1,11 @@
 import os
 
 from openhands.sdk import LLM, BaseConversation, LocalFileStore
-from openhands.sdk.security.confirmation_policy import NeverConfirm
-from openhands.tools.preset.default import get_default_agent
 from prompt_toolkit import HTML, print_formatted_text
 from prompt_toolkit.shortcuts import print_container
 from prompt_toolkit.widgets import Frame, TextArea
 
-from openhands_cli.llm_utils import get_llm_metadata
+from openhands_cli.utils import get_llm_metadata, get_default_cli_agent
 from openhands_cli.locations import AGENT_SETTINGS_PATH, PERSISTENCE_DIR
 from openhands_cli.pt_style import COLOR_GREY
 from openhands_cli.tui.settings.store import AgentStore
@@ -176,13 +174,13 @@ class SettingsScreen:
             model=model,
             api_key=api_key,
             base_url=base_url,
-            service_id='agent',
+            usage_id='agent',
             metadata=get_llm_metadata(model_name=model, llm_type='agent'),
         )
 
         agent = self.agent_store.load()
         if not agent:
-            agent = get_default_agent(llm=llm, cli_mode=True)
+            agent = get_default_cli_agent(llm=llm)
 
         agent = agent.model_copy(update={'llm': llm})
         self.agent_store.save(agent)

openhands-cli/openhands_cli/tui/settings/store.py

@@ -5,7 +5,7 @@ from pathlib import Path
 from typing import Any
 
 from fastmcp.mcp_config import MCPConfig
-from openhands_cli.llm_utils import get_llm_metadata
+from openhands_cli.utils import get_llm_metadata
 from openhands_cli.locations import (
     AGENT_SETTINGS_PATH,
     MCP_CONFIG_FILE,

openhands-cli/openhands_cli/utils.py

@@ -2,7 +2,9 @@
 
 import os
 from typing import Any
-
+from openhands.sdk.security.llm_analyzer import LLMSecurityAnalyzer
+from openhands.tools.preset import get_default_agent
+from openhands.sdk import LLM
 
 def get_llm_metadata(
     model_name: str,
@@ -55,3 +57,20 @@ def get_llm_metadata(
     if user_id is not None:
         metadata['trace_user_id'] = user_id
     return metadata
+
+
+def get_default_cli_agent(
+    llm: LLM
+):
+    agent = get_default_agent(
+        llm=llm,
+        cli_mode=True
+    )
+
+    agent = agent.model_copy(
+        update={
+            'security_analyzer': LLMSecurityAnalyzer()
+        }
+    )
+    
+    return agent

openhands-cli/pyproject.toml

@@ -4,7 +4,7 @@ requires = [ "hatchling>=1.25" ]
 
 [project]
 name = "openhands"
-version = "1.0.2"
+version = "1.0.4"
 description = "OpenHands CLI - Terminal User Interface for OpenHands AI Agent"
 readme = "README.md"
 license = { text = "MIT" }
@@ -18,8 +18,8 @@ classifiers = [
 # Using Git URLs for dependencies so installs from PyPI pull from GitHub
 # TODO: pin package versions once agent-sdk has published PyPI packages
 dependencies = [
-  "openhands-sdk==1.0.0a3",
-  "openhands-tools==1.0.0a3",
+  "openhands-sdk==1.0.0a5",
+  "openhands-tools==1.0.0a5",
   "prompt-toolkit>=3",
   "typer>=0.17.4",
 ]

openhands-cli/tests/commands/test_new_command.py

@@ -4,51 +4,49 @@ from unittest.mock import MagicMock, patch
 from uuid import UUID
 from prompt_toolkit.input.defaults import create_pipe_input
 from prompt_toolkit.output.defaults import DummyOutput
-from openhands_cli.setup import MissingAgentSpec, start_fresh_conversation
+from openhands_cli.setup import MissingAgentSpec, verify_agent_exists_or_setup_agent, setup_conversation
 from openhands_cli.user_actions import UserConfirmation
 
-@patch('openhands_cli.setup.setup_conversation')
-def test_start_fresh_conversation_success(mock_setup_conversation):
-    """Test that start_fresh_conversation creates a new conversation successfully."""
-    # Mock the conversation object
-    mock_conversation = MagicMock()
-    mock_conversation.id = UUID('12345678-1234-5678-9abc-123456789abc')
-    mock_setup_conversation.return_value = mock_conversation
+@patch('openhands_cli.setup.load_agent_specs')
+def test_verify_agent_exists_or_setup_agent_success(mock_load_agent_specs):
+    """Test that verify_agent_exists_or_setup_agent returns agent successfully."""
+    # Mock the agent object
+    mock_agent = MagicMock()
+    mock_load_agent_specs.return_value = mock_agent
 
     # Call the function
-    result = start_fresh_conversation()
+    result = verify_agent_exists_or_setup_agent()
 
     # Verify the result
-    assert result == mock_conversation
-    mock_setup_conversation.assert_called_once_with(None)
+    assert result == mock_agent
+    mock_load_agent_specs.assert_called_once_with()
 
 
 @patch('openhands_cli.setup.SettingsScreen')
-@patch('openhands_cli.setup.setup_conversation')
-def test_start_fresh_conversation_missing_agent_spec(
-    mock_setup_conversation,
+@patch('openhands_cli.setup.load_agent_specs')
+def test_verify_agent_exists_or_setup_agent_missing_agent_spec(
+    mock_load_agent_specs,
     mock_settings_screen_class
 ):
-    """Test that start_fresh_conversation handles MissingAgentSpec exception."""
+    """Test that verify_agent_exists_or_setup_agent handles MissingAgentSpec exception."""
     # Mock the SettingsScreen instance
     mock_settings_screen = MagicMock()
     mock_settings_screen_class.return_value = mock_settings_screen
 
-    # Mock setup_conversation to raise MissingAgentSpec on first call, then succeed
-    mock_conversation = MagicMock()
-    mock_conversation.id = UUID('12345678-1234-5678-9abc-123456789abc')
-    mock_setup_conversation.side_effect = [
+    # Mock load_agent_specs to raise MissingAgentSpec on first call, then succeed
+    mock_agent = MagicMock()
+    mock_load_agent_specs.side_effect = [
         MissingAgentSpec("Agent spec missing"),
-        mock_conversation
+        mock_agent
     ]
 
     # Call the function
-    result = start_fresh_conversation()
+    result = verify_agent_exists_or_setup_agent()
 
     # Verify the result
-    assert result == mock_conversation
+    assert result == mock_agent
     # Should be called twice: first fails, second succeeds
-    assert mock_setup_conversation.call_count == 2
+    assert mock_load_agent_specs.call_count == 2
     # Settings screen should be called once with first_time=True (new behavior)
     mock_settings_screen.configure_settings.assert_called_once_with(first_time=True)
 
@@ -59,11 +57,11 @@ def test_start_fresh_conversation_missing_agent_spec(
 @patch('openhands_cli.agent_chat.exit_session_confirmation')
 @patch('openhands_cli.agent_chat.get_session_prompter')
 @patch('openhands_cli.agent_chat.setup_conversation')
-@patch('openhands_cli.agent_chat.start_fresh_conversation')
+@patch('openhands_cli.agent_chat.verify_agent_exists_or_setup_agent')
 @patch('openhands_cli.agent_chat.ConversationRunner')
 def test_new_command_resets_confirmation_mode(
     mock_runner_cls,
-    mock_start_fresh_conversation,
+    mock_verify_agent,
     mock_setup_conversation,
     mock_get_session_prompter,
     mock_exit_confirm,
@@ -71,15 +69,17 @@ def test_new_command_resets_confirmation_mode(
     # Auto-accept the exit prompt to avoid interactive UI and EOFError
     mock_exit_confirm.return_value = UserConfirmation.ACCEPT
 
-    conv1 = MagicMock(); conv1.id = UUID('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa')
-    conv2 = MagicMock(); conv2.id = UUID('bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb')
-    mock_start_fresh_conversation.return_value = conv1
-    mock_setup_conversation.side_effect = [conv2]
+    # Mock agent verification to succeed
+    mock_agent = MagicMock()
+    mock_verify_agent.return_value = mock_agent
 
-    # Distinct runner instances for each conversation
+    # Mock conversation - only one is created when /new is called
+    conv1 = MagicMock(); conv1.id = UUID('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa')
+    mock_setup_conversation.return_value = conv1
+
+    # One runner instance for the conversation
     runner1 = MagicMock(); runner1.is_confirmation_mode_active = True
-    runner2 = MagicMock(); runner2.is_confirmation_mode_active = False
-    mock_runner_cls.side_effect = [runner1, runner2]
+    mock_runner_cls.return_value = runner1
 
     # Real session fed by a pipe (no interactive confirmation now)
     from openhands_cli.user_actions.utils import get_session_prompter as real_get_session_prompter
@@ -89,13 +89,12 @@ def test_new_command_resets_confirmation_mode(
         mock_get_session_prompter.return_value = session
 
         from openhands_cli.agent_chat import run_cli_entry
-        # Trigger /new, then /status, then /exit (exit will be auto-accepted)
+        # Trigger /new, then /exit (exit will be auto-accepted)
         for ch in "/new\r/exit\r":
             pipe.send_text(ch)
 
         run_cli_entry(None)
 
-    # Assert we switched to a new runner for conv2
-    assert mock_runner_cls.call_count == 2
+    # Assert we created one runner for the conversation when /new was called
+    assert mock_runner_cls.call_count == 1
     assert mock_runner_cls.call_args_list[0].args[0] is conv1
-    assert mock_runner_cls.call_args_list[1].args[0] is conv2

openhands-cli/tests/commands/test_resume_command.py

@@ -0,0 +1,147 @@
+"""Tests for the /resume command functionality."""
+
+from unittest.mock import MagicMock, patch
+from uuid import UUID
+import pytest
+from prompt_toolkit.input.defaults import create_pipe_input
+from prompt_toolkit.output.defaults import DummyOutput
+
+from openhands.sdk.conversation.state import AgentExecutionStatus
+from openhands_cli.user_actions import UserConfirmation
+
+
+# ---------- Fixtures & helpers ----------
+
+@pytest.fixture
+def mock_agent():
+    """Mock agent for verification."""
+    return MagicMock()
+
+
+@pytest.fixture
+def mock_conversation():
+    """Mock conversation with default settings."""
+    conv = MagicMock()
+    conv.id = UUID('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa')
+    return conv
+
+
+@pytest.fixture
+def mock_runner():
+    """Mock conversation runner."""
+    return MagicMock()
+
+
+def run_resume_command_test(commands, agent_status=None, expect_runner_created=True):
+    """Helper function to run resume command tests with common setup."""
+    with patch('openhands_cli.agent_chat.exit_session_confirmation') as mock_exit_confirm, \
+         patch('openhands_cli.agent_chat.get_session_prompter') as mock_get_session_prompter, \
+         patch('openhands_cli.agent_chat.setup_conversation') as mock_setup_conversation, \
+         patch('openhands_cli.agent_chat.verify_agent_exists_or_setup_agent') as mock_verify_agent, \
+         patch('openhands_cli.agent_chat.ConversationRunner') as mock_runner_cls:
+        
+        # Auto-accept the exit prompt to avoid interactive UI
+        mock_exit_confirm.return_value = UserConfirmation.ACCEPT
+        
+        # Mock agent verification to succeed
+        mock_agent = MagicMock()
+        mock_verify_agent.return_value = mock_agent
+        
+        # Mock conversation setup
+        conv = MagicMock()
+        conv.id = UUID('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa')
+        if agent_status:
+            conv.state.agent_status = agent_status
+        mock_setup_conversation.return_value = conv
+        
+        # Mock runner
+        runner = MagicMock()
+        runner.conversation = conv
+        mock_runner_cls.return_value = runner
+        
+        # Real session fed by a pipe
+        from openhands_cli.user_actions.utils import get_session_prompter as real_get_session_prompter
+        with create_pipe_input() as pipe:
+            output = DummyOutput()
+            session = real_get_session_prompter(input=pipe, output=output)
+            mock_get_session_prompter.return_value = session
+            
+            from openhands_cli.agent_chat import run_cli_entry
+            
+            # Send commands
+            for ch in commands:
+                pipe.send_text(ch)
+            
+            # Capture printed output
+            with patch('openhands_cli.agent_chat.print_formatted_text') as mock_print:
+                run_cli_entry(None)
+            
+            return mock_runner_cls, runner, mock_print
+
+
+# ---------- Warning tests (parametrized) ----------
+
+@pytest.mark.parametrize(
+    "commands,expected_warning,expect_runner_created",
+    [
+        # No active conversation - /resume immediately
+        ("/resume\r/exit\r", "No active conversation running", False),
+        # Conversation exists but not in paused state - send message first, then /resume
+        ("hello\r/resume\r/exit\r", "No paused conversation to resume", True),
+    ],
+)
+def test_resume_command_warnings(commands, expected_warning, expect_runner_created):
+    """Test /resume command shows appropriate warnings."""
+    # Set agent status to FINISHED for the "conversation exists but not paused" test
+    agent_status = AgentExecutionStatus.FINISHED if expect_runner_created else None
+    
+    mock_runner_cls, runner, mock_print = run_resume_command_test(
+        commands, agent_status=agent_status, expect_runner_created=expect_runner_created
+    )
+    
+    # Verify warning message was printed
+    warning_calls = [call for call in mock_print.call_args_list 
+                    if expected_warning in str(call)]
+    assert len(warning_calls) > 0, f"Expected warning about {expected_warning}"
+    
+    # Verify runner creation expectation
+    if expect_runner_created:
+        assert mock_runner_cls.call_count == 1
+        runner.process_message.assert_called()
+    else:
+        assert mock_runner_cls.call_count == 0
+
+
+# ---------- Successful resume tests (parametrized) ----------
+
+@pytest.mark.parametrize(
+    "agent_status",
+    [
+        AgentExecutionStatus.PAUSED,
+        AgentExecutionStatus.WAITING_FOR_CONFIRMATION,
+    ],
+)
+def test_resume_command_successful_resume(agent_status):
+    """Test /resume command successfully resumes paused/waiting conversations."""
+    commands = "hello\r/resume\r/exit\r"
+    
+    mock_runner_cls, runner, mock_print = run_resume_command_test(
+        commands, agent_status=agent_status, expect_runner_created=True
+    )
+    
+    # Verify runner was created and process_message was called
+    assert mock_runner_cls.call_count == 1
+    
+    # Verify process_message was called twice: once with the initial message, once with None for resume
+    assert runner.process_message.call_count == 2
+    
+    # Check the calls to process_message
+    calls = runner.process_message.call_args_list
+    
+    # First call should have a message (the "hello" message)
+    first_call_args = calls[0][0]
+    assert first_call_args[0] is not None, "First call should have a message"
+    
+    # Second call should have None (the /resume command)
+    second_call_args = calls[1][0]
+    assert second_call_args[0] is None, "Second call should have None message for resume"

openhands-cli/tests/settings/test_default_agent_security_analyzer.py

@@ -0,0 +1,104 @@
+"""Test that first-time settings screen usage creates a default agent with security analyzer."""
+
+from unittest.mock import patch
+import pytest
+from openhands_cli.tui.settings.settings_screen import SettingsScreen
+from openhands_cli.user_actions.settings_action import SettingsType
+from openhands.sdk import LLM
+from pydantic import SecretStr
+
+
+def test_first_time_settings_creates_default_agent_with_security_analyzer():
+    """Test that using the settings screen for the first time creates a default agent with a non-None security analyzer."""
+    
+    # Create a settings screen instance (no conversation initially)
+    screen = SettingsScreen(conversation=None)
+    
+    # Mock all the user interaction steps to simulate first-time setup
+    with (
+        patch(
+            'openhands_cli.tui.settings.settings_screen.settings_type_confirmation',
+            return_value=SettingsType.BASIC,
+        ),
+        patch(
+            'openhands_cli.tui.settings.settings_screen.choose_llm_provider',
+            return_value='openai',
+        ),
+        patch(
+            'openhands_cli.tui.settings.settings_screen.choose_llm_model',
+            return_value='gpt-4o-mini',
+        ),
+        patch(
+            'openhands_cli.tui.settings.settings_screen.prompt_api_key',
+            return_value='sk-test-key-123',
+        ),
+        patch(
+            'openhands_cli.tui.settings.settings_screen.save_settings_confirmation',
+            return_value=True,
+        ),
+    ):
+        # Run the settings configuration workflow
+        screen.configure_settings(first_time=True)
+    
+    # Load the saved agent from the store
+    saved_agent = screen.agent_store.load()
+    
+    # Verify that an agent was created and saved
+    assert saved_agent is not None, "Agent should be created and saved after first-time settings configuration"
+    
+    # Verify that the agent has the expected LLM configuration
+    assert saved_agent.llm.model == 'openai/gpt-4o-mini', f"Expected model 'openai/gpt-4o-mini', got '{saved_agent.llm.model}'"
+    assert saved_agent.llm.api_key.get_secret_value() == 'sk-test-key-123', "API key should match the provided value"
+    
+    # Verify that the agent has a security analyzer and it's not None
+    assert hasattr(saved_agent, 'security_analyzer'), "Agent should have a security_analyzer attribute"
+    assert saved_agent.security_analyzer is not None, "Security analyzer should not be None"
+    
+    # Verify the security analyzer has the expected type/kind
+    assert hasattr(saved_agent.security_analyzer, 'kind'), "Security analyzer should have a 'kind' attribute"
+    assert saved_agent.security_analyzer.kind == 'LLMSecurityAnalyzer', f"Expected security analyzer kind 'LLMSecurityAnalyzer', got '{saved_agent.security_analyzer.kind}'"
+
+
+def test_first_time_settings_with_advanced_configuration():
+    """Test that advanced settings also create a default agent with security analyzer."""
+    
+    screen = SettingsScreen(conversation=None)
+    
+    with (
+        patch(
+            'openhands_cli.tui.settings.settings_screen.settings_type_confirmation',
+            return_value=SettingsType.ADVANCED,
+        ),
+        patch(
+            'openhands_cli.tui.settings.settings_screen.prompt_custom_model',
+            return_value='anthropic/claude-3-5-sonnet',
+        ),
+        patch(
+            'openhands_cli.tui.settings.settings_screen.prompt_base_url',
+            return_value='https://api.anthropic.com',
+        ),
+        patch(
+            'openhands_cli.tui.settings.settings_screen.prompt_api_key',
+            return_value='sk-ant-test-key',
+        ),
+        patch(
+            'openhands_cli.tui.settings.settings_screen.choose_memory_condensation',
+            return_value=True,
+        ),
+        patch(
+            'openhands_cli.tui.settings.settings_screen.save_settings_confirmation',
+            return_value=True,
+        ),
+    ):
+        screen.configure_settings(first_time=True)
+    
+    saved_agent = screen.agent_store.load()
+    
+    # Verify agent creation and security analyzer
+    assert saved_agent is not None, "Agent should be created with advanced settings"
+    assert saved_agent.security_analyzer is not None, "Security analyzer should not be None in advanced settings"
+    assert saved_agent.security_analyzer.kind == 'LLMSecurityAnalyzer', "Security analyzer should be LLMSecurityAnalyzer"
+    
+    # Verify advanced settings were applied
+    assert saved_agent.llm.model == 'anthropic/claude-3-5-sonnet', "Custom model should be set"
+    assert saved_agent.llm.base_url == 'https://api.anthropic.com', "Base URL should be set"

openhands-cli/tests/settings/test_settings_workflow.py

@@ -6,10 +6,10 @@ import pytest
 from openhands_cli.tui.settings.settings_screen import SettingsScreen
 from openhands_cli.tui.settings.store import AgentStore
 from openhands_cli.user_actions.settings_action import SettingsType
+from openhands_cli.utils import get_default_cli_agent
 from pydantic import SecretStr
 
 from openhands.sdk import LLM, Conversation, LocalFileStore
-from openhands.tools.preset.default import get_default_agent
 
 
 def read_json(path: Path) -> dict:
@@ -18,7 +18,7 @@ def read_json(path: Path) -> dict:
 
 
 def make_screen_with_conversation(model='openai/gpt-4o-mini', api_key='sk-xyz'):
-    llm = LLM(model=model, api_key=SecretStr(api_key), service_id='test-service')
+    llm = LLM(model=model, api_key=SecretStr(api_key), usage_id='test-service')
     # Conversation(agent) signature may vary across versions; adapt if needed:
     from openhands.sdk.agent import Agent
 
@@ -30,8 +30,8 @@ def make_screen_with_conversation(model='openai/gpt-4o-mini', api_key='sk-xyz'):
 def seed_file(path: Path, model: str = 'openai/gpt-4o-mini', api_key: str = 'sk-old'):
     store = AgentStore()
     store.file_store = LocalFileStore(root=str(path))
-    agent = get_default_agent(
-        llm=LLM(model=model, api_key=SecretStr(api_key), service_id='test-service')
+    agent = get_default_cli_agent(
+        llm=LLM(model=model, api_key=SecretStr(api_key), usage_id='test-service')
     )
     store.save(agent)
 

openhands-cli/tests/test_confirmation_mode.py

@@ -4,6 +4,7 @@ Tests for confirmation mode functionality in OpenHands CLI.
 """
 
 import os
+import uuid
 from concurrent.futures import ThreadPoolExecutor
 from typing import Any
 from unittest.mock import ANY, MagicMock, patch
@@ -60,7 +61,7 @@ class TestConfirmationMode:
                 mock_conversation_instance = MagicMock()
                 mock_conversation_class.return_value = mock_conversation_instance
 
-                result = setup_conversation()
+                result = setup_conversation(mock_conversation_id)
 
                 # Verify conversation was created and returned
                 assert result == mock_conversation_instance
@@ -87,7 +88,7 @@ class TestConfirmationMode:
 
             # Should raise MissingAgentSpec
             with pytest.raises(MissingAgentSpec) as exc_info:
-                setup_conversation()
+                setup_conversation(uuid.uuid4())
 
             assert 'Agent specification not found' in str(exc_info.value)
             mock_agent_store_class.assert_called_once()

openhands-cli/tests/test_conversation_runner.py

@@ -6,13 +6,13 @@ from openhands_cli.runner import ConversationRunner
 from openhands_cli.user_actions.types import UserConfirmation
 from pydantic import ConfigDict, SecretStr, model_validator
 
-from openhands.sdk import Conversation, ConversationCallbackType
+from openhands.sdk import Conversation, ConversationCallbackType, LocalConversation
 from openhands.sdk.agent.base import AgentBase
 from openhands.sdk.conversation import ConversationState
 from openhands.sdk.conversation.state import AgentExecutionStatus
 from openhands.sdk.llm import LLM
 from openhands.sdk.security.confirmation_policy import AlwaysConfirm, NeverConfirm
-
+from unittest.mock import MagicMock
 
 class FakeLLM(LLM):
     @model_validator(mode='after')
@@ -41,16 +41,16 @@ class FakeAgent(AgentBase):
         pass
 
     def step(
-        self, state: ConversationState, on_event: ConversationCallbackType
+        self, conversation: LocalConversation, on_event: ConversationCallbackType
     ) -> None:
         self.step_count += 1
         if self.step_count == self.finish_on_step:
-            state.agent_status = AgentExecutionStatus.FINISHED
+            conversation.state.agent_status = AgentExecutionStatus.FINISHED
 
 
 @pytest.fixture()
 def agent() -> FakeAgent:
-    llm = LLM(**default_config(), service_id='test-service')
+    llm = LLM(**default_config(), usage_id='test-service')
     return FakeAgent(llm=llm, tools=[])
 
 
@@ -102,15 +102,15 @@ class TestConversationRunner:
         """
         if final_status == AgentExecutionStatus.FINISHED:
             agent.finish_on_step = 1
-        
+
         # Add a mock security analyzer to enable confirmation mode
-        from unittest.mock import MagicMock
         agent.security_analyzer = MagicMock()
-        
+
         convo = Conversation(agent)
         convo.state.agent_status = AgentExecutionStatus.WAITING_FOR_CONFIRMATION
         cr = ConversationRunner(convo)
         cr.set_confirmation_policy(AlwaysConfirm())
+
         with patch.object(
             cr, '_handle_confirmation_request', return_value=confirmation
         ) as mock_confirmation_request:

openhands-cli/tests/test_directory_separation.py

@@ -37,7 +37,7 @@ class TestToolFix:
         """Test that entire tools list is replaced with default tools when loading agent."""
         # Create a mock agent with different tools and working directories
         mock_agent = Agent(
-            llm=LLM(model='test/model', api_key='test-key', service_id='test-service'),
+            llm=LLM(model='test/model', api_key='test-key', usage_id='test-service'),
             tools=[
                 Tool(name='BashTool'),
                 Tool(name='FileEditorTool'),

openhands-cli/tests/test_gui_launcher.py

@@ -182,7 +182,7 @@ class TestLaunchGuiServer:
             # Check pull command
             pull_call = mock_run.call_args_list[0]
             pull_cmd = pull_call[0][0]
-            assert pull_cmd[0:3] == ['docker', 'pull', 'docker.all-hands.dev/openhands/runtime:latest-nikolaik']
+            assert pull_cmd[0:3] == ['docker', 'pull', 'docker.openhands.dev/openhands/runtime:latest-nikolaik']
 
             # Check run command
             run_call = mock_run.call_args_list[1]

openhands-cli/tests/test_mcp_config_validation.py

@@ -26,7 +26,7 @@ def _create_agent(mcp_config=None) -> Agent:
     if mcp_config is None:
         mcp_config = {}
     return Agent(
-        llm=LLM(model='test-model', api_key='test-key', service_id='test-service'),
+        llm=LLM(model='test-model', api_key='test-key', usage_id='test-service'),
         tools=[],
         mcp_config=mcp_config,
     )

openhands-cli/uv.lock

@@ -1828,7 +1828,7 @@ wheels = [
 
 [[package]]
 name = "openhands"
-version = "1.0.1"
+version = "1.0.3"
 source = { editable = "." }
 dependencies = [
     { name = "openhands-sdk" },
@@ -1855,8 +1855,8 @@ dev = [
 
 [package.metadata]
 requires-dist = [
-    { name = "openhands-sdk", specifier = "==1.0.0a3" },
-    { name = "openhands-tools", specifier = "==1.0.0a3" },
+    { name = "openhands-sdk", specifier = "==1.0.0a5" },
+    { name = "openhands-tools", specifier = "==1.0.0a5" },
     { name = "prompt-toolkit", specifier = ">=3" },
     { name = "typer", specifier = ">=0.17.4" },
 ]
@@ -1879,7 +1879,7 @@ dev = [
 
 [[package]]
 name = "openhands-sdk"
-version = "1.0.0a3"
+version = "1.0.0a5"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "fastmcp" },
@@ -1891,14 +1891,14 @@ dependencies = [
     { name = "tenacity" },
     { name = "websockets" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/7e/82/33b3e3560e259803b773eee9cb377fce63b56c4252f3036126e225171926/openhands_sdk-1.0.0a3.tar.gz", hash = "sha256:c2cf6ab2ac105d257a31fde0e502a81faa969c7e64e0b2364d0634d2ce8e93b4", size = 144940, upload-time = "2025-10-20T15:38:39.647Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1a/90/d40f6716641a95a61d2042f00855e0eadc0b2558167078324576cc5a3c22/openhands_sdk-1.0.0a5.tar.gz", hash = "sha256:8888d6892d58cf9b11a71fa80086156c0b6c9a0b50df6839c0a9cafffba2338c", size = 152810, upload-time = "2025-10-29T16:19:52.086Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/de/ab/4464d2470ef1e02334f9ade094dfefa2cfc5bb761b201663a3e4121e1892/openhands_sdk-1.0.0a3-py3-none-any.whl", hash = "sha256:c8ab45160b67e7de391211ae5607ccfdf44e39781f74d115a2a22df35a2f4311", size = 191937, upload-time = "2025-10-20T15:38:38.668Z" },
+    { url = "https://files.pythonhosted.org/packages/00/6b/d3aa28019163f22f4b589ad818b83e3bea23d0a50b0c51ecc070ffdec139/openhands_sdk-1.0.0a5-py3-none-any.whl", hash = "sha256:db20272b04cf03627f9f7d1e87992078ac4ce15d188955a2962aa9e754d0af03", size = 204063, upload-time = "2025-10-29T16:19:50.684Z" },
 ]
 
 [[package]]
 name = "openhands-tools"
-version = "1.0.0a3"
+version = "1.0.0a5"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "bashlex" },
@@ -1910,9 +1910,9 @@ dependencies = [
     { name = "openhands-sdk" },
     { name = "pydantic" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/d6/93/53cf1a5ae97e0c23d7e024db5bbb1ba1da9855c6352cc91d6b65fc6f5e13/openhands_tools-1.0.0a3.tar.gz", hash = "sha256:2a15fff3749ee5856906ffce999fec49c8305e7f9911f05e01dbcf4ea772e385", size = 59103, upload-time = "2025-10-20T15:38:43.705Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/0c/8d/d62bc5e6c986676363692743688f10b6a922fd24dd525e5c6e87bd6fc08e/openhands_tools-1.0.0a5.tar.gz", hash = "sha256:6c67454e612596e95c5151267659ddd3b633a5d4a1b70b348f7f913c62146562", size = 63012, upload-time = "2025-10-29T16:19:53.783Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f8/aa/251ce4ecd560cad295e1c81def9efadfd1009cec3b7e79bd41357c6a0670/openhands_tools-1.0.0a3-py3-none-any.whl", hash = "sha256:f4c81df682c2a1a1c0bfa450bfe25ba9de5a6a3b56d6bab90f7541bf149bb3ed", size = 78814, upload-time = "2025-10-20T15:38:42.795Z" },
+    { url = "https://files.pythonhosted.org/packages/07/9d/4da48258f0af73d017b61ed3f12786fae4caccc7e7cd97d77ef2bb25f00c/openhands_tools-1.0.0a5-py3-none-any.whl", hash = "sha256:74c27e23e6adc9a0bad00e32448bd4872019ce0786474e8de2fbf2d7c0887e8e", size = 84724, upload-time = "2025-10-29T16:19:52.84Z" },
 ]
 
 [[package]]

openhands/app_server/app_conversation/app_conversation_models.py

@@ -1,11 +1,11 @@
 from datetime import datetime
 from enum import Enum
-from uuid import UUID, uuid4
+from uuid import uuid4
 
 from pydantic import BaseModel, Field
 
 from openhands.agent_server.models import SendMessageRequest
-from openhands.agent_server.utils import utc_now
+from openhands.agent_server.utils import OpenHandsUUID, utc_now
 from openhands.app_server.event_callback.event_callback_models import (
     EventCallbackProcessor,
 )
@@ -19,7 +19,7 @@ from openhands.storage.data_models.conversation_metadata import ConversationTrig
 class AppConversationInfo(BaseModel):
     """Conversation info which does not contain status."""
 
-    id: UUID = Field(default_factory=uuid4)
+    id: OpenHandsUUID = Field(default_factory=uuid4)
 
     created_by_user_id: str | None
     sandbox_id: str
@@ -125,11 +125,11 @@ class AppConversationStartTask(BaseModel):
     we kick off a background task for it. Once the conversation is started, the app_conversation_id
     is populated."""
 
-    id: UUID = Field(default_factory=uuid4)
+    id: OpenHandsUUID = Field(default_factory=uuid4)
     created_by_user_id: str | None
     status: AppConversationStartTaskStatus = AppConversationStartTaskStatus.WORKING
     detail: str | None = None
-    app_conversation_id: UUID | None = Field(
+    app_conversation_id: OpenHandsUUID | None = Field(
         default=None, description='The id of the app_conversation, if READY'
     )
     sandbox_id: str | None = Field(