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

ksadk/plugins/host.py

@@ -8,7 +8,7 @@ healthy, and disposes owned effects in reverse dependency order.
 from __future__ import annotations
 
 import asyncio
-from collections.abc import Coroutine, Mapping
+from collections.abc import Callable, Coroutine, Mapping
 from dataclasses import dataclass
 from typing import Any, Protocol, runtime_checkable
 from uuid import uuid4
@@ -36,6 +36,26 @@ class PluginHostError(RuntimeError):
         self.code = code
 
 
+def _activation_claims(value: Mapping[str, str] | None) -> tuple[tuple[str, str], ...]:
+    """Freeze host-signed activation identity without accepting request payloads."""
+    if value is None:
+        return ()
+    if not isinstance(value, Mapping) or len(value) > 32:
+        raise PluginHostError("agent_activation_claims_invalid", "invalid activation claims")
+    claims = tuple(sorted(value.items()))
+    if any(
+        type(key) is not str
+        or type(item) is not str
+        or not key
+        or not item
+        or len(key) > 80
+        or len(item) > 16_384
+        for key, item in claims
+    ):
+        raise PluginHostError("agent_activation_claims_invalid", "invalid activation claims")
+    return claims
+
+
 @runtime_checkable
 class ManagedPlugin(Protocol):
     """Effects owned by one staged plugin instance."""
@@ -83,6 +103,11 @@ class PluginExecutionContext:
     # The host owns this key. Capability plugins may use it to bind ephemeral
     # leases to the same provider activation without learning request payloads.
     activation_key: str = ""
