langfun 0.1.2.dev202510290805__tar.gz → 0.1.2.dev202510310805__tar.gz

{langfun-0.1.2.dev202510290805 → langfun-0.1.2.dev202510310805}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langfun
-Version: 0.1.2.dev202510290805
+Version: 0.1.2.dev202510310805
 Summary: Langfun: Language as Functions.
 Home-page: https://github.com/google/langfun
 Author: Langfun Authors

{langfun-0.1.2.dev202510290805 → langfun-0.1.2.dev202510310805}/langfun/core/agentic/action.py

@@ -538,6 +538,18 @@ class ExecutionTrace(pg.Object, pg.views.html.HtmlTreeView.Extension):
           remove_class=['not-started'],
       )
 
+  def remove(self, item: TracedItem) -> None:
+    """Removes an item from the sequence."""
+    index = self.items.index(item)
+    if index == -1:
+      raise ValueError(f'Item not found in execution trace: {item!r}')
+
+    with pg.notify_on_change(False):
+      self.items.pop(index)
+
+    if self._tab_control is not None:
+      self._tab_control.remove(index)
+
   def extend(self, items: Iterable[TracedItem]) -> None:
     """Extends the sequence with a list of items."""
     for item in items:
@@ -1648,13 +1660,20 @@ class Session(pg.Object, pg.views.html.HtmlTreeView.Extension):
   @contextlib.contextmanager
   def track_queries(
       self,
-      phase: str | None = None
+      phase: str | None = None,
+      track_if: Callable[
+          [lf_structured.QueryInvocation],
+          bool
+      ] | None = None,
   ) -> Iterator[list[lf_structured.QueryInvocation]]:
     """Tracks `lf.query` made within the context.
 
     Args:
       phase: The name of a new phase to track the queries in. If not provided,
         the queries will be tracked in the parent phase.
+      track_if: A function that takes a `lf_structured.QueryInvocation` and
+        returns True if the query should be included in the result. If None,
+        all queries (including failed queries) will be included.
 
     Yields:
       A list of `lf.QueryInvocation` objects, each for a single `lf.query`
@@ -1673,6 +1692,11 @@ class Session(pg.Object, pg.views.html.HtmlTreeView.Extension):
       self.event_handler.on_query_start(self, self._current_action, invocation)
 
     def _query_end(invocation: lf_structured.QueryInvocation):
+      if track_if is not None and not track_if(invocation):
+        self._current_execution.remove(invocation)
+      # Even if the query is not included in the execution trace, we still
+      # count the usage summary to the current execution and trigger the
+      # event handler to log the query.
       self._current_execution.merge_usage_summary(invocation.usage_summary)
       self.event_handler.on_query_end(self, self._current_action, invocation)
 
@@ -1705,8 +1729,9 @@ class Session(pg.Object, pg.views.html.HtmlTreeView.Extension):
       *,
       lm: lf.LanguageModel,
       examples: list[lf_structured.MappingExample] | None = None,
+      track_if: Callable[[lf_structured.QueryInvocation], bool] | None = None,
       **kwargs
-      ) -> Any:
+  ) -> Any:
     """Calls `lf.query` and associates it with the current invocation.
 
     The following code are equivalent:
@@ -1731,12 +1756,15 @@ class Session(pg.Object, pg.views.html.HtmlTreeView.Extension):
       default: The default value to return if the query fails.
       lm: The language model to use for the query.
       examples: The examples to use for the query.
