codemode: fix Start() fail-fast and use tools.As for wrapper unwrapping

Start() returned on the first error, so one broken toolset (e.g. an
unreachable MCP server) prevented all remaining toolsets from starting.
Collect all errors with errors.Join, matching the existing Stop()
behavior.

Both Start() and Stop() used a direct type assertion to find Startable,
which cannot see through wrapper chains (e.g. StartableToolSet). Switch
to tools.As so the capability is discovered at any depth.

Extract the now-identical loops into a shared forEachStartable helper to
remove the duplication.

Assisted-By: docker-agent

Author: dgageot

pkg/tools/codemode/codemode.go

@@ -103,27 +103,23 @@ func (c *codeModeTool) Tools(ctx context.Context) ([]tools.Tool, error) {
 }
 
 func (c *codeModeTool) Start(ctx context.Context) error {
-	for _, t := range c.toolsets {
-		if startable, ok := t.(tools.Startable); ok {
-			if err := startable.Start(ctx); err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
+	return c.forEachStartable(func(s tools.Startable) error { return s.Start(ctx) })
 }
 
 func (c *codeModeTool) Stop(ctx context.Context) error {
-	var errs []error
+	return c.forEachStartable(func(s tools.Startable) error { return s.Stop(ctx) })
+}
 
+// forEachStartable applies fn to every toolset that implements Startable,
+// collecting all errors so that one broken toolset doesn't block the others.
+func (c *codeModeTool) forEachStartable(fn func(tools.Startable) error) error {
+	var errs []error
 	for _, t := range c.toolsets {
-		if startable, ok := t.(tools.Startable); ok {
-			if err := startable.Stop(ctx); err != nil {
+		if s, ok := tools.As[tools.Startable](t); ok {
+			if err := fn(s); err != nil {
 				errs = append(errs, err)
 			}
 		}
 	}
-
 	return errors.Join(errs...)
 }

pkg/tools/codemode/codemode_test.go

@@ -187,10 +187,42 @@ func TestCodeModeTool_CallEcho(t *testing.T) {
 	require.Empty(t, scriptResult.StdOut)
 }
 
+// TestCodeModeTool_StartContinuesOnError verifies that a failing Start on one
+// toolset does not prevent the remaining toolsets from being started.
+func TestCodeModeTool_StartContinuesOnError(t *testing.T) {
+	failing := &testToolSet{startErr: assert.AnError}
+	healthy := &testToolSet{}
+
+	tool := Wrap(failing, healthy).(tools.Startable)
+
+	err := tool.Start(t.Context())
+	require.ErrorIs(t, err, assert.AnError)
+	assert.Equal(t, 1, failing.start, "failing toolset should have been started")
+	assert.Equal(t, 1, healthy.start, "healthy toolset should still be started")
+}
+
+// TestCodeModeTool_StartStopWrappedToolSet verifies that Start/Stop find
+// Startable through a StartableToolSet wrapper via tools.As.
+func TestCodeModeTool_StartStopWrappedToolSet(t *testing.T) {
+	inner := &testToolSet{}
+	wrapped := tools.NewStartable(inner)
+
+	tool := Wrap(wrapped).(tools.Startable)
+
+	err := tool.Start(t.Context())
+	require.NoError(t, err)
+	assert.Equal(t, 1, inner.start)
+
+	err = tool.Stop(t.Context())
+	require.NoError(t, err)
+	assert.Equal(t, 1, inner.stop)
+}
+
 type testToolSet struct {
-	tools []tools.Tool
-	start int
-	stop  int
+	tools    []tools.Tool
+	start    int
+	stop     int
+	startErr error
 }
 
 // Verify interface compliance
@@ -205,7 +237,7 @@ func (t *testToolSet) Tools(context.Context) ([]tools.Tool, error) {
 
 func (t *testToolSet) Start(context.Context) error {
 	t.start++
-	return nil
+	return t.startErr
 }
 
 func (t *testToolSet) Stop(context.Context) error {