+    activation_claims: tuple[tuple[str, str], ...] = ()
+    activation_generation: str = ""
+    # Checks the exact owning host generation, including retained old graphs.
+    # Code/configuration digests alone cannot establish resource liveness.
+    activation_available: Callable[[], bool] | None = None
 
     def all(
         self,
@@ -156,8 +181,10 @@ class _ActiveGraph:
 @dataclass
 class _ActiveActivation:
     key: str
+    generation: str
     graph: _ActiveGraph
     bundle_digest: str
+    activation_claims: tuple[tuple[str, str], ...]
     runtime: PreparedAgent
     operation_lock: asyncio.Lock
     operation_task: asyncio.Task[Any] | None = None
@@ -185,6 +212,10 @@ class PluginActivationSession:
     def bundle_digest(self) -> str:
         return self._active.bundle_digest
 
+    @property
+    def generation(self) -> str:
+        return self._active.generation
+
     @property
     def closed(self) -> bool:
         return self._active.closed
@@ -343,6 +374,7 @@ class PluginHost:
         bundle: ResolvedPluginBundle,
         *,
         activation_key: str,
+        activation_claims: Mapping[str, str] | None = None,
     ) -> PluginActivationSession:
         """Open or reuse one profile-fenced, provider-owned activation.
 
@@ -357,9 +389,15 @@ class PluginHost:
                 "agent_activation_key_invalid",
                 "activation_key must be a non-empty value of at most 512 characters",
             )
+        claims = _activation_claims(activation_claims)
         async with self._transaction_lock:
             existing = self._activations.get(key)
             if existing is not None:
+                if not existing.closed and existing.activation_claims != claims:
+                    raise PluginHostError(
+                        "agent_activation_claims_mismatch",
+                        "session activation claims changed",
+                    )
                 if (
                     not existing.closed
                     and existing.bundle_digest == bundle.bundle_digest
@@ -374,15 +412,30 @@ class PluginHost:
                 await self._finish_cleanup(self._dispose_unpinned_retired_graphs())
 
             graph = self._require_bundle_graph(bundle)
+            generation = uuid4().hex
+
+            def available() -> bool:
+                current = self._activations.get(key)
+                return (
+                    current is not None
+                    and current.generation == generation
+                    and not current.closed
+                )
+
             runtime = await self._prepare_activation(
                 graph,
                 bundle,
                 activation_key=key,
+                activation_claims=claims,
+                activation_generation=generation,
+                activation_available=available,
             )
             active = _ActiveActivation(
                 key=key,
+                generation=generation,
                 graph=graph,
                 bundle_digest=bundle.bundle_digest,
+                activation_claims=claims,
                 runtime=runtime,
                 operation_lock=asyncio.Lock(),
             )
@@ -516,8 +569,17 @@ class PluginHost:
         bundle: ResolvedPluginBundle,
         *,
         activation_key: str,
+        activation_claims: tuple[tuple[str, str], ...],
+        activation_generation: str,
+        activation_available: Callable[[], bool],
     ) -> PreparedAgent:
-        capabilities = self._execution_context(graph, activation_key=activation_key)
+        capabilities = self._execution_context(
+            graph,
+            activation_key=activation_key,
+            activation_claims=activation_claims,
+            activation_generation=activation_generation,
+            activation_available=activation_available,
+        )
         provider_binding = capabilities.require("agent.provider/v1", slot="agent.execution")
         provider = provider_binding.runtime
         if not isinstance(provider, ExecutableAgentProvider):
@@ -581,19 +643,19 @@ class PluginHost:
                 result = await active.runtime.execute(request)
             except asyncio.CancelledError:
                 if not active.closed:
+                    active.closed = True
                     await self._dispose_activation(active.runtime)
-                active.closed = True
                 raise
             except PluginHostError as error:
                 self._last_failure = error
-                await self._dispose_activation(active.runtime)
                 active.closed = True
+                await self._dispose_activation(active.runtime)
                 raise
             except Exception as error:  # noqa: BLE001 - provider boundary
                 failure = PluginHostError("agent_execution_failed", str(error))
                 self._last_failure = failure
-                await self._dispose_activation(active.runtime)
                 active.closed = True
+                await self._dispose_activation(active.runtime)
                 raise failure from error
             finally:
                 if active.operation_task is task:
@@ -706,6 +768,9 @@ class PluginHost:
         graph: _ActiveGraph,
         *,
         activation_key: str = "",
+        activation_claims: tuple[tuple[str, str], ...] = (),
+        activation_generation: str = "",
+        activation_available: Callable[[], bool] | None = None,
     ) -> PluginExecutionContext:
         bindings = tuple(
             PluginCapabilityBinding(
@@ -723,6 +788,9 @@ class PluginHost:
             plugin_lock_digest=graph.resolved.plugin_lock_digest,
             bindings=bindings,
             activation_key=activation_key,
+            activation_claims=activation_claims,
+            activation_generation=activation_generation,
+            activation_available=activation_available,
         )
 
     @staticmethod

ksadk/plugins/kernel_adapter.py

@@ -47,17 +47,20 @@ class PluginKernelAdapter(RuntimeAdapter):
         runtime_type: str,
         bind_delegate: BindDelegate,
         release_binding: ReleaseBinding,
+        release_failed_binding: ReleaseBinding | None = None,
     ) -> None:
         super().__init__(_PluginKernelRuntime(runtime_type))
         self._runtime_type = runtime_type
         self._bind_delegate_callback = bind_delegate
         self._release_binding_callback = release_binding
+        self._release_failed_binding_callback = release_failed_binding or release_binding
         self._delegate: RuntimeAdapter | None = None
         self._native_handle: RunHandle | None = None
 
     async def start(self, request: StartRequest) -> RunHandle:
         try:
             delegate = await self._bind_delegate(request.session_id)
+            request = await self._prepare_start_request(delegate, request)
             metadata = dict(request.metadata)
             if not metadata.get("invocation_id") and metadata.get("run_id"):
                 metadata["invocation_id"] = metadata["run_id"]
@@ -70,6 +73,12 @@ class PluginKernelAdapter(RuntimeAdapter):
             await self._release_failed_binding(request.session_id)
             raise
 
+    async def _prepare_start_request(
+        self, delegate: RuntimeAdapter, request: StartRequest
+    ) -> StartRequest:
+        """Let a product host admit a bound delegate before its first effect."""
+        return request
+
     def stream(self, handle: RunHandle):  # type: ignore[no-untyped-def]
         return self._require_delegate().stream(self._provider_handle(handle))
 
@@ -97,6 +106,7 @@ class PluginKernelAdapter(RuntimeAdapter):
     async def attach(self, handle: RunHandle) -> RunHandle:
         try:
             delegate = await self._bind_delegate(handle.session_id)
+            handle = await self._prepare_restore_handle(delegate, handle)
             native_handle = await delegate.attach(self._provider_handle(handle))
             self._native_handle = native_handle
             return self._outer_handle(native_handle)
@@ -107,15 +117,42 @@ class PluginKernelAdapter(RuntimeAdapter):
     async def steer(self, handle: RunHandle, payload: SteerPayload) -> None:
         await self._require_delegate().steer(self._provider_handle(handle), payload)
 
+    async def guide(self, handle: RunHandle, payload: SteerPayload) -> object | None:
+        return await self._require_delegate().guide(self._provider_handle(handle), payload)
+
+    async def child_tasks(self, handle: RunHandle) -> tuple[dict, ...]:
+        return await self._require_delegate().child_tasks(self._provider_handle(handle))
+
+    async def child_execution_view(self, handle: RunHandle, child_run_id: str) -> dict:
+        return await self._require_delegate().child_execution_view(self._provider_handle(handle), child_run_id)
+
+    async def cancel_child(self, handle: RunHandle, *, child_run_id: str, command_id: str):
+        return await self._require_delegate().cancel_child(
+            self._provider_handle(handle), child_run_id=child_run_id, command_id=command_id,
+        )
+
+    async def promote_child(self, handle: RunHandle, *, child_run_id: str, command_id: str):
+        return await self._require_delegate().promote_child(
+            self._provider_handle(handle), child_run_id=child_run_id, command_id=command_id,
+        )
+
     async def inject(self, handle: RunHandle, payload: InjectPayload) -> None:
         await self._require_delegate().inject(self._provider_handle(handle), payload)
 
+    async def send_child_input(self, handle: RunHandle, *, child_run_id: str, text: str,
+                               command_id: str, expected_goal_revision: int):
+        return await self._require_delegate().send_child_input(
+            self._provider_handle(handle), child_run_id=child_run_id, text=text,
+            command_id=command_id, expected_goal_revision=expected_goal_revision,
+        )
+
     async def checkpoint(self, handle: RunHandle) -> CheckpointDescriptor:
         return await self._require_delegate().checkpoint(self._provider_handle(handle))
 
     async def durable_restore(self, handle: RunHandle) -> RunHandle:
         try:
             delegate = await self._bind_delegate(handle.session_id)
+            handle = await self._prepare_restore_handle(delegate, handle)
             native_handle = await delegate.durable_restore(
                 self._provider_handle(handle)
             )
@@ -125,6 +162,12 @@ class PluginKernelAdapter(RuntimeAdapter):
             await self._release_failed_binding(handle.session_id)
             raise
 
+    async def _prepare_restore_handle(
+        self, delegate: RuntimeAdapter, handle: RunHandle
+    ) -> RunHandle:
+        """Let the product host recheck immutable pins before reattaching effects."""
+        return handle
+
     def is_handle_attached(self, handle: RunHandle) -> bool:
         return self._delegate is not None and self._delegate.is_handle_attached(
             self._provider_handle(handle)
@@ -185,7 +228,7 @@ class PluginKernelAdapter(RuntimeAdapter):
 
         self._delegate = None
         self._native_handle = None
-        cleanup = asyncio.create_task(self._release_binding_callback(session_id))
+        cleanup = asyncio.create_task(self._release_failed_binding_callback(session_id))
         interrupted = False
         while not cleanup.done():
             try:

ksadk/plugins/memory_provider.py

@@ -0,0 +1,180 @@
+"""Host-scoped recall seam for the DSH memory.provider/v1 capability."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Literal, Protocol, runtime_checkable
+
+from pydantic import Field, model_validator
+
+from ksadk.memory.models import MemorySearchResult
+from ksadk.plugins.bundle import ResolvedPluginBundle
+from ksadk.plugins.contracts import PluginContractModel
+
+MemoryScopeName = Literal["tenant", "workspace", "agent", "user"]
+
+
+class MemoryPrincipal(PluginContractModel):
+    tenant_id: str = Field(min_length=1)
+    workspace_id: str = Field(min_length=1)
+    agent_id: str = Field(min_length=1)
+    user_id: str = Field(min_length=1)
+
+
+class MemoryRecallRequest(PluginContractModel):
+    """Bounded candidates; max_tokens grants the host's final projected recall budget."""
+
+    principal: MemoryPrincipal
+    query: str = Field(max_length=131_072)
+    scopes: tuple[MemoryScopeName, ...]
+    top_k: int = Field(strict=True, ge=1, le=64)
+    max_tokens: int = Field(strict=True, ge=0)
+    min_score: float = Field(ge=0, le=1, allow_inf_nan=False)
+
+
+class MemoryRecordRequest(PluginContractModel):
+    principal: MemoryPrincipal
+    scopes: tuple[MemoryScopeName, ...]
+    memory_id: str = Field(min_length=1, max_length=256)
+
+
+class MemoryReceiptRequest(PluginContractModel):
+    principal: MemoryPrincipal
+    operation_key: str = Field(min_length=1, max_length=1024)
+    request_digest: str = Field(pattern=r"^sha256:[0-9a-f]{64}$")
+
+
+class MemoryUserObservation(PluginContractModel):
+    """Host-selected canonical user input; never model-supplied tool arguments."""
+
+    source_event_id: str = Field(min_length=1, max_length=2048)
+    source_session_id: str = Field(min_length=1, max_length=256)
+    content: str = Field(min_length=1, max_length=131072)
+    source_digest: str = Field(pattern=r"^sha256:[0-9a-f]{64}$")
+
+    @model_validator(mode="after")
+    def original_digest(self):
+        if self.source_digest != "sha256:" + hashlib.sha256(self.content.encode()).hexdigest():
+            raise ValueError("Memory observation source digest differs from original content")
+        return self
+
+
+class MemoryMutationRequest(MemoryReceiptRequest):
+    """Host-derived authority and provenance; never a model tool argument schema."""
+
+    action: Literal["remember", "correct", "forget"]
+    scope: MemoryScopeName
+    content: str = Field(default="", max_length=8192)
+    memory_id: str | None = Field(default=None, min_length=1, max_length=256)
+    expected_version: int | None = Field(default=None, strict=True, ge=1)
+    authority: Literal["explicit_user", "approved_call", "candidate"]
+    source_session_id: str = Field(min_length=1)
+    source_event_id: str = Field(min_length=1)
+    source_goal_revision: int = Field(strict=True, ge=0)
+    source_goal_digest: str = Field(pattern=r"^sha256:[0-9a-f]{64}$")
+    # Eligible original inputs at this actual write boundary. The model cannot
+    # choose this horizon; old prose must not undo a confirmed write/forget.
+    source_user_observations: tuple[MemoryUserObservation, ...] = Field(
+        default=(), exclude_if=lambda value: not value,
+    )
+
+    @model_validator(mode="after")
+    def valid_action(self):
+        if self.action == "remember":
+            if self.memory_id is not None or self.expected_version is not None:
+                raise ValueError("new memory must not supply an existing identity")
+        elif self.memory_id is None or self.expected_version is None:
+            raise ValueError("correct/forget require an exact memory_id and observed version")
+        if self.action != "forget" and not self.content.strip():
+            raise ValueError("remember/correct require content")
+        if self.action == "forget" and self.content:
+            raise ValueError("forget must not carry a replacement fact")
+        return self
+
+
+class MemoryFlushRequest(PluginContractModel):
+    principal: MemoryPrincipal
+    trigger: Literal["pre_compaction", "completed_turn"]
+    observations: tuple[MemoryUserObservation, ...]
+
+
+@runtime_checkable
+class MemoryFlushSource(Protocol):
+    async def memory_flush(
+        self, bundle: ResolvedPluginBundle, request: MemoryFlushRequest,
+    ) -> dict: ...
+
+
+@runtime_checkable
+class MemoryRecallSource(Protocol):
+    async def memory_recall(
+        self, bundle: ResolvedPluginBundle, request: MemoryRecallRequest,
+    ) -> MemorySearchResult: ...
+
+
+@runtime_checkable
+class MemorySearchSource(Protocol):
+    """Explicit scoped search, independent of automatic recall's enable switch.
+
+    The same locked recall limits bound candidates and the host's projected
+    result. This API does not grant exhaustive enumeration or a write.
+    """
+
+    async def memory_search(
+        self, bundle: ResolvedPluginBundle, request: MemoryRecallRequest,
+    ) -> MemorySearchResult: ...
+
+
+@runtime_checkable
+class MemoryMutationSource(Protocol):
+    async def memory_read(
+        self, bundle: ResolvedPluginBundle, request: MemoryRecordRequest,
+    ): ...
+
+    async def memory_mutate(
+        self, bundle: ResolvedPluginBundle, request: MemoryMutationRequest,
+    ) -> dict: ...
+
+    async def memory_receipt(
+        self, bundle: ResolvedPluginBundle, request: MemoryReceiptRequest,
+    ) -> dict | None: ...
+
+
+@dataclass(frozen=True)
+class MemoryProviderBinding:
+    plugin_id: str
+    plugin_version: str
+    slot: str
+    runtime: Any
+
+
+def _namespace(values: tuple[str, ...]) -> str:
+    raw = json.dumps(values, ensure_ascii=False, separators=(",", ":"))
+    return hashlib.sha256(raw.encode()).hexdigest()
+
+
+def memory_db_path(state_root: Path, principal: MemoryPrincipal) -> Path:
+    """One tenant database beneath the explicit host state root, never an env path."""
+    return state_root / "memory-v1" / _namespace((principal.tenant_id,)) / "memory.sqlite"
+
+
+def memory_scope_bindings(principal: MemoryPrincipal, scopes: tuple[MemoryScopeName, ...]):
+    """Keep project identity stable; tenant sharing requires an explicit scope.
+
+    The existing storage vocabulary calls tenant-wide records ``org``.
+    User memory retains the SDK's Agent x User partition inside its workspace.
+    """
+    prefix = (principal.tenant_id, principal.workspace_id)
+    identities = {
+        "tenant": ("org", (principal.tenant_id,)),
+        "workspace": ("workspace", prefix),
+        "agent": ("agent", (*prefix, principal.agent_id)),
+        "user": ("user", (*prefix, principal.agent_id, principal.user_id)),
+    }
+    return tuple(
+        (identities[name][0], "native-memory-v1:" + _namespace((name, *identities[name][1])))
+        for name in dict.fromkeys(scopes)
+    )

