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

ksadk/memory/store_adapter.py

@@ -0,0 +1,150 @@
+"""LangGraph Store → MemoryProvider 适配层（长任务方案 §7.6 / P3）。
+
+LangGraph ``BaseStore`` 语义映射到 KsADK MemoryProvider Protocol：
+
+- namespace = ``(tenant_id, workspace_id, scope, scope_id)``（作用域隔离）；
+- key = ``memory_id``；
+- value = MemoryRecord ``to_payload`` 形态的 dict（KsADK 公共协议，
+  Store 不感知 Harness 类型）。
+
+KsADK ``MemoryRecord`` 和权限语义始终是公共协议；更换 Backend 不改变
+HarnessSpec 与 RuntimeEvent（方案 §10 P3 验收）。
+
+Store API 是 async（``aput/aget/asearch/adelete``）；本适配器在同步
+Protocol 方法内用 :func:`asyncio.run` 驱动（事件循环已运行时抛明确错误，
+调用方应改走异步通道或独立线程）。
+"""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from dataclasses import asdict
+from typing import Any
+
+from ksadk.memory.models import (
+    CoreMemoryRequest,
+    MemoryCapabilities,
+    MemoryDeleteRequest,
+    MemoryDeleteResult,
+    MemoryRecord,
+    MemorySearchRequest,
+    MemorySearchResult,
+)
+
+
+def _run(coro: Any) -> Any:
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.run(coro)
+    raise RuntimeError(
+        "LangGraphStoreAdapter 的同步方法不能在事件循环内调用"
+        "（请在线程/进程边界使用，或经 MemoryCoordinator 异步通道）"
+    )
+
+
+class LangGraphStoreAdapter:
+    """把 LangGraph ``BaseStore`` 适配为 MemoryProvider Protocol。"""
+
+    capabilities_def = MemoryCapabilities(
+        semantic_search=True,  # Store 按 value 匹配语义（视实现而定）
+        keyword_search=False,
+        metadata_filter=True,
+        versioned_update=False,
+        hard_delete=True,
+        ttl=False,
+        max_record_chars=8192,
+    )
+
+    def __init__(self, store: Any, *, tenant_id: str = "local") -> None:
+        self._store = store
+        self._tenant_id = tenant_id
+
+    # ---- namespace 映射 ----
+
+    def _ns(self, scope: str, scope_id: str) -> tuple[str, ...]:
+        return (self._tenant_id, "store", scope, scope_id)
+
+    # ---- MemoryProvider Protocol ----
+
+    def capabilities(self) -> MemoryCapabilities:
+        return self.capabilities_def
+
+    async def _aget(self, memory_id: str, ns: tuple[str, ...]) -> MemoryRecord | None:
+        item = await self._store.aget(ns, memory_id)
+        return MemoryRecord(**item.value) if item else None
+
+    def get(self, memory_id: str) -> MemoryRecord | None:
+        # Store get 需要 namespace；扫描本适配器管理的 scope 前缀不现实，
+        # 调用方（Coordinator）经 search 定位。此处按最近一次 search 缓存解析。
+        raise NotImplementedError("请经 search(memory_id 过滤) 定位记录")
+
+    async def search_async(
+        self, request: MemorySearchRequest
+    ) -> MemorySearchResult:
+        start = time.monotonic()
+        records: list[MemoryRecord] = []
+        for scope, scope_id in request.scopes:
+            items = await self._store.asearch(
+                self._ns(scope, scope_id), query=request.query or None,
+                limit=request.top_k,
+            )
+            for item in items:
+                try:
+                    records.append(MemoryRecord(**dict(item.value)))
+                except TypeError:
+                    continue
+        return MemorySearchResult(
+            status="ok",
+            records=records[: request.top_k],
+            error_code=None,
+            provider="langgraph-store",
+            latency_ms=int((time.monotonic() - start) * 1000),
+            accounting_accuracy="estimated",
+        )
+
+    def search(self, request: MemorySearchRequest) -> MemorySearchResult:
+        return _run(self.search_async(request))
+
+    async def upsert_async(
+        self, record: MemoryRecord, *, expected_version: int | None
+    ) -> MemoryRecord:
+        if expected_version is not None:
+            existing = await self._aget(record.memory_id, self._ns(record.scope, record.scope_id))
+            if existing is not None and existing.version != expected_version:
+                raise RuntimeError(
+                    f"version_conflict:expected={expected_version},"
+                    f"actual={existing.version}"
+                )
+        payload = asdict(record)
+        payload["source_artifact_refs"] = list(record.source_artifact_refs)
+        payload["source_artifacts"] = [asdict(item) for item in record.source_artifacts]
+        payload["supersedes"] = list(record.supersedes)
+        await self._store.aput(self._ns(record.scope, record.scope_id), record.memory_id, payload)
+        return record
+
+    def upsert(self, record: MemoryRecord, *, expected_version: int | None) -> MemoryRecord:
+        return _run(self.upsert_async(record, expected_version=expected_version))
+
+    async def delete_async(self, request: MemoryDeleteRequest) -> MemoryDeleteResult:
+        ns = self._ns(request.scope, request.scope_id)
+        existing = await self._aget(request.memory_id, ns)
+        if existing is None:
+            return MemoryDeleteResult(status="ok", deleted=False, error_code="not_found")
+        if request.hard:
+            await self._store.adelete(ns, request.memory_id)
+        else:
+            deleted = {**asdict(existing), "status": "deleted"}
+            await self._store.aput(ns, request.memory_id, deleted)
+        return MemoryDeleteResult(status="ok", deleted=True, error_code=None)
+
+    def delete(self, request: MemoryDeleteRequest) -> MemoryDeleteResult:
+        return _run(self.delete_async(request))
+
+    def list_core(self, request: CoreMemoryRequest) -> list[MemoryRecord]:
+        # Store 无常驻 Block 概念；Core Memory 交由 Coordinator 预算层。
+        return []
+
+
+__all__ = ["LangGraphStoreAdapter"]

