agentengine-sdk-python 0.8.5__py3-none-any.whl → 0.8.6__py3-none-any.whl

ksadk/plugins/providers/harness_tools.py

@@ -14,8 +14,13 @@ from collections.abc import Mapping
 from pathlib import Path
 from typing import Any
 
+from ksadk.harness.tool_output import publish_tool_output
 from ksadk.harness.tools import HarnessTool
 
+LOCKED_PYTHON_EXECUTION_POLICY_DIGEST = (
+    "sha256:" + hashlib.sha256(b"ksadk.python-source-bytes/v1").hexdigest()
+)
+
 
 def python_tool_bundle_path(digest: str) -> Path:
     if not re.fullmatch(r"sha256:[0-9a-f]{64}", digest):
@@ -24,45 +29,99 @@ def python_tool_bundle_path(digest: str) -> Path:
 
 
 _EXECUTE = """
-import asyncio, contextlib, importlib.util, inspect, json, sys
-path, name = sys.argv[1:]
+import asyncio, contextlib, hashlib, importlib.util, inspect, json, sys
+from pathlib import Path
+path, name, expected_digest = sys.argv[1:]
 with contextlib.redirect_stdout(sys.stderr):
-    spec = importlib.util.spec_from_file_location('locked_tool', path)
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
-    value = getattr(module, name)(**json.load(sys.stdin))
-    if inspect.isawaitable(value):
-        value = asyncio.run(value)
-print(json.dumps(value, ensure_ascii=False))
+    arguments = json.load(sys.stdin)
+    source = None
+    try:
+        pinned_path = Path(path)
+        if pinned_path.resolve(strict=True) == pinned_path:
+            source = pinned_path.read_bytes()
+    except (OSError, ValueError):
+        pass
+    if source is None or 'sha256:' + hashlib.sha256(source).hexdigest() != expected_digest:
+        result = {'version': 'ksadk.python-source-bytes/v1', 'status': 'source_rejected'}
+    else:
+        spec = importlib.util.spec_from_file_location('locked_tool', path)
+        module = importlib.util.module_from_spec(spec)
+        # Compile exactly the verified bytes. SourceFileLoader may read a .pyc
+        # even with -B, or reopen a changed path after the digest check.
+        exec(compile(source, path, 'exec'), module.__dict__)
+        value = getattr(module, name)(**arguments)
+        if inspect.isawaitable(value):
+            value = asyncio.run(value)
+        result = {'version': 'ksadk.python-source-bytes/v1', 'status': 'ok', 'value': value}
+print(json.dumps(result, ensure_ascii=False))
 """
 
 _EXECUTE_BUILTIN = """
-import contextlib, json, sqlite3, sys
+import contextlib, json, sqlite3, sys, threading
 from dataclasses import asdict
+wire_stdout = sys.stdout
+output_bytes = 0
+output_lock = threading.Lock()
 sys.path.insert(0, sys.argv[1])
 with contextlib.redirect_stdout(sys.stderr):
     from pathlib import Path
     from ksadk.toolsets import get_agentengine_tools
+    import ksadk.toolsets.platform as platform
+    import ksadk.toolsets.sandbox as sandbox
     import ksadk.toolsets.workspace as workspace
     import ksadk.toolsets.workspace_state as state
-    workspace.workspace_root = lambda: Path(sys.argv[2])
+    from ksadk.toolsets.workspace_read_budget import SourceReadBudget, source_read_budget_scope
+    from ksadk.harness.tool_output import tool_output_scope
+    resolved_workspace_root = lambda: Path(sys.argv[2])
+    # Builtin modules import workspace_root by value. Patch every consumer so
+    # file tools, status tools, and command execution share the exact policy
+    # root passed by the managed provider.
+    workspace.workspace_root = resolved_workspace_root
+    platform.workspace_root = resolved_workspace_root
+    sandbox.workspace_root = resolved_workspace_root
     tool = get_agentengine_tools(include=[sys.argv[3]], mode='direct')[0]
     arguments = json.load(sys.stdin)
-    # Keep read-before-edit protection across short-lived executor processes.
-    # The DB is outside the tool-visible workspace and scoped by session.
-    db_path = Path(sys.argv[4])
-    db_path.parent.mkdir(parents=True, exist_ok=True)
-    with sqlite3.connect(db_path, timeout=10) as db:
-        db.execute('CREATE TABLE IF NOT EXISTS reads (session TEXT PRIMARY KEY, data TEXT)')
-        db.execute('BEGIN IMMEDIATE')
-        row = db.execute('SELECT data FROM reads WHERE session=?', (sys.argv[5],)).fetchone()
-        if row:
-            for item in json.loads(row[0]):
-                state.record_read_state(state.WorkspaceReadState(**item))
-        value = tool.invoke(arguments) if hasattr(tool, 'invoke') else tool(**arguments)
-        snapshot = [asdict(item) for item in state._READ_STATE.values()]
-        db.execute('INSERT OR REPLACE INTO reads VALUES (?, ?)',
-                   (sys.argv[5], json.dumps(snapshot)))
+    source_budget = SourceReadBudget.from_transport(json.loads(sys.argv[6]))
+
+    def public_output(channel, text):
+        global output_bytes
+        if sys.argv[3] != 'run_command' or channel not in {'stdout', 'stderr'}:
+            return
+        with output_lock:
+            text = str(text)[:max(0, 32768 - output_bytes)]
+            output_bytes += len(text)
+            for offset in range(0, len(text), 4096):
+                print('KSADK_PUBLIC_OUTPUT:' + json.dumps(
+                    {'channel': channel, 'text': text[offset:offset + 4096]},
+                    ensure_ascii=False), file=wire_stdout, flush=True)
+
+    def invoke_builtin():
+        with source_read_budget_scope(source_budget), tool_output_scope(public_output):
+            return tool.invoke(arguments) if hasattr(tool, 'invoke') else tool(**arguments)
+
+    # File observations and mutations share the persistent revision guard.
+    # Commands, searches, listings and unrelated tools do not consume it and
+    # must not hold its write transaction throughout their execution.
+    stateful = sys.argv[3] in {
+        'read_workspace_file', 'write_workspace_file', 'write_workspace_files',
+        'edit_workspace_file', 'multi_edit_workspace_file', 'delete_workspace_file',
+    }
+    if stateful:
+        db_path = Path(sys.argv[4])
+        db_path.parent.mkdir(parents=True, exist_ok=True)
+        with sqlite3.connect(db_path, timeout=10) as db:
+            db.execute('CREATE TABLE IF NOT EXISTS reads (session TEXT PRIMARY KEY, data TEXT)')
+            db.execute('BEGIN IMMEDIATE')
+            row = db.execute('SELECT data FROM reads WHERE session=?', (sys.argv[5],)).fetchone()
+            if row:
+                for item in json.loads(row[0]):
+                    state.record_read_state(state.WorkspaceReadState(**item))
+            value = invoke_builtin()
+            snapshot = [asdict(item) for item in state._READ_STATE.values()]
+            db.execute('INSERT OR REPLACE INTO reads VALUES (?, ?)',
+                       (sys.argv[5], json.dumps(snapshot)))
+    else:
+        value = invoke_builtin()
 print(json.dumps(value, ensure_ascii=False))
 """
 