ksadk/plugins/providers/_process_group.py

@@ -0,0 +1,50 @@
+"""Conservative Linux process-group liveness after a successful killpg probe."""
+
+import os
+from pathlib import Path
+
+
+def linux_group_has_live_members(process_group: int, *, proc_root: Path = Path("/proc")) -> bool:
+    """Ignore only a proven zombie/dead-only group in a complete proc view.
+
+    Linux keeps orphan zombies in their process group until their new parent
+    reaps them. killpg(pgid, 0) still succeeds, although no signal can stop a
+    zombie. Unknown visibility or a racing empty snapshot stays conservative.
+    """
+    try:
+        mounts = (proc_root / "self" / "mountinfo").read_text().splitlines()
+        candidates = [line.split() for line in mounts if line.split()[4] == "/proc"]
+        if len(candidates) != 1:
+            return True  # An overmount can hide members from the older view.
+        proc_mount = candidates[0]
+        separator = proc_mount.index("-")
+        if proc_mount[separator + 1] != "proc":
+            return True
+        options = (proc_mount[5] + "," + proc_mount[separator + 3]).split(",")
+        if any(option.startswith("hidepid=") and option != "hidepid=0" for option in options):
+            return True
+        own = (proc_root / "self" / "stat").read_text()
+        own_fields = own.rsplit(")", 1)[1].split()
+        if int(own.split(" ", 1)[0]) != os.getpid() or int(own_fields[2]) != os.getpgrp():
+            return True  # An ancestor PID namespace can use different IDs.
+        status = (proc_root / "self" / "status").read_text().splitlines()
+        namespace_pids = next(line for line in status if line.startswith("NSpid:")).split()[1:]
+        if namespace_pids != [str(os.getpid())]:
+            return True  # Matching numbers alone cannot prove namespace identity.
+        matched = False
+        for entry in proc_root.iterdir():
+            if not entry.name.isdecimal():
+                continue
+            try:
+                # comm is parenthesized and can contain spaces and ')'.
+                stat = (entry / "stat").read_text().rsplit(")", 1)[1].split()
+                group = int(stat[2])
+            except FileNotFoundError:
+                continue  # This process was reaped during the snapshot.
+            if group == process_group:
+                matched = True
+                if stat[0] not in {"Z", "X", "x"}:
+                    return True
+        return not matched
+    except (OSError, ValueError, IndexError, StopIteration):
+        return True