ksadk/model_policy.py

@@ -7,8 +7,8 @@ from typing import Any, Mapping
 
 from ksadk.configs.settings import DEFAULT_MODEL_NAME
 
-DEFAULT_MULTIMODAL_MODEL = "kimi-k2.7-code"
-DEFAULT_FALLBACK_MODEL = "deepseek-v4-pro"
+DEFAULT_MULTIMODAL_MODEL = "deepseek-v4.1-flash"
+DEFAULT_FALLBACK_MODEL = "glm-5.3-flash"
 
 DEFAULT_MODEL_POLICY: dict[str, Any] = {
     "version": "v1",

ksadk/model_proxy/detect.py

@@ -44,6 +44,16 @@ class ModelCapabilities:
     preferred_protocol: str = "chat"  # "responses" | "chat":路由该走哪条
     checked_at: float = 0.0
     verdict: Verdict = "unknown"  # 最近一次探测结论
+    # --- 以下为 opt-in 贵探测,默认 None(未探),由 probe_extended_capability 按需填充 ---
+    # store/previous_response_id 服务端会话链是否真生效(2026-09 实测 deepseek 系
+    # 返回 200 但静默丢历史=假支持)。False 时客户端必须每次带全量历史。
+    store_supported: bool | None = None
+    # 该模型 reasoning_effort 的合法值集合(2026-09 实测 glm-5.3-flash 只认
+    # low/high/max,medium/none/xhigh 全 400;且不能按 family 前缀推断,逐模型实测)。
+    reasoning_effort_values: frozenset[str] | None = None
+    # 非流式响应里 reasoning item 是否稳定出现(2026-09 实测 glm-5.3-flash
+    # 同 effort 下约半数响应只有 message 没有 reasoning item;流式不受影响)。
+    reasoning_item_reliable: bool | None = None
 
 
 def _classify_responses_error(status: int, body: str) -> Verdict:
@@ -336,3 +346,247 @@ def _finalize(caps: ModelCapabilities) -> ModelCapabilities:
         # 因为转换层对 chat 模型是确定可用的,而直连 responses 在 unknown 下有风险
         caps.preferred_protocol = "chat"
     return caps
+
+
+# ---------------------------------------------------------------------------
+# Opt-in 贵探测:store 会话链 / reasoning_effort 值域 / reasoning item 可靠性
+# 这三个探测各需多次真实请求,默认不并入 probe_responses_capability,由调用方按需触发。
+# 全部遵循同一铁律:只在确凿证据下置 True/False,故障/超时/不确定一律留 None(未探)。
+# ---------------------------------------------------------------------------
+
+# reasoning_effort 候选值,覆盖 OpenAI/Codex 主流档 + glm 的 max。
+_EFFORT_CANDIDATES = ("none", "minimal", "low", "medium", "high", "xhigh", "max")
+
+
+def probe_extended_capability(
+    client: httpx.Client | httpx.AsyncClient,
+    base: str,
+    key: str,
+    model: str,
+    timeout: float = 60.0,
+):
+    """按需探测 store/reasoning 三项能力,返回填充了对应字段的 ModelCapabilities。
+
+    - ``store_supported``: store=true 拿 response_id,再用 previous_response_id
+      追问一个只有上一轮才知道的事实;答出=真支持,答不出=假支持(静默丢历史)。
+    - ``reasoning_effort_values``: 逐个候选值发最小请求,200=接受,400=拒绝;
+      其余(超时/5xx)不计入(故障≠值域缺失)。
+    - ``reasoning_item_reliable``: 非流式带 reasoning 请求,检查 output 是否含
+      reasoning item。单次缺席不足以判 False(可能模型本来没想),需 N 次全缺席才判。
+
+    按 client 类型分发:sync 返回 ModelCapabilities,async 返回 coroutine。
+    """
+    if isinstance(client, httpx.AsyncClient):
+        return _probe_extended_async(client, base, key, model, timeout)
+    if isinstance(client, httpx.Client):
+        return _probe_extended_sync(client, base, key, model, timeout)
+    raise TypeError(f"client 必须是 httpx.Client/AsyncClient,不是 {type(client).__name__}")
+
+
+def _reasoning_item_present(data: Any) -> bool:
+    if not isinstance(data, dict):
+        return False
+    return any(
+        isinstance(item, dict) and item.get("type") == "reasoning"
+        for item in data.get("output", [])
+    )
+
+
+def _post_json(client, url, payload, headers, timeout):
+    """统一 sync post + json 解析;返回 (status, data) 或 None(故障)。"""
+    try:
+        r = client.post(url, json=payload, headers=headers, timeout=timeout)
+    except (httpx.TimeoutException, httpx.ConnectError, httpx.HTTPError):
+        return None
+    try:
+        return r.status_code, r.json()
+    except ValueError:
+        return r.status_code, None
+
+
+async def _post_json_async(client, url, payload, headers, timeout):
+    try:
+        r = await client.post(url, json=payload, headers=headers, timeout=timeout)
+    except (httpx.TimeoutException, httpx.ConnectError, httpx.HTTPError):
+        return None
+    try:
+        return r.status_code, r.json()
+    except ValueError:
+        return r.status_code, None
+
+
+def _store_first_payload(model: str, marker: str) -> dict:
+    return {
+        "model": model,
+        "input": f"记住代号 {marker},只回 OK",
+        "max_output_tokens": 200,
+        "store": True,
+    }
+
+
+def _probe_store_sync(client, url, headers, model, timeout):
+    marker = "cobalt-9173"
+    first = _post_json(client, url, _store_first_payload(model, marker), headers, timeout)
+    if not first or first[0] != 200 or not isinstance(first[1], dict):
+        return None
+    rid = first[1].get("id")
+    if not rid:
+        return None
+    second = _post_json(
+        client,
+        url,
+        {"model": model, "input": "我刚才让你记的代号是什么?只回答代号",
+         "max_output_tokens": 200, "previous_response_id": rid},
+        headers,
+        timeout,
+    )
+    if not second or second[0] != 200 or not isinstance(second[1], dict):
+        return None
+    text = "".join(
+        c.get("text", "")
+        for item in second[1].get("output", [])
+        if isinstance(item, dict) and item.get("type") == "message"
+        for c in item.get("content", [])
+        if isinstance(c, dict)
+    )
+    return marker in text
+
+
+async def _probe_store_async(client, url, headers, model, timeout):
+    marker = "cobalt-9173"
+    first = await _post_json_async(
+        client, url, _store_first_payload(model, marker), headers, timeout
+    )
+    if not first or first[0] != 200 or not isinstance(first[1], dict):
+        return None
+    rid = first[1].get("id")
+    if not rid:
+        return None
+    second = await _post_json_async(
+        client,
+        url,
+        {"model": model, "input": "我刚才让你记的代号是什么?只回答代号",
+         "max_output_tokens": 200, "previous_response_id": rid},
+        headers,
+        timeout,
+    )
+    if not second or second[0] != 200 or not isinstance(second[1], dict):
+        return None
+    text = "".join(
+        c.get("text", "")
+        for item in second[1].get("output", [])
+        if isinstance(item, dict) and item.get("type") == "message"
+        for c in item.get("content", [])
+        if isinstance(c, dict)
+    )
+    return marker in text
+
+
+def _probe_effort_values_sync(client, url, headers, model, timeout):
+    accepted = set()
+    saw_any = False
+    for eff in _EFFORT_CANDIDATES:
+        res = _post_json(
+            client,
+            url,
+            {"model": model, "input": "hi", "max_output_tokens": 30,
+             "reasoning": {"effort": eff}},
+            headers,
+            timeout,
+        )
+        if res is None:
+            continue  # 故障,不计入
+        status, _ = res
+        saw_any = True
+        if status == 200:
+            accepted.add(eff)
+        # 400 = 明确拒绝该值,不计入 accepted
+    return frozenset(accepted) if saw_any else None
+
+
+async def _probe_effort_values_async(client, url, headers, model, timeout):
+    accepted = set()
+    saw_any = False
+    for eff in _EFFORT_CANDIDATES:
+        res = await _post_json_async(
+            client,
+            url,
+            {"model": model, "input": "hi", "max_output_tokens": 30,
+             "reasoning": {"effort": eff}},
+            headers,
+            timeout,
+        )
+        if res is None:
+            continue
+        status, _ = res
+        saw_any = True
+        if status == 200:
+            accepted.add(eff)
+    return frozenset(accepted) if saw_any else None
+
+
+def _probe_reasoning_reliable_sync(client, url, headers, model, timeout, trials=3):
+    """N 次非流式全缺席 reasoning item 才判 False;任一故障或出现就留 None/True。"""
+    absences = 0
+    for _ in range(trials):
+        res = _post_json(
+            client,
+            url,
+            {"model": model, "input": "9.11 和 9.9 哪个大?", "max_output_tokens": 600,
+             "reasoning": {"effort": "low"}},
+            headers,
+            timeout,
+        )
+        if res is None or res[0] != 200:
+            return None  # 故障,无法判定
+        if _reasoning_item_present(res[1]):
+            return True
+        absences += 1
+    return False if absences == trials else None
+
+
+async def _probe_reasoning_reliable_async(client, url, headers, model, timeout, trials=3):
+    absences = 0
+    for _ in range(trials):
+        res = await _post_json_async(
+            client,
+            url,
+            {"model": model, "input": "9.11 和 9.9 哪个大?", "max_output_tokens": 600,
+             "reasoning": {"effort": "low"}},
+            headers,
+            timeout,
+        )
+        if res is None or res[0] != 200:
+            return None
+        if _reasoning_item_present(res[1]):
+            return True
+        absences += 1
+    return False if absences == trials else None
+
+
+def _probe_extended_sync(client, base, key, model, timeout) -> ModelCapabilities:
+    caps = ModelCapabilities(checked_at=time.time(), verdict="unknown")
+    url = f"{base.rstrip('/')}/responses"
+    headers = {"Authorization": f"Bearer {key}", "Content-Type": "application/json"}
+    caps.store_supported = _probe_store_sync(client, url, headers, model, timeout)
+    caps.reasoning_effort_values = _probe_effort_values_sync(
+        client, url, headers, model, timeout
+    )
+    caps.reasoning_item_reliable = _probe_reasoning_reliable_sync(
+        client, url, headers, model, timeout
+    )
+    return caps
+
+
+async def _probe_extended_async(client, base, key, model, timeout) -> ModelCapabilities:
+    caps = ModelCapabilities(checked_at=time.time(), verdict="unknown")
+    url = f"{base.rstrip('/')}/responses"
+    headers = {"Authorization": f"Bearer {key}", "Content-Type": "application/json"}
+    caps.store_supported = await _probe_store_async(client, url, headers, model, timeout)
+    caps.reasoning_effort_values = await _probe_effort_values_async(
+        client, url, headers, model, timeout
+    )
+    caps.reasoning_item_reliable = await _probe_reasoning_reliable_async(
+        client, url, headers, model, timeout
+    )
+    return caps

ksadk/model_proxy/server.py

@@ -248,9 +248,10 @@ def create_app(config: ProxyConfig) -> FastAPI:
 async def _chat_passthrough_stream(config: ProxyConfig, base: str, headers: dict, body: dict):
     """chat SSE 字节级透传(不转换),让前缀缓存/流式格式与直连一致。"""
     try:
+        stream_headers = {**headers, "Accept": "text/event-stream"}
         async with httpx.AsyncClient(timeout=config.timeout) as c:
             async with c.stream(
-                "POST", f"{base}/chat/completions", json=body, headers=headers
+                "POST", f"{base}/chat/completions", json=body, headers=stream_headers
             ) as r:
                 async for line in r.aiter_lines():
                     yield line + "\n"
@@ -275,10 +276,11 @@ async def _stream_gen(
     for e in s.start():
         yield e
     try:
+        stream_headers = {**headers, "Accept": "text/event-stream"}
         # 超时必须有界(config.timeout):无限超时的活动 SSE 会让 stop() 后线程仍存活
         async with httpx.AsyncClient(timeout=config.timeout) as c:
             async with c.stream(
-                "POST", f"{base}/chat/completions", json=chat_req, headers=headers
+                "POST", f"{base}/chat/completions", json=chat_req, headers=stream_headers
             ) as r:
                 config.emit(
                     "proxy.upstream",

ksadk/model_proxy/transform.py

@@ -234,13 +234,51 @@ _EFFORT_CAP_PREFIXES = (
     ("qwen3.5", "high"),
 )
 
+# 各上游模型的 reasoning_effort 合法值集合(2026-09 实测,见 tests/model_proxy)。
+# 与 _EFFORT_CAP_PREFIXES 的区别:cap 是"单调钳顶"(qwen 超 cap 钳到 cap);
+# 这里是"值域裁剪"——glm-5.3-flash 是始终思考模型,合法值只有 low/high/max,
+# none/minimal/medium/xhigh 全部 400,无法用单调钳顶表达。
+_EFFORT_ALLOWED_SETS = {
+    "glm-5.3-flash": ("low", "high", "max"),
+}
+# 值域裁剪用的档位表:max 视为与 xhigh 同级(5),仅在值域裁剪内部使用,
+# 不改 _EFFORT_RANK(影响 cap 路径)。
+_ALLOWED_RANK = {**_EFFORT_RANK, "max": 5}
+
+
+def remap_reasoning_effort(model, effort):
+    """把 reasoning_effort 向上取整到该模型的合法值集合(值域裁剪)。
+
+    规则:档位 >= 入参的最近合法档;无更高档则取集合最高档;未知档位取集合最低档。
+    未列出的模型/非字符串原样返回(不做发明式映射)。
+
+    实测:glm-5.3-flash 始终思考,medium/xhigh/none/minimal 全 400,
+    medium→high、xhigh→max、none/minimal→low。
+    """
+    if not isinstance(model, str) or not isinstance(effort, str):
+        return effort
+    allowed = None
+    for prefix, vals in _EFFORT_ALLOWED_SETS.items():
+        if model.startswith(prefix):
+            allowed = vals
+            break
+    if not allowed or effort in allowed:
+        return effort
+    r = _ALLOWED_RANK.get(effort)
+    if r is None:
+        return allowed[0]
+    higher = [v for v in allowed if _ALLOWED_RANK[v] >= r]
+    return higher[0] if higher else allowed[-1]
+
 
 def clamp_reasoning_effort(model, effort):
-    """把超出上游模型族支持上限的 reasoning_effort 钳到最高合法档。
+    """把 reasoning_effort 适配到上游模型:先做值域裁剪,再做上限钳制。
 
-    codex 对自家模型默认发 xhigh;qwen3.7 系上游 400,需钳到 high。
+    值域裁剪(remap_reasoning_effort)处理非单调值域(如 glm-5.3-flash 只认
+    low/high/max);上限钳制处理单调超 cap(如 qwen3.7 xhigh→high)。
     未知档位/未知模型族原样返回(不做发明式映射)。
     """
+    effort = remap_reasoning_effort(model, effort)
     if not isinstance(effort, str) or effort not in _EFFORT_RANK:
         return effort
     for prefix, cap in _EFFORT_CAP_PREFIXES:

ksadk/plugins/__init__.py

@@ -1,4 +1,4 @@
-"""Versioned contracts for the Phase 2 plugin composition boundary.
+"""Versioned contracts for the Release plugin composition boundary.
 
 This package models discovery, deterministic locking, and the controlled
 PluginHost lifecycle.  It does not create a second runtime/event store;

ksadk/plugins/bridges/dsh.py

@@ -998,6 +998,17 @@ class DshProfilePluginBridge:
     def _prepare_source(self, source: str) -> _PreparedSource:
         value = source.strip()
         candidate = Path(value).expanduser()
+        if not candidate.is_absolute():
+            # dsh CLI 以 Profile 目录为 cwd 解析 add 的源参数；相对当前工作目录
+            # 存在的本地源必须先绝对化，否则会被写成指向不存在位置的 link: 依赖。
+            workspace_relative = self._cwd / candidate
+            if workspace_relative.exists():
+                candidate = workspace_relative
+            elif value.endswith(".tgz"):
+                raise DshPluginMutationError(
+                    f"local DSH plugin source does not exist: {value} "
+                    f"(resolved against {self._cwd})"
+                )
         if not candidate.is_absolute() or not candidate.exists():
             return _PreparedSource(value, "", "tgz", "")
         local = candidate.resolve()

ksadk/plugins/builtins.py

@@ -36,6 +36,7 @@ SQLITE_SESSION_STORE_PLUGIN_ID = "io.ksadk.session-store.sqlite"
 WORKSPACE_MCP_PLUGIN_ID = "io.ksadk.mcp.workspace"
 WORKSPACE_SKILL_PLUGIN_ID = "io.ksadk.skill.workspace"
 READ_ONLY_CONTEXT_PLUGIN_ID = "io.ksadk.context.bundle-readonly"
+LOCAL_MEMORY_PROVIDER_PLUGIN_ID = "io.ksadk.memory.local-default"
 CORE_RENDERER_PLUGIN_ID = "io.ksadk.renderer.conversation-core"
 
 SecretResolver = Callable[[str], str | None]
@@ -86,7 +87,7 @@ def _manifest(
 
 
 def builtin_capability_manifests() -> tuple[PluginManifest, ...]:
-    """Return the exact, deterministic Phase 2 built-in capability catalog."""
+    """Return the exact, deterministic Release built-in capability catalog."""
 
     return (
         _manifest(
@@ -118,6 +119,12 @@ def builtin_capability_manifests() -> tuple[PluginManifest, ...]:
             mode="multiple",
             permissions=("filesystem:bundle-read",),
         ),
+        _manifest(
+            LOCAL_MEMORY_PROVIDER_PLUGIN_ID,
+            definition="memory.provider/v1",
+            slot="memory.primary",
+            mode="unique",
+        ),
         _manifest(
             CORE_RENDERER_PLUGIN_ID,
             definition="session.item.renderer/v1",
@@ -275,6 +282,27 @@ class WorkspaceMCPRuntime(_BuiltinRuntime):
                 resolved, "endpointUrl", code="builtin_mcp_endpoint_missing"
             )
             secret_ref = _optional_string(materializer.get("apiKeyRef"))
+            if secret_ref is None:
+                # 组合器只透传 binding.config；目录资源的凭据声明在合同
+                # envRefs 里（例如 Authorization: env://<API_KEY>）。
+                # materializer 未显式覆盖时回退读取资源自身 envRefs，
+                # 否则 http MCP 少鉴权头必然 401 transport_failed。
+                env_refs = resolved.get("envRefs")
+                if isinstance(env_refs, Mapping) and env_refs:
+                    if len(env_refs) > 1:
+                        raise PluginHostError(
+                            "builtin_mcp_credentials_unsupported",
+                            f"workspace MCP {resolved['name']!r} accepts at most "
+                            "one Authorization credential",
+                        )
+                    header_name, reference = next(iter(env_refs.items()))
+                    if str(header_name).strip().casefold() != "authorization":
+                        raise PluginHostError(
+                            "builtin_mcp_credentials_unsupported",
+                            f"workspace MCP {resolved['name']!r} envRefs header "
+                            f"{header_name!r} is not supported; use Authorization",
+                        )
+                    secret_ref = str(reference).strip()
             api_key: str | None = None
             if secret_ref is not None:
                 if not _is_secret_reference(secret_ref):
@@ -356,7 +384,13 @@ class WorkspaceSkillRuntime(_BuiltinRuntime):
             instructions = _required_string(
                 item, "instructions", code="builtin_skill_instructions_missing"
             )
-            contributions.append(HarnessSkillContribution(name=name, instructions=instructions))
+            contributions.append(
+                HarnessSkillContribution(
+                    name=name,
+                    instructions=instructions,
+                    resource_root=directory,
+                )
+            )
         if not contributions:
             raise PluginHostError(
                 "builtin_skill_resource_missing", "workspace Skill has no locked resource"
@@ -537,6 +571,9 @@ def builtin_capability_factories(
         READ_ONLY_CONTEXT_PLUGIN_ID: _SimpleFactory(
             READ_ONLY_CONTEXT_PLUGIN_ID, ReadOnlyBundleContextRuntime
         ),
+        LOCAL_MEMORY_PROVIDER_PLUGIN_ID: _SimpleFactory(
+            LOCAL_MEMORY_PROVIDER_PLUGIN_ID, _BuiltinRuntime
+        ),
         CORE_RENDERER_PLUGIN_ID: _SimpleFactory(
             CORE_RENDERER_PLUGIN_ID, CoreConversationRendererRuntime
         ),
@@ -730,6 +767,7 @@ def _is_secret_reference(value: str) -> bool:
 __all__ = [
     "BUILTIN_PLUGIN_VERSION",
     "CORE_RENDERER_PLUGIN_ID",
+    "LOCAL_MEMORY_PROVIDER_PLUGIN_ID",
     "READ_ONLY_CONTEXT_PLUGIN_ID",
     "SQLITE_SESSION_STORE_PLUGIN_ID",
     "WORKSPACE_MCP_PLUGIN_ID",