@@ -125,6 +184,22 @@ def _plain(value: Any) -> Any:
     return value
 
 
+def _resolved_agent_id(resolved: Mapping[str, Any]) -> str:
+    """Read the canonical Agent id from a compiled resolved spec.
+
+    Current bundles store it as the top-level ``agentId``.  Keep the legacy
+    metadata fallback for older hand-authored fixtures and bundles, but never
+    assume that a source-draft metadata object survives compilation.
+    """
+    direct = str(resolved.get("agentId") or "").strip()
+    if direct:
+        return direct
+    metadata = resolved.get("metadata")
+    if isinstance(metadata, Mapping):
+        return str(metadata.get("id") or "").strip()
+    return ""
+
+
 def _reserve_tool_call(
     *,
     database: Path,
@@ -230,10 +305,15 @@ def assemble_python_tools(
             policy = current_execution_policy()
             policy_root = policy.workspace_root if policy is not None else None
             writable_root = policy_root or workspace_root or root
+            state_root = (
+                policy.tool_state_root
+                if policy is not None and policy.tool_state_root is not None
+                else writable_root
+            )
             max_calls = contract.get("maxCallsPerRun")
             if max_calls is not None:
                 _reserve_tool_call(
-                    database=writable_root
+                    database=state_root
                     / ".harness-tools"
                     / "state"
                     / "tool-call-quotas.sqlite",
@@ -242,7 +322,7 @@ def assemble_python_tools(
                     limit=int(max_calls),
                 )
             if descriptor is None:
-                command = [_EXECUTE, str(path), contract["callableName"]]
+                command = [_EXECUTE, str(path), contract["callableName"], contract["sourceSha256"]]
             else:
                 from ksadk.toolsets.workspace_identity import identity_workspace_root
 
@@ -253,23 +333,31 @@ def assemble_python_tools(
                 env = dict(
                     os.environ, KSADK_TOOL_APPROVAL_MODE="full",
                     KSADK_PROJECT_DIR=str(execution_root),
-                    AGENTENGINE_UI_DIR=str(execution_root / ".harness-tools" / "ui"),
+                    KSADK_STUDIO_AGENT_ID=_resolved_agent_id(resolved),
+                    AGENTENGINE_UI_DIR=str(state_root / ".harness-tools" / "ui"),
                 )
                 scoped_root = policy_root or identity_workspace_root(
                     (workspace_root or root) / ".harness-tools" / "workspace"
                 ).resolve()
+                from ksadk.toolsets.workspace_read_budget import current_source_read_budget
+
+                source_budget = (
+                    current_source_read_budget()
+                    if contract["name"] == "read_workspace_file" else None
+                )
                 command = [
                     _EXECUTE_BUILTIN,
                     str(Path(__file__).resolve().parents[3]),
                     str(scoped_root),
                     contract["name"],
                     str(
-                        writable_root
+                        state_root
                         / ".harness-tools"
                         / "state"
                         / (hashlib.sha256(str(scoped_root).encode()).hexdigest() + ".sqlite")
                     ),
                     tool_context.session_id or "default",
+                    json.dumps(source_budget.transport() if source_budget is not None else None),
                 ]
             process = await asyncio.create_subprocess_exec(
                 sys.executable,
@@ -290,23 +378,64 @@ def assemble_python_tools(
                     await process.stdin.drain()
                     process.stdin.close()
                     output = bytearray()
+                    pending = bytearray()
+                    allow_progress = descriptor is not None and contract["name"] == "run_command"
+                    prefix = b'KSADK_PUBLIC_OUTPUT:'
                     while chunk := await process.stdout.read(65536):
-                        output.extend(chunk)
-                        if len(output) > 1_048_576:
+                        pending.extend(chunk)
+                        while b'\n' in pending:
+                            line, _, tail = pending.partition(b'\n')
+                            pending = bytearray(tail)
+                            if allow_progress and line.startswith(prefix):
+                                progress = json.loads(line[len(prefix):])
+                                publish_tool_output(progress.get('channel'), progress.get('text'))
+                            else:
+                                output.extend(line + b'\n')
+                        if len(output) + len(pending) > 1_048_576:
                             raise ValueError("Tool 输出超过 1 MiB 限制")
+                    output.extend(pending)
                     await process.wait()
                     if process.returncode:
                         raise RuntimeError(
                             f"Tool {contract['name']} 执行失败，请检查参数与运行环境"
                         )
-                    return json.loads(output)
+                    value = json.loads(output)
+                    if descriptor is None:
+                        if (
+                            not isinstance(value, dict)
+                            or value.get("version") != "ksadk.python-source-bytes/v1"
+                        ):
+                            raise RuntimeError("Locked Python worker returned an invalid protocol")
+                        if value.get("status") == "source_rejected":
+                            return {
+                                "ok": False,
+                                "error_type": "tool_source_integrity",
+                                "error_message": (
+                                    "Locked Python Tool source is unavailable or changed"
+                                ),
+                            }
+                        if value.get("status") != "ok" or "value" not in value:
+                            raise RuntimeError("Locked Python worker returned an invalid protocol")
+                        return value["value"]
+                    return value
+            completed = False
             try:
-                return await asyncio.wait_for(
+                result = await asyncio.wait_for(
                     consume_output(), timeout=contract.get("timeoutSeconds", 20)
                 )
+                completed = True
+                return result
             finally:
-                if process.returncode is None:
-                    os.killpg(process.pid, signal.SIGKILL)
+                # An exited group leader can leave descendants holding stdout
+                # and performing writes. A failed/cancelled foreground call
+                # retains cleanup ownership until its group has been stopped.
+                if not completed or process.returncode is None:
+                    try:
+                        os.killpg(process.pid, signal.SIGKILL)
+                    except ProcessLookupError:
+                        # Natural exit must not replace the original error or
+                        # cancellation with an unrelated cleanup exception.
+                        pass
                 await process.wait()
 
         tools[name] = HarnessTool(

ksadk/plugins/providers/legacy_catalog.py

@@ -46,7 +46,7 @@ def _provider_manifest(
         "compatibility": {
             "kernelApi": ">=1,<2",
             "runtimeProtocols": ["agentkit.runtime/v1"],
-            "python": ">=3.10,<3.15" if runtime == "python" else None,
+            "python": ">=3.12,<3.15" if runtime == "python" else None,
         },
         "healthContract": "plugin.health/v1",
         "provenance": {

ksadk/plugins/providers/mcp_projection.py

@@ -3,9 +3,9 @@
 from __future__ import annotations
 
 import asyncio
-from collections.abc import Awaitable, Sequence
+from collections.abc import Awaitable, Callable, Sequence
 from contextlib import AsyncExitStack
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Protocol, runtime_checkable
 
 from ksadk.harness.config import McpToolSpec
@@ -46,6 +46,22 @@ class ReleasableStaticMCPSource(Protocol):
     async def release_harness_mcp_specs(self, specs: Sequence[McpToolSpec]) -> None: ...
 
 
+@dataclass(frozen=True)
+class MCPResourcePin:
+    name: str
+    generation: str
+    descriptor_digest: str
+
+
+@dataclass(frozen=True)
+class MCPRuntimeCredential:
+    """Ephemeral host callbacks; never part of a spec, lock or Run snapshot."""
+
+    name: str
+    token: Callable[[], Awaitable[str]] = field(repr=False)
+    available: Callable[[], Awaitable[bool]] = field(repr=False)
+
+
 @dataclass
 class MCPProjectionLease:
     """Projected connector specs and their activation-owned cleanup."""
@@ -53,7 +69,35 @@ class MCPProjectionLease:
     specs: tuple[McpToolSpec, ...]
     owners: tuple[str, ...]
     _cleanup: AsyncExitStack
+    _checks: tuple[Callable[[], Awaitable[bool]], ...] = ()
+    _activation_available: Callable[[], bool] | None = None
+    resource_pins: tuple[MCPResourcePin, ...] = ()
     _close_task: asyncio.Task[None] | None = None
+    runtime_credentials: tuple[MCPRuntimeCredential, ...] = ()
+    _runtime_checks: tuple[Callable[[], Awaitable[bool]], ...] = ()
+
+    async def available(self) -> bool:
+        """Check original owners; never replace specs with a newer lease."""
+        return await self._available(self._checks)
+
+    async def runtime_available(self) -> bool:
+        """Admit only clients explicitly consuming owned runtime credentials."""
+        return await self._available(self._runtime_checks or self._checks)
+
+    async def _available(self, checks: tuple[Callable[[], Awaitable[bool]], ...]) -> bool:
+        if self._close_task is not None:
+            return False
+        try:
+            if self._activation_available is not None and not self._activation_available():
+                return False
+            for check in checks:
+                if await check() is not True:
+                    return False
+            return self._close_task is None and (
+                self._activation_available is None or self._activation_available() is True
+            )
+        except Exception:
+            return False
 
     async def aclose(self) -> None:
         if self._close_task is None:
@@ -86,6 +130,10 @@ async def project_mcp_capabilities(
     cleanup = AsyncExitStack()
     specs: list[McpToolSpec] = []
     owners: list[str] = []
+    checks: list[Callable[[], Awaitable[bool]]] = []
+    runtime_checks: list[Callable[[], Awaitable[bool]]] = []
+    runtime_credentials: list[MCPRuntimeCredential] = []
+    resource_pins: list[MCPResourcePin] = []
     names: set[str] = set()
     try:
         for binding in capabilities.all("mcp.connector/v1"):
@@ -120,6 +168,46 @@ async def project_mcp_capabilities(
                     "mcp_capability_incompatible",
                     f"plugin {binding.plugin_id} cannot project MCP connector config",
                 )
+            lease_check = getattr(runtime, "activation_mcp_specs_available", None)
+            if callable(lease_check):
+
+                async def check(source=runtime, selected=projected_specs):
+                    return await source.activation_mcp_specs_available(selected)
+
+                checks.append(check)
+            else:
+                checks.append(runtime.health)
+            credentials = getattr(runtime, "activation_mcp_runtime_credentials", None)
+            selected_credentials = (
+                tuple(credentials(projected_specs)) if callable(credentials) else ()
+            )
+            if any(
+                not isinstance(item, MCPRuntimeCredential)
+                or item.name not in {spec.name for spec in projected_specs}
+                for item in selected_credentials
+            ) or len({item.name for item in selected_credentials}) != len(selected_credentials):
+                raise PluginHostError("mcp_credential_invalid", "invalid MCP runtime credential")
+            if selected_credentials and {item.name for item in selected_credentials} != {
+                spec.name for spec in projected_specs
+            }:
+                raise PluginHostError(
+                    "mcp_credential_invalid", "partial MCP runtime credential ownership"
+                )
+            runtime_credentials.extend(selected_credentials)
+            runtime_checks.extend(item.available for item in selected_credentials)
+            # A connector with no rotating credential keeps its original probe.
+            if not selected_credentials:
+                runtime_checks.append(checks[-1])
+            resource_refs = getattr(runtime, "activation_mcp_resource_pins", None)
+            if callable(resource_refs):
+                selected_pins = tuple(resource_refs(projected_specs))
+                if any(
+                    not isinstance(pin, MCPResourcePin)
+                    or pin.name not in {spec.name for spec in projected_specs}
+                    for pin in selected_pins
+                ):
+                    raise PluginHostError("mcp_resource_pin_invalid", "invalid MCP resource pin")
+                resource_pins.extend(selected_pins)
             for spec in projected_specs:
                 if not isinstance(spec, McpToolSpec) or not spec.name.strip():
                     raise PluginHostError(
@@ -138,7 +226,16 @@ async def project_mcp_capabilities(
         close = asyncio.create_task(cleanup.aclose())
         await _finish_owned_task(close)
         raise
-    return MCPProjectionLease(tuple(specs), tuple(owners), cleanup)
+    return MCPProjectionLease(
+        tuple(specs),
+        tuple(owners),
+        cleanup,
+        tuple(checks),
+        capabilities.activation_available,
+        tuple(resource_pins),
+        runtime_credentials=tuple(runtime_credentials),
+        _runtime_checks=tuple(runtime_checks),
+    )
 
 
 __all__ = [

ksadk/plugins/providers/platform_resources.py

@@ -99,7 +99,7 @@ def platform_resource_mcp_manifest() -> PluginManifest:
                     "compatibility": {
                         "kernelApi": ">=1,<2",
                         "runtimeProtocols": ["agentkit.runtime/v1", "2025-06-18"],
-                        "python": ">=3.10,<3.15",
+                        "python": ">=3.12,<3.15",
                     },
                     "healthContract": "plugin.health/v1",
                     "provenance": {
@@ -126,8 +126,9 @@ def _activation_operations(
 ) -> tuple[str, ...]:
     """Narrow an admitted maximum to the immutable Agent memory policy."""
 
-    read_operations = tuple(operation for operation in allowed if operation != "save_memory")
-    if "save_memory" not in allowed or write_authorizer is None:
+    write_operations = {"save_memory", "update_memory", "delete_memory"}
+    read_operations = tuple(operation for operation in allowed if operation not in write_operations)
+    if not write_operations.intersection(allowed) or write_authorizer is None:
         return tuple(operation for operation in read_operations if operation != "memory_status")
     resolved = bundle.resolved_agent_spec
     memory = resolved.get("memory") if isinstance(resolved, Mapping) else None
@@ -144,9 +145,18 @@ def _activation_operations(
         or str(rollout.get("memoryWrite") or "off") != "enabled"
     ):
         return tuple(operation for operation in read_operations if operation != "memory_status")
-    return tuple(operation for operation in allowed if operation in {
-        "load_memory", "save_memory", "memory_status",
-    })
+    return tuple(
+        operation
+        for operation in allowed
+        if operation
+        in {
+            "load_memory",
+            "save_memory",
+            "update_memory",
+            "delete_memory",
+            "memory_status",
+        }
+    )
 
 
 def _profile_config(profile: CompositionProfile) -> Mapping[str, Any]:

ksadk/plugins/teams/application.py

@@ -17,14 +17,15 @@ from ksadk.conversations.contracts import ConversationItem
 from ksadk.conversations.reducer import ConversationItemReducer
 from ksadk.plugins.execution_host import PluginExecutionScope
 
-from .contracts import TERMINAL, Actor, TaskCreateInput
+from .contracts import TERMINAL, Actor
 from .domain import public
 from .errors import TeamsError
 from .runtime import TEAMS_PLUGIN_ID, TeamsRuntime
 from .store import new_id, now
+from .tool_service import TeamsToolMethods
 
 
-class TeamsApplication:
+class TeamsApplication(TeamsToolMethods):
     def __init__(
         self,
         *,
@@ -338,147 +339,6 @@ class TeamsApplication:
             },
         )
 
-    @staticmethod
-    def tool_definitions():
-        def schema(properties, required=()):
-            return {
-                "type": "object",
-                "properties": properties,
-                "required": list(required),
-                "additionalProperties": False,
-            }
-
-        text = {"type": "string"}
-        return [
-            ("team_context", "读取当前团队消息、成员和任务状态。", schema({})),
-            (
-                "team_message",
-                "发布进度，或明确请求某成员执行；wake=false仅留言，不触发执行。",
-                schema(
-                    {"content": text, "targetMemberId": text, "wake": {"type": "boolean"}},
-                    ["content"],
-                ),
-            ),
-            (
-                "team_create_task",
-                "仅Leader：创建有验收标准的任务；指定负责人即自动派发，不要再额外wake。依赖用本轮已有taskId。",
-                TaskCreateInput.model_json_schema(),
-            ),
-            (
-                "team_wait",
-                "仅Leader：持久等待一组任务验收/失败，不阻塞；调用后结束当前回复。",
-                schema(
-                    {"taskIds": {"type": "array", "items": text, "minItems": 1, "maxItems": 64}},
-                    ["taskIds"],
-                ),
-            ),
-            (
-                "team_task_action",
-                "按最新 revision 领取任务；Leader 分配/重试，并仅在leader策略下审核任务结果。",
-                schema(
-                    {
-                        "taskId": text,
-                        "action": {"enum": ["assign", "claim", "retry", "accept", "reject"]},
-                        "expectedRevision": {"type": "integer", "minimum": 1},
-                        "ownerMemberId": text,
-                        "reason": {"type": "string", "maxLength": 2000},
-                    },
-                    ["taskId", "action", "expectedRevision"],
-                ),
-            ),
-            (
-                "team_submit_result",
-                "提交自己当前任务的可核验结果。成功Run结束及验收后才算成功。",
-                schema(
-                    {"result": text, "artifactIds": {"type": "array", "items": text}}, ["result"]
-                ),
-            ),
-            (
-                "team_finish",
-                "仅Leader：所有任务通过验收后提交最终成果，等待群主验收。",
-                schema({"result": text}, ["result"]),
-            ),
-            (
-                "team_publish_artifact",
-                "登记当前独立工作区的实际交付文件，返回有来源和哈希的产物引用。",
-                schema({"path": text, "name": text}, ["path"]),
-            ),
-            (
-                "team_read_artifact",
-                "读取本群已显式共享的不可变交付物，复制到自己工作区并返回来源与摘要。",
-                schema({"artifactId": text}, ["artifactId"]),
-            ),
-        ]
-
-    async def invoke(self, principal, operation, arguments, call_id):
-        # principal is an in-process/opaque-handle Host value, never JSON Actor.
-        actor = principal.get("actor") if isinstance(principal, dict) else None
-        if not isinstance(actor, Actor) or actor.kind != "member":
-            raise TeamsError("invocation_required", "缺少宿主授予的成员调用上下文", status=403)
-        from jsonschema import Draft202012Validator
-        from jsonschema.exceptions import ValidationError
-
-        definition = next((item for item in self.tool_definitions() if item[0] == operation), None)
-        if definition is None:
-            raise TeamsError("tool_unavailable", "当前团队不提供此工具", status=404)
-        try:
-            Draft202012Validator(definition[2]).validate(arguments)
-        except ValidationError as error:
-            raise TeamsError(
-                "invalid_tool_arguments", "协作工具参数不符合声明的结构", status=422
-            ) from error
-        if not isinstance(call_id, str) or not call_id or len(call_id) > 512:
-            raise TeamsError("call_identity_required", "缺少稳定工具调用标识", status=403)
-        with self.domain.store.transaction() as tx:
-            self.domain.authorize(tx, actor, actor.group_id)
-        key = f"tool:{actor.run_id}:{call_id}"
-        if operation == "team_context":
-            from .context import execution_context
-
-            return execution_context(self.domain, actor, principal.get("taskId"))
-        if operation == "team_message":
-            return self.domain.member_message(
-                actor,
-                content=arguments["content"],
-                target_member_id=arguments.get("targetMemberId"),
-                wake=arguments.get("wake", False),
-                source_delivery_id=principal["deliveryId"],
-                key=key,
-            )
-        if operation == "team_create_task":
-            return self.domain.create_task(
-                actor,
-                actor.group_id,
-                actor.team_run_id,
-                TaskCreateInput.model_validate(arguments),
-                key,
-            )
-        if operation == "team_wait":
-            return self.domain.wait_for_tasks(actor, arguments["taskIds"], key)
-        if operation == "team_task_action":
-            return self.domain.task_action(
-                actor,
-                actor.group_id,
-                arguments["taskId"],
-                arguments["action"],
-                arguments["expectedRevision"],
-                key,
-                owner_member_id=arguments.get("ownerMemberId"),
-                reason=arguments.get("reason"),
-            )
-        if operation == "team_submit_result":
-            artifacts = self._artifacts(actor, arguments.get("artifactIds", []))
-            return self.domain.result_candidate(
-                actor, principal["taskId"], arguments["result"], key, artifacts=artifacts
-            )
-        if operation == "team_finish":
-            return self.domain.finish_candidate(actor, arguments["result"], key)
-        if operation == "team_publish_artifact":
-            return self.publish_artifact(actor, arguments["path"], arguments.get("name"), key)
-        if operation == "team_read_artifact":
-            return self.read_artifact(actor, arguments["artifactId"])
-        raise TeamsError("tool_unavailable", "当前团队不提供此工具", status=404)
-
     def read_artifact(self, actor, artifact_id):
         from .artifacts import read_workspace_artifact