ksadk/plugins/providers/bundles/dsh-channels-client/client.js

@@ -0,0 +1,19 @@
+window.__ModuleLoader__.load({
+  id: '@kingsoftcloud/dsh-channels-client',
+  factory: require => {
+    const { createElement, useEffect, useRef, useState } = require('react');
+    function ChannelsWorkspace(props) {
+      const container = useRef(null);
+      const [error, setError] = useState('');
+      useEffect(() => {
+        let disposed = false, detach;
+        const mount = window.__STUDIO_APP__?.mountWorkspace;
+        if (!mount) { setError('Studio 消息渠道组件不可用'); return; }
+        Promise.resolve(mount('channels', container.current, props)).then(v => { if (disposed) v?.(); else detach = v; }).catch(() => setError('消息渠道页面加载失败'));
+        return () => { disposed = true; detach?.(); };
+      }, []);
+      return createElement('div', { ref: container, style: { height: '100%', minHeight: 0 } }, error ? createElement('p', { role: 'alert' }, error) : null);
+    }
+    return { name: 'dsh-channels-client', inject: ['slots'], apply(ctx) { ctx.slots.inject('studio.workspace.page', () => ctx.slots.register({ name: 'studio.workspace.page', id: 'channels', label: '消息渠道', order: 45 }, ChannelsWorkspace)); } };
+  },
+});

