@datalayer/agent-runtimes 1.0.29 → 1.3.11

package/scripts/generate-environments-types.py

@@ -0,0 +1,404 @@
+#!/usr/bin/env python3
+# Copyright (c) 2025-2026 Datalayer, Inc.
+# Distributed under the terms of the Modified BSD License.
+
+"""
+Generate the TypeScript types of the Environment specification from its JSON Schema.
+
+The pydantic models of ``code_sandboxes.environments`` are the specification
+(PLAN_ENV.md, D-14). ``code-sandboxes`` exports them as
+``schemas/environment-v1alpha1.json``; this writes what that schema says, in
+TypeScript, to ``src/models/environments.generated.ts``, as ``core`` generates
+its orchestration and MCP types.
+
+The schema is read from the first of:
+
+- ``DATALAYER_ENVIRONMENT_SCHEMA``, the path of a copy;
+- the ``code-sandboxes`` checkout beside this one;
+- the installed ``code_sandboxes`` package, which exports the same text.
+
+The generated file carries the sha256 of the schema text it came from, so
+``--check`` fails on any change to the schema: a new pattern or bound, which
+changes no TypeScript type, as much as a new field. ``--check`` exits non-zero
+when the checked-in file is not what the schema gives.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import re
+import sys
+from pathlib import Path
+from typing import Any
+
+ROOT = Path(__file__).resolve().parents[1]
+OUTPUT = ROOT / "src/models/environments.generated.ts"
+SCHEMA_VARIABLE = "DATALAYER_ENVIRONMENT_SCHEMA"
+SIBLING_SCHEMA = ROOT.parent / "code-sandboxes/schemas/environment-v1alpha1.json"
+
+#: The licence header every source file here carries. `fix-license-header`
+#: would add one to a file without it, and `--check` would then disagree with
+#: the formatter forever.
+LICENCE = (
+    "/*\n"
+    " * Copyright (c) 2025-2026 Datalayer, Inc.\n"
+    " * Distributed under the terms of the Modified BSD License.\n"
+    " */"
+)
+HEADER = (
+    "/* Generated from the Environment JSON Schema of code-sandboxes "
+    "(schemas/environment-v1alpha1.json) by "
+    "scripts/generate-environments-types.py. Do not edit. */"
+)
+#: `src` is prettier-checked, so what is written is what prettier would write:
+#: single quotes, 80 columns, a long union broken one member per line.
+PRINT_WIDTH = 80
+INDENT = "  "
+_IDENTIFIER = re.compile(r"^[A-Za-z_$][A-Za-z0-9_$]*$")
+
+
+def read_schema() -> str:
+    """
+    Return the text of the Environment JSON Schema.
+
+    Returns
+    -------
+    str
+        The schema, exactly as ``code-sandboxes`` exports it.
+
+    Raises
+    ------
+    SystemExit
+        When no copy of the schema can be found.
+    """
+    given = os.environ.get(SCHEMA_VARIABLE)
+    if given:
+        path = Path(given)
+        if not path.is_file():
+            raise SystemExit(f"{SCHEMA_VARIABLE} names {path}, which is not a file.")
+        return path.read_text(encoding="utf-8")
+    if SIBLING_SCHEMA.is_file():
+        return SIBLING_SCHEMA.read_text(encoding="utf-8")
+    try:
+        from code_sandboxes.environments.schema import schema_text
+    except ImportError:
+        raise SystemExit(
+            f"No Environment JSON Schema: set {SCHEMA_VARIABLE}, check out "
+            "code-sandboxes beside agent-runtimes, or install code-sandboxes>=1.5.0."
+        ) from None
+    return schema_text()
+
+
+def quote(value: str) -> str:
+    """
+    Return a TypeScript string literal, quoted the way prettier quotes.
+
+    Parameters
+    ----------
+    value : str
+        The string.
+
+    Returns
+    -------
+    str
+        The literal, in single quotes.
+    """
+    escaped = value.replace("\\", "\\\\").replace("'", "\\'")
+    return f"'{escaped}'"
+
+
+def literal(value: Any) -> str:
+    """
+    Return a JSON scalar as a TypeScript literal.
+
+    Parameters
+    ----------
+    value : Any
+        A string, number, boolean or null.
+
+    Returns
+    -------
+    str
+        Its TypeScript spelling.
+    """
+    if isinstance(value, str):
+        return quote(value)
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if value is None:
+        return "null"
+    return json.dumps(value)
+
+
+def members(node: dict[str, Any]) -> list[str]:
+    """
+    Return the members of the union a schema node is, or its one type.
+
+    Parameters
+    ----------
+    node : dict[str, Any]
+        The schema node.
+
+    Returns
+    -------
+    list[str]
+        Each member spelled in TypeScript, without duplicates.
+    """
+    if "$ref" in node:
+        return [node["$ref"].rsplit("/", 1)[-1]]
+    if "const" in node:
+        return [literal(node["const"])]
+    if "enum" in node:
+        return [literal(value) for value in node["enum"]]
+    for keyword in ("anyOf", "oneOf"):
+        if keyword in node:
+            found = [member for option in node[keyword] for member in members(option)]
+            return list(dict.fromkeys(found))
+    kind = node.get("type")
+    if isinstance(kind, list):
+        found = [member for item in kind for member in members({**node, "type": item})]
+        return list(dict.fromkeys(found))
+    if kind == "array":
+        item = ts_type(node.get("items", {}))
+        return [f"{item}[]" if _IDENTIFIER.match(item) else f"Array<{item}>"]
+    if kind == "object":
+        extra = node.get("additionalProperties")
+        if isinstance(extra, dict):
+            return [f"Record<string, {ts_type(extra)}>"]
+        return ["Record<string, unknown>"]
+    return [
+        {
+            "integer": "number",
+            "number": "number",
+            "string": "string",
+            "boolean": "boolean",
+            "null": "null",
+        }.get(str(kind), "unknown")
+    ]
+
+
+def ts_type(node: dict[str, Any]) -> str:
+    """
+    Return the TypeScript type of one schema node.
+
+    Parameters
+    ----------
+    node : dict[str, Any]
+        The schema node.
+
+    Returns
+    -------
+    str
+        Its TypeScript spelling.
+    """
+    return " | ".join(members(node))
+
+
+def notes(node: dict[str, Any]) -> str | None:
+    """
+    Return what a property's type cannot say: its description, bounds and default.
+
+    Parameters
+    ----------
+    node : dict[str, Any]
+        The property's schema node.
+
+    Returns
+    -------
+    str | None
+        One line for a doc comment, or None when there is nothing to say.
+    """
+    parts: list[str] = []
+    description = node.get("description")
+    if description:
+        parts.append(" ".join(description.strip().split("\n\n")[0].split()))
+    for option in [node, *node.get("anyOf", []), *node.get("oneOf", [])]:
+        if "pattern" in option:
+            parts.append(f"Pattern: `{option['pattern']}`.")
+        if "minimum" in option:
+            parts.append(f"Minimum: {option['minimum']}.")
+        if "exclusiveMinimum" in option:
+            parts.append(f"Greater than {option['exclusiveMinimum']}.")
+    if node.get("default") is not None and "const" not in node:
+        parts.append(f"Default: `{json.dumps(node['default'])}`.")
+    if not parts:
+        return None
+    return " ".join(parts).replace("*/", "*\\/")
+
+
+def key(name: str) -> str:
+    """
+    Return a property name, quoted only when TypeScript needs it quoted.
+
+    Parameters
+    ----------
+    name : str
+        The property name.
+
+    Returns
+    -------
+    str
+        The name as an interface member is written.
+    """
+    return name if _IDENTIFIER.match(name) else quote(name)
+
+
+def summary(description: str | None) -> str | None:
+    """
+    Return the first paragraph of a description, as one line.
+
+    Parameters
+    ----------
+    description : str | None
+        The description, if any.
+
+    Returns
+    -------
+    str | None
+        One line, or None when there is nothing to say.
+    """
+    if not description:
+        return None
+    return " ".join(description.strip().split("\n\n")[0].split()).replace("*/", "*\\/")
+
+
+def interface(name: str, schema: dict[str, Any]) -> list[str]:
+    """
+    Render one object schema as an exported interface.
+
+    Parameters
+    ----------
+    name : str
+        The interface name.
+    schema : dict[str, Any]
+        The object schema.
+
+    Returns
+    -------
+    list[str]
+        The lines of the interface.
+    """
+    lines: list[str] = []
+    described = summary(schema.get("description"))
+    if described:
+        lines.append(f"/** {described} */")
+    properties = schema.get("properties") or {}
+    if not properties:
+        return [*lines, f"export interface {name} {{}}"]
+    lines.append(f"export interface {name} {{")
+    required = set(schema.get("required", []))
+    for property_name, node in properties.items():
+        note = notes(node)
+        if note:
+            lines.append(f"{INDENT}/** {note} */")
+        head = (
+            f"{INDENT}{key(property_name)}{'' if property_name in required else '?'}:"
+        )
+        union = members(node)
+        single = f"{head} {' | '.join(union)};"
+        if len(single) <= PRINT_WIDTH or len(union) == 1:
+            lines.append(single)
+            continue
+        lines.append(head)
+        lines.extend(f"{INDENT * 2}| {member}" for member in union[:-1])
+        lines.append(f"{INDENT * 2}| {union[-1]};")
+    lines.append("}")
+    return lines
+
+
+def declare(name: str, value: str, comment: str) -> list[str]:
+    """
+    Render one exported string constant, broken after `=` as prettier breaks it.
+
+    Parameters
+    ----------
+    name : str
+        The constant's name.
+    value : str
+        Its value.
+    comment : str
+        What it is.
+
+    Returns
+    -------
+    list[str]
+        The lines of the declaration.
+    """
+    opening = f"export const {name} = "
+    flat = quote(value)
+    if len(opening) + len(flat) + 1 <= PRINT_WIDTH:
+        return [f"/** {comment} */", f"{opening}{flat};"]
+    return [f"/** {comment} */", opening.rstrip(), f"{INDENT}{flat};"]
+
+
+def generate(text: str) -> str:
+    """
+    Return the whole of the generated TypeScript file.
+
+    Parameters
+    ----------
+    text : str
+        The schema text.
+
+    Returns
+    -------
+    str
+        The file's content.
+    """
+    schema = json.loads(text)
+    root = schema.get("title") or "Environment"
+    properties = schema.get("properties") or {}
+    blocks: list[list[str]] = [
+        [LICENCE],
+        [HEADER],
+        declare(
+            "ENVIRONMENT_SCHEMA_ID",
+            schema["$id"],
+            "The `$id` of the JSON Schema these types are generated from.",
+        ),
+        declare(
+            "ENVIRONMENT_SCHEMA_SHA256",
+            hashlib.sha256(text.encode("utf-8")).hexdigest(),
+            "The sha256 of the schema text these types are generated from.",
+        ),
+        declare(
+            "ENVIRONMENT_API_VERSION",
+            properties["apiVersion"]["const"],
+            "The `apiVersion` an Environment document carries.",
+        ),
+        declare(
+            "ENVIRONMENT_KIND",
+            properties["kind"]["const"],
+            "The `kind` an Environment document carries.",
+        ),
+    ]
+    for name, definition in sorted((schema.get("$defs") or {}).items()):
+        blocks.append(interface(name, definition))
+    blocks.append(interface(root, schema))
+    return "\n\n".join("\n".join(block) for block in blocks) + "\n"
+
+
+def main() -> None:
+    """
+    Write the generated file, or check that the checked-in one is current.
+
+    Raises
+    ------
+    SystemExit
+        When `--check` is given and the file is stale.
+    """
+    expected = generate(read_schema())
+    if "--check" in sys.argv[1:]:
+        if not OUTPUT.exists() or OUTPUT.read_text(encoding="utf-8") != expected:
+            raise SystemExit(
+                f"Stale generated environment types ({OUTPUT.relative_to(ROOT)}): "
+                "run `npm run generate:environments`"
+            )
+        return
+    OUTPUT.write_text(expected, encoding="utf-8")
+
+
+if __name__ == "__main__":
+    main()

package/lib/chat/prompt/InputFooter.d.ts

@@ -1,58 +0,0 @@
-import type { KernelMessage } from '@jupyterlab/services';
-import type { BuiltinTool, ContextSnapshotData, MCPServerConfig, McpToolsetsStatusResponse, ModelConfig, SkillInfo } from '../../types';
-export interface InputToolbarProps {
-    input: string;
-    setInput: (value: string) => void;
-    isLoading: boolean;
-    kernelStatus?: KernelMessage.Status;
-    connectionConfirmed: boolean;
-    placeholder?: string;
-    autoFocus: boolean;
-    focusTrigger?: number;
-    padding: number;
-    onSend: () => void;
-    onStop: () => void;
-    disableInputPrompt?: boolean;
-    showTokenUsage: boolean;
-    agentUsage?: ContextSnapshotData;
-    showModelSelector: boolean;
-    showToolsMenu: boolean;
-    showSkillsMenu: boolean;
-    codemodeEnabled: boolean;
-    /**
-     * Optional callback invoked when the user toggles codemode from the Tools
-     * menu. When omitted the toggle renders as read-only.
-     */
-    onToggleCodemode?: (enabled: boolean) => void | Promise<void>;
-    isA2AProtocol: boolean;
-    hasConfigData: boolean;
-    hasSkillsData: boolean;
-    models: ModelConfig[];
-    selectedModel: string;
-    onModelSelect: (modelId: string) => void;
-    availableTools: BuiltinTool[];
-    /** MCP servers to render (already filtered by selection) */
-    mcpServers: MCPServerConfig[];
-    enabledMcpTools: Map<string, Set<string>>;
-    enabledMcpToolCount: number;
-    onToggleMcpTool: (serverId: string, toolName: string) => void;
-    onToggleAllMcpServerTools: (serverId: string, toolNames: string[], enable: boolean) => void;
-    /** Approved MCP tools per server (default: all tools approved) */
-    approvedMcpTools: Map<string, Set<string>>;
-    onToggleMcpToolApproval: (serverId: string, toolName: string) => void;
-    skills: SkillInfo[];
-    skillsLoading: boolean;
-    enabledSkills: Set<string>;
-    onToggleSkill: (skillId: string) => void;
-    onToggleAllSkills: (skillIds: string[], enable: boolean) => void;
-    /** Approved skills set (default: all skills approved) */
-    approvedSkills: Set<string>;
-    onToggleSkillApproval: (skillId: string) => void;
-    /** API base URL passed to MCP indicator */
-    apiBase?: string;
-    /** Auth token passed to MCP indicator */
-    authToken?: string;
-    /** Pre-fetched MCP status from WebSocket — bypasses REST polling */
-    mcpStatusData?: McpToolsetsStatusResponse | null;
-}
-export declare function InputToolbar({ input, setInput, isLoading, kernelStatus, connectionConfirmed, placeholder, autoFocus, focusTrigger, padding, onSend, onStop, disableInputPrompt, showTokenUsage, agentUsage, showModelSelector, showToolsMenu, showSkillsMenu, codemodeEnabled, onToggleCodemode, isA2AProtocol, hasConfigData, hasSkillsData, models, selectedModel, onModelSelect, availableTools, mcpServers, enabledMcpTools, enabledMcpToolCount, onToggleMcpTool, onToggleAllMcpServerTools, approvedMcpTools, onToggleMcpToolApproval, skills, skillsLoading, enabledSkills, onToggleSkill, onToggleAllSkills, approvedSkills, onToggleSkillApproval, apiBase, authToken, mcpStatusData, }: InputToolbarProps): import("react/jsx-runtime").JSX.Element;

package/lib/chat/prompt/InputFooter.js

@@ -1,194 +0,0 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-/*
- * Copyright (c) 2025-2026 Datalayer, Inc.
- * Distributed under the terms of the Modified BSD License.
- */
-/**
- * InputFooter — Bottom toolbar below the InputPrompt component.
- *
- * Contains the InputPrompt component, the TokenUsageBar, and the
- * model / tools / skills action-menu selectors.
- *
- * @module chat/prompt/InputFooter
- */
-import { Text, Button, ActionMenu, ActionList, ToggleSwitch, } from '@primer/react';
-import { Box } from '@datalayer/primer-addons';
-import { ToolsIcon, BriefcaseIcon, AiModelIcon } from '@primer/octicons-react';
-import { InputPrompt } from './InputPrompt';
-import { TokenUsageBar } from '../usage/TokenUsageBar';
-import { McpStatusIndicator } from '../indicators/McpStatusIndicator';
-import { SkillsStatusIndicator } from '../indicators/SkillsStatusIndicator';
-// ---------------------------------------------------------------------------
-// Component
-// ---------------------------------------------------------------------------
-export function InputToolbar({ input, setInput, isLoading, kernelStatus, connectionConfirmed, placeholder, autoFocus, focusTrigger, padding, onSend, onStop, disableInputPrompt = false, showTokenUsage, agentUsage, showModelSelector, showToolsMenu, showSkillsMenu, codemodeEnabled, onToggleCodemode, isA2AProtocol, hasConfigData, hasSkillsData, models, selectedModel, onModelSelect, availableTools, mcpServers, enabledMcpTools, enabledMcpToolCount, onToggleMcpTool, onToggleAllMcpServerTools, approvedMcpTools, onToggleMcpToolApproval, skills, skillsLoading, enabledSkills, onToggleSkill, onToggleAllSkills, approvedSkills, onToggleSkillApproval, apiBase, authToken, mcpStatusData, }) {
-    const isKernelBusy = kernelStatus === 'busy';
-    const showSelectorsBar = showModelSelector || showToolsMenu || showSkillsMenu;
-    const hasSelectorsContent = hasConfigData || hasSkillsData;
-    // Show token usage when we have valid context data
-    const hasContext = Boolean(agentUsage && !agentUsage.error && agentUsage.totalTokens > 0);
-    return (_jsxs(Box, { children: [_jsx(InputPrompt, { placeholder: placeholder || 'Type a message...', isLoading: isLoading, isKernelBusy: isKernelBusy, disabled: disableInputPrompt, readOnly: !connectionConfirmed, onSend: onSend, onStop: onStop, autoFocus: autoFocus, focusTrigger: focusTrigger, padding: padding, value: input, onChange: setInput, footerRightContent: _jsxs(_Fragment, { children: [_jsx(McpStatusIndicator, { apiBase: apiBase, authToken: authToken, data: mcpStatusData }), _jsx(SkillsStatusIndicator, { skillsCount: skills.length, enabledCount: enabledSkills.size, loading: skillsLoading })] }) }), showTokenUsage && (_jsx(Box, { sx: { minHeight: hasContext && agentUsage ? 28 : 8 }, children: hasContext && agentUsage ? (_jsx(TokenUsageBar, { agentUsage: agentUsage, padding: padding })) : null })), showSelectorsBar && (_jsx(Box, { "aria-disabled": disableInputPrompt || undefined, sx: {
-                    display: 'flex',
-                    gap: 2,
-                    px: padding,
-                    py: 0.5,
-                    minHeight: 36,
-                    borderTop: '1px solid',
-                    borderColor: 'border.default',
-                    alignItems: 'center',
-                    bg: 'canvas.subtle',
-                    ...(disableInputPrompt
-                        ? { opacity: 0.5, pointerEvents: 'none', filter: 'grayscale(1)' }
-                        : null),
-                }, children: hasSelectorsContent ? (_jsxs(_Fragment, { children: [showToolsMenu && (_jsx(ToolsMenu, { codemodeEnabled: codemodeEnabled, onToggleCodemode: onToggleCodemode, mcpServers: mcpServers, enabledMcpTools: enabledMcpTools, enabledMcpToolCount: enabledMcpToolCount, onToggleMcpTool: onToggleMcpTool, onToggleAllMcpServerTools: onToggleAllMcpServerTools, approvedMcpTools: approvedMcpTools, onToggleMcpToolApproval: onToggleMcpToolApproval, availableTools: availableTools })), showSkillsMenu && (_jsx(SkillsMenu, { skills: skills, skillsLoading: skillsLoading, enabledSkills: enabledSkills, onToggleSkill: onToggleSkill, onToggleAllSkills: onToggleAllSkills, approvedSkills: approvedSkills, onToggleSkillApproval: onToggleSkillApproval })), showModelSelector && models.length > 0 && selectedModel && (_jsx(ModelSelector, { models: models, selectedModel: selectedModel, onModelSelect: onModelSelect, isA2AProtocol: isA2AProtocol }))] })) : (_jsx(Text, { sx: { fontSize: 0, color: 'fg.muted' }, children: "Loading controls..." })) }))] }));
-}
-// ---------------------------------------------------------------------------
-// ToolsMenu (private sub-component)
-// ---------------------------------------------------------------------------
-function ToolsMenu({ codemodeEnabled, onToggleCodemode, mcpServers, enabledMcpTools, enabledMcpToolCount, onToggleMcpTool, onToggleAllMcpServerTools, approvedMcpTools, onToggleMcpToolApproval, availableTools: _availableTools, }) {
-    const hasUsableMcpServers = mcpServers.some(server => server.isAvailable);
-    return (_jsxs(ActionMenu, { children: [_jsx(ActionMenu.Anchor, { children: _jsx(Button, { type: "button", variant: "invisible", size: "small", leadingVisual: ToolsIcon, children: _jsxs(Text, { sx: { fontSize: 0 }, children: ["Tools", enabledMcpToolCount > 0 && ` (${enabledMcpToolCount})`] }) }) }), _jsx(ActionMenu.Overlay, { side: "outside-top", align: "start", width: "large", children: _jsx(Box, { sx: { maxHeight: '60vh', overflowY: 'auto' }, children: _jsxs(ActionList, { children: [_jsx(ActionList.Group, { title: "Codemode", children: _jsxs(Box, { sx: {
-                                        display: 'flex',
-                                        alignItems: 'center',
-                                        justifyContent: 'space-between',
-                                        px: 3,
-                                        py: 2,
-                                        borderBottom: '1px solid',
-                                        borderColor: 'border.muted',
-                                        gap: 2,
-                                    }, children: [_jsxs(Box, { sx: { flex: 1, minWidth: 0 }, children: [_jsx(Text, { id: "toggle-codemode", sx: { fontWeight: 'semibold', display: 'block' }, children: "Enable Codemode" }), _jsx(Text, { sx: { fontSize: 0, color: 'fg.muted' }, children: codemodeEnabled
-                                                        ? 'MCP tools accessible via meta-tools (search_tools, execute_code).'
-                                                        : 'Expose MCP tools directly to the model.' })] }), _jsx(ToggleSwitch, { size: "small", checked: codemodeEnabled, disabled: !onToggleCodemode, onClick: () => {
-                                                if (onToggleCodemode) {
-                                                    void onToggleCodemode(!codemodeEnabled);
-                                                }
-                                            }, "aria-labelledby": "toggle-codemode" })] }) }), mcpServers.length > 0 && hasUsableMcpServers ? (mcpServers.map(server => {
-                                const serverTools = enabledMcpTools.get(server.id);
-                                const allToolNames = server.tools.map(t => t.name);
-                                const enabledCount = serverTools?.size ?? 0;
-                                const allEnabled = enabledCount === allToolNames.length &&
-                                    allToolNames.length > 0;
-                                return (_jsxs(ActionList.Group, { title: `${server.name}${server.isAvailable ? '' : ' (unavailable)'}`, children: [server.isAvailable && server.tools.length > 0 && (_jsxs(Box, { sx: {
-                                                display: 'flex',
-                                                alignItems: 'center',
-                                                justifyContent: 'space-between',
-                                                px: 3,
-                                                py: 2,
-                                                borderBottom: '1px solid',
-                                                borderColor: 'border.muted',
-                                            }, children: [_jsxs(Text, { id: `toggle-all-${server.id}`, sx: {
-                                                        fontSize: 0,
-                                                        fontWeight: 'semibold',
-                                                        color: 'fg.muted',
-                                                    }, children: ["Enable all (", enabledCount, "/", allToolNames.length, ")"] }), _jsx(ToggleSwitch, { size: "small", checked: allEnabled, onClick: () => onToggleAllMcpServerTools(server.id, allToolNames, !allEnabled), "aria-labelledby": `toggle-all-${server.id}` })] })), server.isAvailable && server.tools.length > 0 ? (server.tools.map(tool => {
-                                            const isEnabled = serverTools?.has(tool.name) ?? false;
-                                            const serverApproved = approvedMcpTools.get(server.id);
-                                            // Tools default to NOT approved — user must explicitly
-                                            // approve each one (matches the Skills approval UX).
-                                            const isApproved = serverApproved?.has(tool.name) ?? false;
-                                            return (_jsxs(Box, { sx: {
-                                                    display: 'flex',
-                                                    alignItems: 'center',
-                                                    justifyContent: 'space-between',
-                                                    px: 3,
-                                                    py: 2,
-                                                    '&:hover': {
-                                                        backgroundColor: 'canvas.subtle',
-                                                    },
-                                                }, children: [_jsxs(Box, { sx: { flex: 1, minWidth: 0 }, children: [_jsx(Text, { id: `toggle-tool-${server.id}-${tool.name}`, sx: { fontWeight: 'semibold' }, children: tool.name }), tool.description && (_jsx(Text, { sx: {
-                                                                    display: 'block',
-                                                                    fontSize: 0,
-                                                                    color: 'fg.muted',
-                                                                    overflow: 'hidden',
-                                                                    textOverflow: 'ellipsis',
-                                                                    whiteSpace: 'nowrap',
-                                                                }, children: tool.description }))] }), _jsxs(Box, { sx: {
-                                                            display: 'flex',
-                                                            alignItems: 'center',
-                                                            gap: 3,
-                                                        }, children: [_jsxs(Box, { sx: {
-                                                                    display: 'flex',
-                                                                    flexDirection: 'column',
-                                                                    alignItems: 'center',
-                                                                    gap: '2px',
-                                                                }, children: [_jsx(Text, { sx: { fontSize: '10px', color: 'fg.muted' }, children: "Enabled" }), _jsx(ToggleSwitch, { size: "small", checked: isEnabled, onClick: () => onToggleMcpTool(server.id, tool.name), "aria-labelledby": `toggle-tool-${server.id}-${tool.name}` })] }), _jsxs(Box, { sx: {
-                                                                    display: 'flex',
-                                                                    flexDirection: 'column',
-                                                                    alignItems: 'center',
-                                                                    gap: '2px',
-                                                                }, children: [_jsx(Text, { sx: { fontSize: '10px', color: 'fg.muted' }, children: "Approved" }), _jsx(ToggleSwitch, { size: "small", checked: isApproved, onClick: () => onToggleMcpToolApproval(server.id, tool.name), "aria-labelledby": `toggle-tool-${server.id}-${tool.name}` })] })] })] }, `${server.id}-${tool.name}`));
-                                        })) : server.isAvailable ? (_jsx(ActionList.Item, { disabled: true, children: _jsx(Text, { sx: { color: 'fg.muted', fontStyle: 'italic' }, children: "No tools discovered" }) })) : (_jsx(ActionList.Item, { disabled: true, children: _jsx(Text, { sx: { color: 'fg.muted', fontStyle: 'italic' }, children: "Server unavailable" }) }))] }, server.id));
-                            })) : (_jsx(ActionList.Group, { title: "No MCP Servers", children: _jsx(ActionList.Item, { disabled: true, children: _jsx(Text, { sx: { color: 'fg.muted', fontStyle: 'italic' }, children: "No MCP Servers" }) }) }))] }) }) })] }));
-}
-// ---------------------------------------------------------------------------
-// SkillsMenu (private sub-component)
-// ---------------------------------------------------------------------------
-function SkillsMenu({ skills, skillsLoading, enabledSkills, onToggleSkill, onToggleAllSkills, approvedSkills, onToggleSkillApproval, }) {
-    return (_jsxs(ActionMenu, { children: [_jsx(ActionMenu.Anchor, { children: _jsx(Button, { type: "button", variant: "invisible", size: "small", leadingVisual: BriefcaseIcon, children: _jsxs(Text, { sx: { fontSize: 0 }, children: ["Skills", skills.length > 0 && ` (${skills.length})`] }) }) }), _jsx(ActionMenu.Overlay, { side: "outside-top", align: "start", width: "large", children: _jsx(Box, { sx: { maxHeight: '60vh', overflowY: 'auto' }, children: _jsx(ActionList, { children: skillsLoading ? (_jsx(ActionList.Item, { disabled: true, children: _jsx(Text, { sx: { color: 'fg.muted' }, children: "Loading skills..." }) })) : skills.length > 0 ? (_jsxs(_Fragment, { children: [_jsxs(Box, { sx: {
-                                        display: 'flex',
-                                        alignItems: 'center',
-                                        justifyContent: 'space-between',
-                                        px: 3,
-                                        py: 2,
-                                        borderBottom: '1px solid',
-                                        borderColor: 'border.muted',
-                                    }, children: [_jsxs(Text, { id: "toggle-all-skills", sx: {
-                                                fontSize: 0,
-                                                fontWeight: 'semibold',
-                                                color: 'fg.muted',
-                                            }, children: ["Enable all (", enabledSkills.size, "/", skills.length, ")"] }), _jsx(ToggleSwitch, { size: "small", checked: enabledSkills.size === skills.length, onClick: () => onToggleAllSkills(skills.map(s => s.id), enabledSkills.size !== skills.length), "aria-labelledby": "toggle-all-skills" })] }), skills.map(skill => (_jsxs(Box, { sx: {
-                                        display: 'flex',
-                                        alignItems: 'center',
-                                        justifyContent: 'space-between',
-                                        px: 3,
-                                        py: 2,
-                                        '&:hover': {
-                                            backgroundColor: 'canvas.subtle',
-                                        },
-                                    }, children: [_jsxs(Box, { sx: { flex: 1, minWidth: 0 }, children: [_jsxs(Box, { sx: { display: 'flex', alignItems: 'center', gap: 1 }, children: [_jsx(Text, { id: `toggle-skill-${skill.id}`, sx: { fontWeight: 'semibold' }, children: skill.name }), skill.status && (_jsx(Text, { sx: {
-                                                                fontSize: '10px',
-                                                                px: 1,
-                                                                borderRadius: 2,
-                                                                bg: skill.status === 'loaded'
-                                                                    ? 'success.subtle'
-                                                                    : skill.status === 'enabled'
-                                                                        ? 'attention.subtle'
-                                                                        : 'neutral.subtle',
-                                                                color: skill.status === 'loaded'
-                                                                    ? 'success.fg'
-                                                                    : skill.status === 'enabled'
-                                                                        ? 'attention.fg'
-                                                                        : 'fg.muted',
-                                                            }, children: skill.status }))] }), skill.description && (_jsx(Text, { sx: {
-                                                        display: 'block',
-                                                        fontSize: 0,
-                                                        color: 'fg.muted',
-                                                        overflow: 'hidden',
-                                                        textOverflow: 'ellipsis',
-                                                        whiteSpace: 'nowrap',
-                                                    }, children: skill.description }))] }), _jsxs(Box, { sx: { display: 'flex', alignItems: 'center', gap: 3 }, children: [_jsxs(Box, { sx: {
-                                                        display: 'flex',
-                                                        flexDirection: 'column',
-                                                        alignItems: 'center',
-                                                        gap: '2px',
-                                                    }, children: [_jsx(Text, { sx: { fontSize: '10px', color: 'fg.muted' }, children: "Enabled" }), _jsx(ToggleSwitch, { size: "small", checked: enabledSkills.has(skill.id), onClick: () => onToggleSkill(skill.id), "aria-labelledby": `toggle-skill-${skill.id}` })] }), _jsxs(Box, { sx: {
-                                                        display: 'flex',
-                                                        flexDirection: 'column',
-                                                        alignItems: 'center',
-                                                        gap: '2px',
-                                                    }, children: [_jsx(Text, { sx: { fontSize: '10px', color: 'fg.muted' }, children: "Approved" }), _jsx(ToggleSwitch, { size: "small", checked: approvedSkills.has(skill.id), onClick: () => onToggleSkillApproval(skill.id), "aria-labelledby": `toggle-skill-${skill.id}` })] })] })] }, skill.id)))] })) : (_jsx(ActionList.Item, { disabled: true, children: _jsx(Text, { sx: { color: 'fg.muted', fontStyle: 'italic' }, children: "No skills available" }) })) }) }) })] }));
-}
-// ---------------------------------------------------------------------------
-// ModelSelector (private sub-component)
-// ---------------------------------------------------------------------------
-function ModelSelector({ models, selectedModel, onModelSelect, isA2AProtocol, }) {
-    return (_jsxs(Box, { sx: {
-            display: 'flex',
-            flexDirection: 'column',
-            alignItems: 'flex-end',
-        }, children: [_jsxs(ActionMenu, { children: [_jsx(ActionMenu.Anchor, { children: _jsx(Button, { type: "button", variant: "invisible", size: "small", leadingVisual: AiModelIcon, disabled: isA2AProtocol, sx: isA2AProtocol
-                                ? { opacity: 0.5, cursor: 'not-allowed' }
-                                : undefined, children: _jsx(Text, { sx: { fontSize: 0 }, children: models.find(m => m.id === selectedModel)?.name || 'Select Model' }) }) }), _jsx(ActionMenu.Overlay, { side: "outside-top", align: "end", children: _jsx(ActionList, { selectionVariant: "single", children: models.map(modelItem => (_jsxs(ActionList.Item, { selected: selectedModel === modelItem.id, onSelect: () => onModelSelect(modelItem.id), disabled: modelItem.isAvailable === false || isA2AProtocol, sx: modelItem.isAvailable === false
-                                    ? { color: 'fg.muted' }
-                                    : undefined, children: [modelItem.name, modelItem.isAvailable === false && (_jsx(ActionList.Description, { variant: "block", children: "Missing API key" }))] }, modelItem.id))) }) })] }), isA2AProtocol && (_jsx(Text, { sx: { fontSize: 0, color: 'attention.fg', mt: 1 }, children: "A2A: Model set by agent config" }))] }));
-}