+      track_if: A function that takes a `lf_structured.QueryInvocation`
+        and returns True if the query should be tracked.
+        If None, all queries (including failed queries) will be tracked.
       **kwargs: Additional keyword arguments to pass to `lf.query`.
 
     Returns:
       The result of the query.
     """
-    with self.track_queries():
+    with self.track_queries(track_if=track_if):
       return lf_structured.query(
           prompt,
           schema=schema,

{langfun-0.1.2.dev202510290805 → langfun-0.1.2.dev202510310805}/langfun/core/agentic/action_test.py

@@ -530,6 +530,31 @@ class SessionTest(unittest.TestCase):
     self.assertIn('agent@', session.id)
     self.assertIsInstance(session.as_message(), lf.AIMessage)
 
+  def test_query_with_track_if(self):
+    lm = fake.StaticResponse('lm response')
+    session = action_lib.Session()
+
+    # Render session to trigger javascript updates to the HTML when
+    # operating on the session.
+    _ = session.to_html()
+    with session:
+      # This query will succeed.
+      session.query(
+          'prompt1',
+          schema=None,
+          lm=lm,
+          track_if=lambda q: not q.has_error,
+          default=None)
+      # This query will fail during parsing.
+      session.query(
+          'prompt2',
+          schema=int,
+          lm=lm,
+          track_if=lambda q: not q.has_error,
+          default=None)
+    self.assertEqual(len(session.root.queries), 1)
+    self.assertIsNone(session.root.queries[0].error)
+
 
 if __name__ == '__main__':
   unittest.main()

{langfun-0.1.2.dev202510290805 → langfun-0.1.2.dev202510310805}/langfun/core/llms/gemini.py

@@ -830,9 +830,9 @@ class Gemini(rest.REST):
     )
 
   def _error(self, status_code: int, content: str) -> lf.LMError:
-    if (
-        status_code == 400
-        and b'exceeds the maximum number of tokens' in content
+    if status_code == 400 and (
+        b'exceeds the maximum number of tokens' in content
+        or b'Reduce the input token count and try again.' in content
     ):
       return lf.ContextLimitError(f'{status_code}: {content}')
     return super()._error(status_code, content)

{langfun-0.1.2.dev202510290805 → langfun-0.1.2.dev202510310805}/langfun/env/__init__.py

@@ -24,6 +24,10 @@ from langfun.env.interface import Environment
 from langfun.env.interface import Sandbox
 from langfun.env.interface import Feature
 
+# Decorators for sandbox/feature methods.
+from langfun.env.interface import treat_as_sandbox_state_error
+from langfun.env.interface import log_sandbox_activity
+
 from langfun.env.base_environment import BaseEnvironment
 from langfun.env.base_sandbox import BaseSandbox
 from langfun.env.base_feature import BaseFeature

{langfun-0.1.2.dev202510290805 → langfun-0.1.2.dev202510310805}/langfun/env/base_sandbox.py

@@ -26,7 +26,7 @@ import contextlib
 import functools
 import threading
 import time
-from typing import Annotated, Any, Callable, Iterator, Sequence, Type
+from typing import Annotated, Any, Iterator
 
 from langfun.env import interface
 from langfun.env.event_handlers import base as event_handler_base
@@ -100,10 +100,9 @@ class BaseSandbox(interface.Sandbox):
     self._status = status
     self._status_start_time = time.time()
 
-  def report_maybe_state_error(self, e: BaseException | None) -> None:
+  def report_state_error(self, e: interface.SandboxStateError) -> None:
     """Reports sandbox state errors."""
-    if (isinstance(e, interface.SandboxStateError)
-        and e not in self._state_errors):
+    if e not in self._state_errors:
       self._state_errors.append(e)
 
   def _setup_features(self) -> None:
@@ -141,7 +140,8 @@ class BaseSandbox(interface.Sandbox):
         try:
           feature.teardown()
         except BaseException as e:  # pylint: disable=broad-except
-          self.report_maybe_state_error(e)
+          if isinstance(e, interface.SandboxStateError):
+            self.report_state_error(e)
           errors[feature.name] = e
     if errors:
       return interface.FeatureTeardownError(sandbox=self, errors=errors)
@@ -175,7 +175,8 @@ class BaseSandbox(interface.Sandbox):
         try:
           feature.teardown_session()
         except BaseException as e:  # pylint: disable=broad-except
-          self.report_maybe_state_error(e)
+          if isinstance(e, interface.SandboxStateError):
+            self.report_state_error(e)
           feature_teardown_errors[name] = e
 
     return interface.SessionTeardownError(
@@ -277,28 +278,6 @@ class BaseSandbox(interface.Sandbox):
     """Returns the features in the sandbox."""
     return self._features
 
-  def _enter_service_call(self) -> bool:
-    """Enters a service call.
-
-    Returns:
-      True if the service call is at the top of the call stack.
-    """
-    v = getattr(self._tls_state, 'service_call_depth', None)
-    if v is None:
-      v = 0
-    setattr(self._tls_state, 'service_call_depth', v + 1)
-    return v == 0
-
-  def _exit_service_call(self) -> bool:
-    """Exits a service call.
-
-    Returns:
-      True if the service call is at the top of the call stack.
-    """
-    v = getattr(self._tls_state, 'service_call_depth')
-    setattr(self._tls_state, 'service_call_depth', v - 1)
-    return v == 1
-
   #
   # Sandbox start/shutdown.
   #
@@ -369,7 +348,8 @@ class BaseSandbox(interface.Sandbox):
           '[%s]: Sandbox failed to start in %.2f seconds: %s',
           self.id, duration, e
       )
-      self.report_maybe_state_error(e)
+      if isinstance(e, interface.SandboxStateError):
+        self.report_state_error(e)
       self.on_start(duration, e)
       self.shutdown()
       raise e
@@ -442,7 +422,8 @@ class BaseSandbox(interface.Sandbox):
       shutdown_error = None
     except BaseException as e:  # pylint: disable=broad-except
       shutdown_error = e
-      self.report_maybe_state_error(e)
+      if isinstance(e, interface.SandboxStateError):
+        self.report_state_error(e)
       self._set_status(interface.Sandbox.Status.OFFLINE)
       pg.logging.error(
           '[%s]: Sandbox shutdown with error: %s',
@@ -540,7 +521,8 @@ class BaseSandbox(interface.Sandbox):
       self._set_status(self.Status.IN_SESSION)
       self.on_session_start(session_id, time.time() - self._session_start_time)
     except BaseException as e:  # pylint: disable=broad-except
-      self.report_maybe_state_error(e)
+      if isinstance(e, interface.SandboxStateError):
+        self.report_state_error(e)
       self.on_session_start(
           session_id, time.time() - self._session_start_time, e
       )
@@ -626,7 +608,8 @@ class BaseSandbox(interface.Sandbox):
                 self.id,
                 e
             )
-            self.report_maybe_state_error(e)
+            if isinstance(e, interface.SandboxStateError):
+              self.report_state_error(e)
             self.shutdown()
 
         # End session before setting up the next session.
@@ -677,6 +660,30 @@ class BaseSandbox(interface.Sandbox):
         and end_session_error.has_non_sandbox_state_error):
       raise end_session_error  # pylint: disable=raising-bad-type
 
+  @contextlib.contextmanager
+  def track_activity(
+      self,
+      name: str,
+      feature: interface.Feature | None = None,
+      **kwargs: Any
+  ) -> Iterator[None]:
+    """Tracks an activity for the sandbox."""
+    start_time = time.time()
+    error = None
+    try:
+      yield None
+    except BaseException as e:  # pylint: disable=broad-except
+      error = e
+      raise
+    finally:
+      self.on_activity(
+          name=name,
+          feature=feature,
+          duration=time.time() - start_time,
+          error=error,
+          **kwargs
+      )
+
   #
   # Housekeeping.
   #
@@ -722,7 +729,7 @@ class BaseSandbox(interface.Sandbox):
                 str(e)
             )
             self._housekeep_counter += 1
-            self.report_maybe_state_error(e)
+            self.report_state_error(e)
             self.on_housekeep(time.time() - housekeep_start, e)
             self.shutdown()
             break
@@ -744,7 +751,7 @@ class BaseSandbox(interface.Sandbox):
                 feature.name,
                 e,
             )
-            self.report_maybe_state_error(e)
+            self.report_state_error(e)
             self._housekeep_counter += 1
             self.on_housekeep(time.time() - housekeep_start, e)
             self.shutdown()
@@ -917,208 +924,3 @@ class BaseSandbox(interface.Sandbox):
       handler.on_session_end(
           self.environment, self, session_id, duration, lifetime, error
       )
-
-
-#
-# Sandbox service decorator.
-#
-
-
-def sandbox_service(
-    critical_errors: Sequence[
-        Type[BaseException] | tuple[Type[BaseException], str]
-    ] | None = None
-) -> Callable[..., Any]:
-  """Decorator for Sandbox/Feature methods exposed as sandbox services.
-
-  This decorator will catch errors and map to `SandboxStateError` if the
-  error matches any of the critical errors. Consequently, the sandbox will be
-  shutdown automatically when the error is raised.
-
-  Example:
-
-  ```
-    with env:
-      with env.sandbox() as sb:
-        try:
-          sb.test_feature.do_something_with_non_state_error()
-        except ValueError:
-          # sandbox will not be shutdown.
-          pass
-
-        try:
-          sb.test_feature.do_something_with_state_error()
-        except ValueError:
-          assert sb.state == sb.Status.OFFLINE
-  ```
-
-  If the decorated method returns a context manager, a wrapper context manager
-  will be returned, which will end the session when exiting the context.
-
-  Example:
-
-  ```
-    with env:
-      with env.test_feature.do_something_with_context_manager() as result:
-        # sandbox will be alive during the whole context manager cycle.
-  ```
-
-  For sandbox service methods, an optional `session_id` argument can be passed
-  to create a new session for the service call, even its signature does not
-  contain a `session_id` argument.
-
-  Args:
-    critical_errors: A sequence of exception types or tuples of exception type
-      and error messages (described in regular expression), when matched, treat
-      the sandbox as in a bad state, which will trigger a shutdown.
-
-  Returns:
-    The decorator function.
-  """
-  critical_errors = critical_errors or []
-
-  def decorator(func):
-    signature = pg.typing.get_signature(func)
-    if 'session_id' in signature.arg_names:
-      raise ValueError(
-          '`session_id` should not be used as argument for sandbox '
-          'service method. Please use `self.session_id` instead.'
-      )
-
-    def to_kwargs(*args, **kwargs):
-      num_non_self_args = len(signature.arg_names) - 1
-      if len(args) > num_non_self_args:
-        assert signature.varargs is not None, (signature, args)
-        kwargs[signature.varargs.name] = tuple(args[num_non_self_args:])
-        args = args[:num_non_self_args]
-      for i in range(len(args)):
-        # The first argument is `self`.
-        kwargs[signature.arg_names[i + 1]] = args[i]
-      return kwargs
-
-    @functools.wraps(func)
-    def method_wrapper(self, *args, **kwargs) -> Any:
-      """Helper function to safely execute logics in the sandbox."""
-
-      assert isinstance(self, (BaseSandbox, interface.Feature)), self
-      sandbox = self.sandbox if isinstance(self, interface.Feature) else self
-
-      # We count the service call stack depth so we could shutdown the sandbox
-      # at the top upon sandbox state error.
-      sandbox._enter_service_call()  # pylint: disable=protected-access
-
-      # When a capability is directly accessed from the environment,
-      # we create a new session for the capability call. This
-      # prevents the sandbox from being reused for other feature calls.
-      if sandbox.status == interface.Sandbox.Status.ACQUIRED:
-        new_session = True
-        new_session_id = kwargs.get('session_id')
-        if new_session_id is None:
-          new_session_id = sandbox.environment.new_session_id()
-
-        # If it's a feature method called from the environment, start a new
-        # session for the feature call.
-        sandbox.start_session(new_session_id)
-      else:
-        new_session = False
-
-      kwargs.pop('session_id', None)
-      result = None
-      error = None
-      start_time = time.time()
-
-      try:
-        # Execute the service function.
-        result = func(self, *args, **kwargs)
-
-        # If the result is a context manager, wrap it with a context manager
-        # to end the session when exiting.
-        if isinstance(result, contextlib.AbstractContextManager):
-          return _service_context_manager_wrapper(
-              service=result,
-              sandbox_or_feature=self,
-              sandbox=sandbox,
-              name=func.__name__,
-              kwargs=to_kwargs(*args, **kwargs),
-              start_time=start_time,
-              new_session=new_session
-          )
-
-        # Otherwise, return the result and end the session in the finally block.
-        return result
-      except BaseException as e:
-        error = e
-        sandbox.report_maybe_state_error(e)
-        if pg.match_error(e, critical_errors):
-          state_error = interface.SandboxStateError(
-              'Sandbox encountered an unexpected error executing '
-              f'`{func.__name__}` (args={args!r}, kwargs={kwargs!r}): {e}',
-              sandbox=self
-          )
-          sandbox.report_maybe_state_error(state_error)
-          raise state_error from e
-        raise
-      finally:
-        is_topmost_call = sandbox._exit_service_call()  # pylint: disable=protected-access
-        if not isinstance(result, contextlib.AbstractContextManager):
-          self.on_activity(
-              name=func.__name__,
-              duration=time.time() - start_time,
-              error=error,
-              **to_kwargs(*args, **kwargs),
-          )
-          if new_session:
-            assert is_topmost_call
-
-            # End the session if it's from a feature method and the result
-            # is not a context manager.
-            sandbox.end_session()
-
-        # Shutdown the sandbox if it is at the top of the service call stack and
-        # has state errors.
-        if (is_topmost_call
-            and sandbox.state_errors
-            # Sandbox service method might be called during shutting down, in
-            # that case we don't want to shutdown the sandbox again.
-            and not sandbox.is_shutting_down):
-          sandbox.shutdown()
-
-    return method_wrapper
-  return decorator
-
-
-@contextlib.contextmanager
-def _service_context_manager_wrapper(
-    service: contextlib.AbstractContextManager[Any],
-    sandbox_or_feature: BaseSandbox | interface.Feature,
-    sandbox: interface.Sandbox,
-    name: str,
-    kwargs: dict[str, Any],
-    new_session: bool,
-    start_time: float,
-) -> Iterator[Any]:
-  """Context manager wrapper for ending a sandbox session when exiting."""
-  error = None
-  sandbox._enter_service_call()  # pylint: disable=protected-access
-
-  try:
-    with service as result:
-      yield result
-  except BaseException as e:
-    error = e
-    sandbox.report_maybe_state_error(error)
-    raise
-  finally:
-    sandbox_or_feature.on_activity(
-        name=name,
-        error=error,
-        duration=time.time() - start_time,
-        **kwargs,
-    )
-    is_topmost_call = sandbox._exit_service_call()  # pylint: disable=protected-access
-
-    if new_session:
-      assert is_topmost_call
-      sandbox.end_session()
-    elif isinstance(error, interface.SandboxStateError):
-      sandbox.shutdown()

{langfun-0.1.2.dev202510290805 → langfun-0.1.2.dev202510310805}/langfun/env/base_test.py

@@ -15,7 +15,6 @@ import time
 from typing import Any
 import unittest
 
-from langfun.env import base_sandbox
 from langfun.env import interface
 from langfun.env import test_utils
 from langfun.env.event_handlers import base as event_handler_base
@@ -460,10 +459,11 @@ class EnvironmentTests(unittest.TestCase):
           simulate_setup_error=interface.SandboxStateError,
           skip_notification=True
       )
-      with env.sandbox() as sb:
-        with self.assertRaises(interface.SandboxStateError):
+      with self.assertRaises(interface.SandboxStateError):
+        with env.sandbox() as sb:
           sb.shell('bad command', raise_error=interface.SandboxStateError)
       self.assertEqual(sb.status, interface.Sandbox.Status.OFFLINE)
+      self.assertEqual(len(sb.state_errors), 1)
       sb_offline_time = time.time()
       while time.time() - sb_offline_time < 10:
         if not env.is_online:
@@ -1250,12 +1250,11 @@ class SandboxStatusTests(unittest.TestCase):
         },
     )
     with env:
-      with env.sandbox(session_id='session1') as sb:
-        with self.assertRaises(interface.SandboxStateError):
+      with self.assertRaises(interface.SandboxStateError):
+        with env.sandbox(session_id='session1') as sb:
           sb.shell('echo foo', raise_error=RuntimeError)
-        self.assertEqual(len(sb.state_errors), 1)
-        self.assertEqual(sb.status, interface.Sandbox.Status.OFFLINE)
-        sb.shell('echo bar')
+      self.assertEqual(len(sb.state_errors), 1)
+      self.assertEqual(sb.status, interface.Sandbox.Status.OFFLINE)
       self.assertEqual(
           self.event_handler.logs,
           [
@@ -1282,7 +1281,6 @@ class SandboxStatusTests(unittest.TestCase):
               '[testing-env/test_image:0:0/feature1] feature teardown',
               '[testing-env/test_image:0:0] shutting_down -> offline',
               '[testing-env/test_image:0:0] sandbox shutdown',
-              '[testing-env/test_image:0:0] shell: echo bar',
               # pylint: enable=line-too-long
           ]
       )
@@ -1306,11 +1304,6 @@ class SandboxActivityTests(unittest.TestCase):
             r'test_feature-session-[0-9a-f]{7}'
         )
 
-    with self.assertRaisesRegex(ValueError, '`session_id` should not be used'):
-      @base_sandbox.sandbox_service()
-      def foo(session_id: str):
-        del session_id
-
   def test_ping_error(self):
     env = TestingEnvironment(
         features={'test_feature': TestingFeature(housekeep_interval=0)},
@@ -1487,10 +1480,11 @@ class SandboxServiceTests(unittest.TestCase):
 
   def test_service_call_from_feature_with_error(self):
     with self.env:
-      with self.env.sandbox(session_id='session1') as sb:
-        with self.assertRaises(interface.SandboxStateError):
+      with self.assertRaises(interface.SandboxStateError):
+        with self.env.sandbox(session_id='session1') as sb:
           sb.test_feature.bad_shell_call()
-        self.assertEqual(sb.status, interface.Sandbox.Status.OFFLINE)
+      self.assertEqual(sb.status, interface.Sandbox.Status.OFFLINE)
+      self.assertEqual(len(sb.state_errors), 1)
 
     self.assertEqual(
         self.event_handler.logs,
@@ -1584,7 +1578,6 @@ class SandboxServiceTests(unittest.TestCase):
             '[testing-env/test_image:0/session1] shell: "test_feature" setup session',
             "[testing-env/test_image:0] session 'session1' started",
             '[testing-env/test_image:0/session1] shell: hello',
-            '[testing-env/test_image:0/session1/test_feature] test_feature.my_service: None',
             '[testing-env/test_image:0/session1] shell: foo',
             '[testing-env/test_image:0/session1] shell: "test_feature" teardown session',
             "[testing-env/test_image:0] session 'session1' ended",
@@ -1598,11 +1591,12 @@ class SandboxServiceTests(unittest.TestCase):
 
   def test_service_context_manager_from_feature_with_error(self):
     with self.env:
-      with self.env.sandbox(session_id='session1') as sb:
-        with self.assertRaises(interface.SandboxStateError):
+      with self.assertRaises(interface.SandboxStateError):
+        with self.env.sandbox(session_id='session1') as sb:
           with sb.test_feature.my_service() as service:
             service.do('hello', raise_error=interface.SandboxStateError)
-        self.assertEqual(sb.status, interface.Sandbox.Status.OFFLINE)
+      self.assertEqual(sb.status, interface.Sandbox.Status.OFFLINE)
+      self.assertEqual(len(sb.state_errors), 1)
     self.assertEqual(
         self.event_handler.logs,
         [
@@ -1614,7 +1608,6 @@ class SandboxServiceTests(unittest.TestCase):
             '[testing-env/test_image:0/session1] shell: "test_feature" setup session',
             "[testing-env/test_image:0] session 'session1' started",
             '[testing-env/test_image:0/session1] shell: hello with SandboxStateError',
-            '[testing-env/test_image:0/session1/test_feature] test_feature.my_service: None with SandboxStateError',
             '[testing-env/test_image:0/session1] shell: "test_feature" teardown session',
             "[testing-env/test_image:0] session 'session1' ended with SandboxStateError",
             '[testing-env/test_image:0] shell: "test_feature" teardown',
@@ -1645,7 +1638,6 @@ class SandboxServiceTests(unittest.TestCase):
             '[testing-env/test_image:0/session1] shell: "test_feature" setup session',
             "[testing-env/test_image:0] session 'session1' started",
             '[testing-env/test_image:0/session1] shell: foo',
-            '[testing-env/test_image:0/session1/test_feature] test_feature.my_service: None',
             '[testing-env/test_image:0/session1] shell: "test_feature" teardown session',
             "[testing-env/test_image:0] session 'session1' ended",
             '[testing-env/test_image:0] shell: "test_feature" teardown',
@@ -1657,7 +1649,6 @@ class SandboxServiceTests(unittest.TestCase):
             '[testing-env/test_image:1/test_feature-session-2291d8c] shell: "test_feature" setup session',
             "[testing-env/test_image:1] session 'test_feature-session-2291d8c' started",
             '[testing-env/test_image:1/test_feature-session-2291d8c] shell: bar',
-            '[testing-env/test_image:1/test_feature-session-2291d8c/test_feature] test_feature.my_service: None',
             '[testing-env/test_image:1/test_feature-session-2291d8c] shell: "test_feature" teardown session',
             "[testing-env/test_image:1] session 'test_feature-session-2291d8c' ended",
             '[testing-env/test_image:1] shell: "test_feature" teardown',
@@ -1685,7 +1676,6 @@ class SandboxServiceTests(unittest.TestCase):
             '[testing-env/test_image:0/test_feature-session-2291d8c] shell: "test_feature" setup session',
             "[testing-env/test_image:0] session 'test_feature-session-2291d8c' started",
             '[testing-env/test_image:0/test_feature-session-2291d8c] shell: hello with SandboxStateError',
-            '[testing-env/test_image:0/test_feature-session-2291d8c/test_feature] test_feature.my_service: None with SandboxStateError',
             '[testing-env/test_image:0/test_feature-session-2291d8c] shell: "test_feature" teardown session',
             "[testing-env/test_image:0] session 'test_feature-session-2291d8c' ended with SandboxStateError",
             '[testing-env/test_image:0] shell: "test_feature" teardown',