ksadk/plugins/providers/bundles/dsh-channels-client/cordis.patch.yml

@@ -0,0 +1,3 @@
+- insert:
+    - id: dsh-channels-client
+      name: '@kingsoftcloud/dsh-channels-client'

ksadk/plugins/providers/bundles/dsh-channels-client/index.mjs

@@ -0,0 +1,7 @@
+// Browser-only contribution; Core loads client.js through the DSH client
+// extension contract and does not need a server-side Cordis service.
+export const name = 'dsh-channels-client'
+
+// DSH still expects every server-side bundle entrypoint to expose apply;
+// the actual workspace contribution is registered by client.js.
+export function apply() {}

ksadk/plugins/providers/bundles/dsh-channels-client/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@kingsoftcloud/dsh-channels-client",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "description": "Channels client Cordis companion contribution",
+  "exports": { ".": "./index.mjs", "./cordis.patch.yml": "./cordis.patch.yml", "./client": "./client.js" },
+  "files": ["index.mjs", "cordis.patch.yml", "client.js"],
+  "engines": { "node": ">=22.19.0" },
+  "peerDependencies": { "@deepseek-ai/cordis": "^4.0.1" },
+  "dsh": { "bundle": { "patch": "./cordis.patch.yml" }, "client": { "inject": ["@kingsoftcloud/dsh-app-studio"], "platform": "web" } }
+}

ksadk/plugins/providers/bundles/dsh-knowledge/index.mjs

@@ -1,6 +1,18 @@
 export const name = 'dsh-knowledge'
 export const inject = ['tools', 'platformResources']
 
+// The platform retrieval service may prefix a chunk with its internal object
+// storage key (for example ``upload_files/<numeric-id>/<uuid>.md,``).  That
+// value is neither useful evidence nor safe user-facing content.  Long numeric
+// object keys also look like payment-card numbers to the Harness DLP policy,
+// which forces an otherwise harmless knowledge result into an unreadable
+// sensitive artifact.  Strip only this well-known transport prefix and retain
+// the document title and every byte of authored content that follows it.
+export function sanitizeKnowledgeContent(value) {
+  if (typeof value !== 'string') return value
+  return value.replace(/^upload_files\/[^,\r\n]+,/, '')
+}
+
 export function apply(ctx) {
   ctx.effect(() => ctx.platformResources.registerTool('search_knowledge_base', 'search_knowledge_base'))
   ctx.tools.register({
@@ -46,8 +58,18 @@ export function apply(ctx) {
       },
     },
     isConcurrencySafe: () => true,
-    execute(args, execution) {
-      return ctx.platformResources.call('search_knowledge_base', args, { signal: execution.signal })
+    async execute(args, execution) {
+      const result = await ctx.platformResources.call(
+        'search_knowledge_base', args, { signal: execution.signal },
+      )
+      if (!result || !Array.isArray(result.items)) return result
+      return {
+        ...result,
+        items: result.items.map(item => ({
+          ...item,
+          content: sanitizeKnowledgeContent(item.content),
+        })),
+      }
     },
   })
 }

ksadk/plugins/providers/bundles/dsh-knowledge/package.json

@@ -9,7 +9,7 @@
   "engines": {"node": ">=22.19.0"},
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-tools": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-tools": "0.1.7-rc.1",
     "@kingsoftcloud/dsh-platform-resources": "0.1.0"
   },
   "dsh": {"bundle": {"patch": "./cordis.patch.yml"}}

ksadk/plugins/providers/bundles/dsh-memory/package.json

@@ -9,7 +9,7 @@
   "engines": {"node": ">=22.19.0"},
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-tools": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-tools": "0.1.7-rc.1",
     "@kingsoftcloud/dsh-platform-resources": "0.1.0"
   },
   "dsh": {"bundle": {"patch": "./cordis.patch.yml"}}

ksadk/plugins/providers/bundles/dsh-skill-center/package.json

@@ -9,7 +9,7 @@
   "engines": {"node": ">=22.19.0"},
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-tools": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-tools": "0.1.7-rc.1",
     "@kingsoftcloud/dsh-platform-resources": "0.1.0"
   },
   "dsh": {"bundle": {"patch": "./cordis.patch.yml"}}

ksadk/plugins/providers/bundles/dsh-teams-client/client.js

@@ -0,0 +1,29 @@
+window.__ModuleLoader__.load({
+  id: '@kingsoftcloud/dsh-teams-client',
+  factory: require => {
+    const { createElement, useEffect, useRef, useState } = require('react');
+    function TeamsWorkspace(props) {
+      const container = useRef(null);
+      const [error, setError] = useState('');
+      useEffect(() => {
+        let disposed = false, detach;
+        const mount = window.__STUDIO_APP__?.mountWorkspace;
+        if (!mount) { setError('Studio 团队组件不可用'); return; }
+        Promise.resolve(mount('teams', container.current, props)).then(value => {
+          if (disposed) value?.(); else detach = value;
+        }).catch(() => setError('团队页面加载失败'));
+        return () => { disposed = true; detach?.(); };
+      }, []);
+      return createElement('div', { ref: container, style: { height: '100%', minHeight: 0 } },
+        error ? createElement('p', { role: 'alert' }, error) : null);
+    }
+    return {
+      name: 'dsh-teams-client', inject: ['slots'],
+      apply(ctx) {
+        ctx.slots.inject('studio.workspace.page', () => ctx.slots.register({
+          name: 'studio.workspace.page', id: 'teams', label: '团队', order: 40,
+        }, TeamsWorkspace));
+      },
+    };
+  },
+});

ksadk/plugins/providers/bundles/dsh-teams-client/cordis.patch.yml

@@ -0,0 +1,3 @@
+- insert:
+    - id: dsh-teams-client
+      name: '@kingsoftcloud/dsh-teams-client'