agentengine-sdk-python 0.8.1__py3-none-any.whl → 0.8.2__py3-none-any.whl

ksadk/studio/static/index.html

@@ -4,10 +4,10 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>AgentKit Studio</title>
-    <script type="module" crossorigin src="/static/assets/index-DI2eY_NH.js"></script>
+    <script type="module" crossorigin src="/static/assets/index-CYekR2Xv.js"></script>
     <link rel="modulepreload" crossorigin href="/static/assets/rolldown-runtime-hePW80VL.js">
     <link rel="modulepreload" crossorigin href="/static/assets/react-vendor-BNmTiJ-I.js">
-    <link rel="stylesheet" crossorigin href="/static/assets/index-CaEN0eTR.css">
+    <link rel="stylesheet" crossorigin href="/static/assets/index-BLpcdrgW.css">
   </head>
   <body>
     <div id="root"></div>

ksadk/studio/templates.py

@@ -2,11 +2,13 @@
 
 from __future__ import annotations
 
+import re
 from collections.abc import Iterable
 
 import yaml  # type: ignore[import-untyped]
 
 from ksadk.studio.contracts import (
+    AgentBehaviorDesign,
     AgentBindings,
     AgentSpec,
     AgentTemplateComposeRequest,
@@ -26,6 +28,87 @@ from ksadk.studio.workspace import Workspace
 RESEARCH_SKILL_NAME = "deep-research-methodology"
 RESEARCH_SKILL_VERSION = "1.0.0"
 
+
+def _explicit_boundaries(goal: str) -> list[str]:
+    clauses = [item.strip() for item in re.split(r"[。；;\n]+", goal) if item.strip()]
+    boundary_markers = (
+        "必须",
+        "不得",
+        "不要",
+        "禁止",
+        "仅限",
+        "只能",
+        "确认",
+        "审批",
+        "敏感",
+        "隐私",
+    )
+    return [
+        clause
+        for clause in clauses
+        if any(marker in clause for marker in boundary_markers)
+    ][:4]
+
+
+def _blank_behavior_design(goal: str, policy_template: str) -> AgentBehaviorDesign:
+    primary_goal = next(
+        (item.strip() for item in re.split(r"[。；;\n]+", goal) if item.strip()),
+        goal,
+    )
+    explicit = _explicit_boundaries(goal)
+    safety = list(explicit)
+    policy_boundary = (
+        "执行外部写入、生产变更或其他高风险操作前，说明影响并取得用户确认。"
+        if policy_template == "strict"
+        else "调用工具和外部服务时遵守当前权限策略，不宣称未实际完成的操作。"
+    )
+    if policy_boundary not in safety:
+        safety.append(policy_boundary)
+    return AgentBehaviorDesign(
+        role=f"以“{primary_goal[:80]}”为核心职责的智能助手",
+        objective=goal,
+        operating_principles=[
+            "优先理解当前目标、已知事实和成功标准，不把假设表述为事实。",
+            "信息不足或存在关键歧义时，先提出最少必要问题。",
+            "只在确有需要时调用已绑定能力，并检查工具输入与返回结果。",
+        ],
+        workflow=[
+            "识别本次请求、约束条件和期望结果",
+            "检查信息是否充分并澄清关键缺口",
+            "制定并执行必要步骤，使用可用 Tool、MCP 或 Skill",
+            "核对结果、说明限制并按约定结构交付",
+        ],
+        explicit_boundaries=explicit,
+        safety_boundaries=safety,
+        output_expectations=[
+            "回答准确、清晰、可执行，并区分事实、判断和建议。",
+            "涉及风险、假设或未完成事项时明确说明，不伪造执行结果。",
+        ],
+        source_notes=[
+            "用户输入：核心目标和明确提出的边界",
+            "模板补充：通用执行流程、澄清原则和交付要求",
+            "平台策略：工具权限与高风险操作边界",
+        ],
+    )
+
+
+def _blank_system_prompt(design: AgentBehaviorDesign) -> str:
+    principles = "\n".join(f"- {item}" for item in design.operating_principles)
+    boundaries = "\n".join(f"- {item}" for item in design.safety_boundaries)
+    outputs = "\n".join(f"- {item}" for item in design.output_expectations)
+    return (
+        f"# 角色\n{design.role}\n\n"
+        f"# 核心目标\n{design.objective}\n\n"
+        f"# 工作原则\n{principles}\n\n"
+        f"# 安全与边界\n{boundaries}\n\n"
+        f"# 回答要求\n{outputs}"
+    )
+
+
+def _blank_task_prompt(design: AgentBehaviorDesign) -> str:
+    workflow = "\n".join(f"{index}. {item}" for index, item in enumerate(design.workflow, 1))
+    return f"每次收到请求时遵循以下执行契约：\n{workflow}"
+
 _RESEARCH_SKILL_MANIFEST = {
     "name": RESEARCH_SKILL_NAME,
     "displayName": "深度调研方法",
@@ -180,7 +263,10 @@ def compose_blank_agent(
     skills = [item for item in resources if item.kind == "skill"]
     mcps = [item for item in resources if item.kind == "mcp"]
 
-    model = _select_model(models, request.model_profile_id)
+    requested_primary_model = request.model_profile_id or next(
+        iter(request.model_profile_ids), None
+    )
+    model = _select_model(models, requested_primary_model)
     selected_model_ids = _select_model_ids(
         models, request.model_profile_id, request.model_profile_ids
     )
@@ -199,12 +285,14 @@ def compose_blank_agent(
         request.mcp_resource_ids,
         kind="mcp",
     )
-    system_prompt = request.prompt.strip() or request.goal.strip()
-    task_prompt = request.task_prompt.strip() or (
-        "理解用户目标并给出准确、可执行的回答。调用 Tool 前检查输入，"
-        "对外部操作遵守权限策略；信息不足时说明假设并请求必要补充。"
-    )
-    description = request.description.strip() or system_prompt[:160]
+    goal = request.goal.strip() or request.prompt.strip()
+    behavior_design = _blank_behavior_design(goal, request.policy_template)
+    # Explicit ``prompt`` is a compatibility path for callers that already own the
+    # final system instructions. Studio quick-create sends ``goal`` and therefore
+    # receives the compiled, reviewable behavior contract below.
+    system_prompt = request.prompt.strip() or _blank_system_prompt(behavior_design)
+    task_prompt = request.task_prompt.strip() or _blank_task_prompt(behavior_design)
+    description = request.description.strip() or goal[:160]
     bindings = AgentBindings(
         model_profile_id=model.resource_id,
         model_profile_ids=selected_model_ids,
@@ -261,6 +349,7 @@ def compose_blank_agent(
     return AgentTemplateComposition(
         template_id="blank",
         spec=spec,
+        behavior_design=behavior_design,
         recommendations=recommendations,
         warnings=[],
     )
@@ -278,7 +367,10 @@ def compose_research_agent(
     skills = [item for item in resources if item.kind == "skill"]
     mcps = [item for item in resources if item.kind == "mcp"]
 
-    model = _select_model(models, request.model_profile_id)
+    requested_primary_model = request.model_profile_id or next(
+        iter(request.model_profile_ids), None
+    )
+    model = _select_model(models, requested_primary_model)
     selected_model_ids = _select_model_ids(
         models, request.model_profile_id, request.model_profile_ids
     )

ksadk/studio/validator.py

@@ -213,6 +213,25 @@ class AgentValidator:
                     )
                 )
 
+        # 方案 §5.2 / §6.1：ownership 必须与 runtime capability 兼容，不支持组合时报错不静默降级。
+        runtime_type = (
+            draft.spec.runtime.type if draft.spec.runtime
+            else draft.metadata.labels.get("agentkit.ksyun.com/framework", "")
+        )
+        ownership = draft.spec.context.ownership
+        try:
+            from ksadk.context_engine.capabilities import validate_ownership_for_runtime
+            validate_ownership_for_runtime(ownership, runtime_type=runtime_type)
+        except ValueError as exc:
+            diagnostics.append(
+                self._error(
+                    "OWNERSHIP_CAPABILITY_MISMATCH",
+                    str(exc),
+                    "spec.context.ownership",
+                    hint="按 Runtime capability 选择 ownership，不支持组合时 Build 会拒绝",
+                )
+            )
+
     @staticmethod
     def _error(
         code: str,

ksadk/studio/workspace.py

@@ -15,16 +15,6 @@ class Workspace:
     def __init__(self, root: Path | str) -> None:
         self.root = Path(root).expanduser().resolve()
 
-    def matches_configured_root_path(self, path: str) -> bool:
-        """Return whether a no-op workspace-open request names this exact root.
-
-        The local Studio daemon is intentionally bound to one workspace for its
-        lifetime.  Comparing the advertised canonical string avoids resolving
-        a client-supplied pathname in the workspace-open endpoint.
-        """
-
-        return path == os.fspath(self.root)
-
     def initialize(self) -> None:
         self.root.mkdir(parents=True, exist_ok=True)
         for relative in (
@@ -67,28 +57,36 @@ class Workspace:
             )
 
     def resolve(self, relative: Path | str, *, must_exist: bool = False) -> Path:
-        root_path = os.path.realpath(os.fspath(self.root))
-        raw_path = os.fspath(relative)
-        requested_path = (
-            raw_path if os.path.isabs(raw_path) else os.path.join(root_path, raw_path)
-        )
-        candidate_path = os.path.realpath(requested_path)
-        if candidate_path == root_path:
-            candidate = self.root
-        else:
-            root_prefix = root_path if root_path.endswith(os.sep) else f"{root_path}{os.sep}"
-            # `realpath` resolves traversal and symlinks before this segment-boundary check.
-            if candidate_path.startswith(root_prefix):
-                candidate = Path(candidate_path)
-            else:
-                raise StudioError(
-                    "WORKSPACE_PATH_FORBIDDEN",
-                    "路径不在当前工作区内",
-                    status_code=403,
-                    details={"path": str(relative)},
-                )
-        if must_exist:
-            candidate.stat()
+        raw = Path(relative)
+        # Reject lexical traversal before asking the filesystem to resolve any
+        # symlink.  The real-path prefix check below also catches a path that is
+        # lexically inside the workspace but escapes through a symlink.
+        if ".." in raw.parts:
+            raise StudioError(
+                "WORKSPACE_PATH_FORBIDDEN",
+                "路径不在当前工作区内",
+                status_code=403,
+                details={"path": str(relative)},
+            )
+
+        root_text = os.path.realpath(os.fspath(self.root))
+        candidate_input = raw if raw.is_absolute() else self.root / raw
+        candidate_text = os.path.realpath(os.fspath(candidate_input))
+        if candidate_text == root_text:
+            if must_exist and not self.root.exists():
+                raise FileNotFoundError(self.root)
+            return self.root
+        root_prefix = root_text.rstrip(os.sep) + os.sep
+        if not candidate_text.startswith(root_prefix):
+            raise StudioError(
+                "WORKSPACE_PATH_FORBIDDEN",
+                "路径不在当前工作区内",
+                status_code=403,
+                details={"path": str(relative)},
+            )
+        candidate = Path(candidate_text)
+        if must_exist and not candidate.exists():
+            raise FileNotFoundError(candidate)
         return candidate
 
     def relative(self, path: Path | str) -> str:

ksadk/tracing/setup.py

@@ -2,25 +2,48 @@
 Tracing 初始化 - 标准 OTLP 双写（Langfuse 主 + CloudMonitor 次）
 
 每个 Python Agent 进程一个 TracerProvider，挂两个 OTLP/HTTP protobuf BatchSpanProcessor，
-消费同一批 ReadableSpan。不在 exporter 阶段按目的地改写 span。
+消费同一批 ReadableSpan。仅为 CloudMonitor 克隆并补充兼容属性，不修改原始 span。
 
 支持 ADK 自动插桩 via openinference-instrumentation-google-adk
 """
 
 import atexit
 import importlib
+import json
 import logging
 import os
+from collections.abc import Callable, Sequence
 from dataclasses import dataclass
 from typing import Any, Optional
 from urllib.parse import unquote
 
+from opentelemetry.sdk.resources import Resource
+from opentelemetry.sdk.trace import ReadableSpan
 from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
 
 from ksadk.tracing.exporters.inmemory_exporter import InMemoryExporter
 
 logger = logging.getLogger(__name__)
 
+_CLOUD_MONITOR_RESOURCE_SPAN_ATTRIBUTES = (
+    "agentengine.account_id",
+    "agentengine.agent_id",
+    "agentengine.framework",
+    "agentengine.langfuse_project_id",
+    "agentengine.region",
+)
+
+_LANGFUSE_OBSERVATION_TYPES = {
+    "LLM": "generation",
+    "EMBEDDING": "embedding",
+    "CHAIN": "chain",
+    "AGENT": "agent",
+    "TOOL": "tool",
+    "RETRIEVER": "retriever",
+    "EVALUATOR": "evaluator",
+    "GUARDRAIL": "guardrail",
+}
+
 
 def _batch_span_processor_kwargs() -> dict:
     """BatchSpanProcessor 参数：限制单次 export 体积，避免 OTLP collector 413。
@@ -66,14 +89,16 @@ class _LoggingSpanExporter(SpanExporter):
         endpoint: str,
         service_name: str,
         header_keys: list[str],
+        span_transform: Callable[[Sequence[ReadableSpan]], Sequence[ReadableSpan]] | None = None,
     ):
         self._exporter = exporter
         self._name = name
         self._endpoint = endpoint
         self._service_name = service_name
         self._header_keys = header_keys
+        self._span_transform = span_transform
 
-    def export(self, spans) -> SpanExportResult:
+    def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
         span_count = len(spans)
         logger.info(
             "%s export started: endpoint=%s service_name=%s spans=%s headers=%s",
@@ -84,7 +109,8 @@ class _LoggingSpanExporter(SpanExporter):
             ",".join(self._header_keys),
         )
         try:
-            result = self._exporter.export(spans)
+            export_spans = self._span_transform(spans) if self._span_transform else spans
+            result = self._exporter.export(export_spans)
         except Exception:
             logger.exception(
                 "%s export failed: endpoint=%s service_name=%s spans=%s",
@@ -118,6 +144,280 @@ class _LoggingSpanExporter(SpanExporter):
         return self._exporter.force_flush(timeout_millis)
 
 
+def _coerce_int(value: Any) -> int:
+    if value is None or isinstance(value, bool):
+        return 0
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        try:
+            return int(float(value))
+        except (TypeError, ValueError):
+            return 0
+
+
+def _span_context(span: Any) -> Any:
+    context = getattr(span, "context", None)
+    if context is not None:
+        return context
+    get_context = getattr(span, "get_span_context", None)
+    return get_context() if callable(get_context) else None
+
+
+def _span_id(span: Any) -> Optional[int]:
+    return getattr(_span_context(span), "span_id", None)
+
+
+def _trace_id(span: Any) -> Optional[int]:
+    return getattr(_span_context(span), "trace_id", None)
+
+
+def _parent_span_id(span: Any) -> Optional[int]:
+    return getattr(getattr(span, "parent", None), "span_id", None)
+
+
+def _span_token_usage(span: Any) -> dict[str, int]:
+    attributes = getattr(span, "attributes", None) or {}
+    return _token_usage(attributes)
+
+
+def _token_usage(attributes: dict[str, Any]) -> dict[str, int]:
+    input_tokens = _coerce_int(
+        attributes.get("gen_ai.usage.input_tokens")
+        or attributes.get("llm.usage.prompt_tokens")
+        or attributes.get("llm.token_count.prompt")
+    )
+    output_tokens = _coerce_int(
+        attributes.get("gen_ai.usage.output_tokens")
+        or attributes.get("llm.usage.completion_tokens")
+        or attributes.get("llm.token_count.completion")
+    )
+    total_tokens = _coerce_int(
+        attributes.get("gen_ai.usage.total_tokens")
+        or attributes.get("llm.usage.total_tokens")
+        or attributes.get("llm.token_count.total")
+    )
+    return {
+        "input": input_tokens,
+        "output": output_tokens,
+        "total": total_tokens or input_tokens + output_tokens,
+        "cache_read": _coerce_int(
+            attributes.get("gen_ai.usage.cache_read.input_tokens")
+            or attributes.get("llm.usage.cache_read.input_tokens")
+        ),
+        "reasoning_output": _coerce_int(
+            attributes.get("gen_ai.usage.reasoning.output_tokens")
+            or attributes.get("llm.usage.reasoning_tokens")
+        ),
+    }
+
+
+def _first_span_attribute(attributes: dict[str, Any], *keys: str) -> Any:
+    for key in keys:
+        value = attributes.get(key)
+        if value not in (None, ""):
+            return value
+    return None
+
+
+def _add_langfuse_compatibility_attributes(attributes: dict[str, Any]) -> None:
+    usage = _token_usage(attributes)
+    observation_kind = str(attributes.get("openinference.span.kind") or "").upper()
+    observation_type = _LANGFUSE_OBSERVATION_TYPES.get(observation_kind)
+    if observation_type is None:
+        observation_type = "generation" if _has_nonzero_token_usage(usage) else "span"
+    attributes.setdefault("langfuse.observation.type", observation_type)
+
+    provider = _first_span_attribute(
+        attributes,
+        "gen_ai.provider.name",
+        "gen_ai.system",
+        "llm.provider",
+    )
+    if provider is not None:
+        attributes.setdefault("langfuse.observation.metadata.ls_provider", provider)
+
+    model = _first_span_attribute(
+        attributes,
+        "gen_ai.request.model",
+        "llm.model_name",
+    )
+    if model is not None:
+        attributes.setdefault("langfuse.observation.model.name", model)
+        attributes.setdefault("langfuse.observation.metadata.ls_model_name", model)
+
+    if _has_nonzero_token_usage(usage):
+        attributes.setdefault("gen_ai.usage.total_tokens", usage["total"])
+        usage_details = {
+            "input": usage["input"],
+            "output": usage["output"],
+            "total": usage["total"],
+            "input_cache_read": usage["cache_read"],
+        }
+        attributes["langfuse.observation.usage_details"] = json.dumps(
+            usage_details, separators=(",", ":"), sort_keys=True
+        )
+
+
+def _has_nonzero_token_usage(usage: dict[str, int]) -> bool:
+    return any(value > 0 for value in usage.values())
+
+
+def _clone_cloud_monitor_resource(resource: Resource | None) -> Resource | None:
+    if resource is None:
+        return None
+    attributes = dict(resource.attributes)
+    agent_id = str(attributes.get("agentengine.agent_id") or "").strip()
+    if not agent_id or attributes.get("service.name") == agent_id:
+        return resource
+    attributes["service.name"] = agent_id
+    return Resource(attributes, schema_url=resource.schema_url)
+
+
+def _clone_span(
+    span: ReadableSpan,
+    *,
+    attributes: dict[str, Any],
+    resource: Resource | None,
+) -> ReadableSpan:
+    return ReadableSpan(
+        name=span.name,
+        context=span.context,
+        parent=span.parent,
+        resource=resource,
+        attributes=attributes,
+        events=span.events,
+        links=span.links,
+        kind=span.kind,
+        status=span.status,
+        start_time=span.start_time,
+        end_time=span.end_time,
+        instrumentation_scope=getattr(span, "instrumentation_scope", None),
+    )
+
+
+def _prepare_cloud_monitor_spans(
+    spans: Sequence[ReadableSpan],
+) -> Sequence[ReadableSpan]:
+    """Clone CloudMonitor spans with resource identity and root usage compatibility."""
+    if not spans:
+        return spans
+    span_list = list(spans)
+    session_ids_by_trace: dict[Optional[int], Any] = {}
+    for span in span_list:
+        attributes = dict(getattr(span, "attributes", None) or {})
+        session_id = _first_span_attribute(
+            attributes,
+            "session.id",
+            "langfuse.session.id",
+            "ksadk.session_id",
+        )
+        if session_id is not None:
+            session_ids_by_trace.setdefault(_trace_id(span), session_id)
+    span_keys = {
+        (_trace_id(span), _span_id(span)) for span in span_list if _span_id(span) is not None
+    }
+    children_by_parent: dict[tuple[Optional[int], int], list[ReadableSpan]] = {}
+    roots: list[ReadableSpan] = []
+    for span in span_list:
+        span_id = _span_id(span)
+        if span_id is None:
+            continue
+        trace_id = _trace_id(span)
+        parent_id = _parent_span_id(span)
+        if parent_id is None or (trace_id, parent_id) not in span_keys:
+            roots.append(span)
+        else:
+            children_by_parent.setdefault((trace_id, parent_id), []).append(span)
+
+    usage_by_span = {
+        (_trace_id(span), _span_id(span)): _span_token_usage(span)
+        for span in span_list
+        if _span_id(span) is not None
+    }
+    has_token_descendant_cache: dict[tuple[Optional[int], int], bool] = {}
+
+    def has_token_descendant(span: ReadableSpan) -> bool:
+        key = (_trace_id(span), _span_id(span))
+        if key[1] is None:
+            return False
+        if key in has_token_descendant_cache:
+            return has_token_descendant_cache[key]
+        result = any(
+            _has_nonzero_token_usage(usage_by_span.get((_trace_id(child), _span_id(child)), {}))
+            or has_token_descendant(child)
+            for child in children_by_parent.get(key, [])
+        )
+        has_token_descendant_cache[key] = result
+        return result
+
+    def collect_leaf_usage(span: ReadableSpan, aggregate: dict[str, int]) -> None:
+        key = (_trace_id(span), _span_id(span))
+        own_usage = usage_by_span.get(key, {})
+        if _has_nonzero_token_usage(own_usage) and not has_token_descendant(span):
+            for usage_key, value in own_usage.items():
+                aggregate[usage_key] += value
+            return
+        for child in children_by_parent.get(key, []):
+            collect_leaf_usage(child, aggregate)
+
+    root_usage: dict[int, dict[str, int]] = {}
+    for root in roots:
+        aggregate = {
+            "input": 0,
+            "output": 0,
+            "total": 0,
+            "cache_read": 0,
+            "reasoning_output": 0,
+        }
+        collect_leaf_usage(root, aggregate)
+        root_usage[id(root)] = aggregate
+
+    resource_cache: dict[int, Resource | None] = {}
+    transformed: list[ReadableSpan] = []
+    usage_attributes = {
+        "gen_ai.usage.input_tokens": "input",
+        "gen_ai.usage.output_tokens": "output",
+        "gen_ai.usage.total_tokens": "total",
+        "gen_ai.usage.cache_read.input_tokens": "cache_read",
+        "gen_ai.usage.reasoning.output_tokens": "reasoning_output",
+    }
+    for span in span_list:
+        original_resource = getattr(span, "resource", None)
+        original_resource_attributes = getattr(original_resource, "attributes", {}) or {}
+        resource_key = id(original_resource)
+        if resource_key not in resource_cache:
+            resource_cache[resource_key] = _clone_cloud_monitor_resource(original_resource)
+        resource = resource_cache[resource_key]
+        attributes = dict(getattr(span, "attributes", None) or {})
+        resource_attributes = getattr(resource, "attributes", {}) or {}
+        for key in _CLOUD_MONITOR_RESOURCE_SPAN_ATTRIBUTES:
+            value = resource_attributes.get(key)
+            if value not in (None, ""):
+                attributes.setdefault(f"gen_ai.{key}", value)
+        agent_name = original_resource_attributes.get(
+            "agentengine.agent_name"
+        ) or original_resource_attributes.get("service.name")
+        if agent_name not in (None, ""):
+            attributes.setdefault("gen_ai.agentengine.agent_name", agent_name)
+        aggregate = root_usage.get(id(span), {})
+        for attribute, usage_key in usage_attributes.items():
+            if _coerce_int(attributes.get(attribute)) <= 0 and aggregate.get(usage_key, 0) > 0:
+                attributes[attribute] = aggregate[usage_key]
+
+        session_id = session_ids_by_trace.get(_trace_id(span))
+        if session_id is not None:
+            attributes.setdefault("session.id", session_id)
+        _add_langfuse_compatibility_attributes(attributes)
+
+        original_attributes = dict(getattr(span, "attributes", None) or {})
+        if resource is original_resource and attributes == original_attributes:
+            transformed.append(span)
+        else:
+            transformed.append(_clone_span(span, attributes=attributes, resource=resource))
+    return transformed
+
+
 def _parse_otlp_headers(raw: str) -> dict[str, str]:
     """Parse OTEL_EXPORTER_OTLP_HEADERS into an HTTP headers dict."""
     headers: dict[str, str] = {}
@@ -409,6 +709,7 @@ def setup_tracing(
                 endpoint=cloud_monitor_config.endpoint,
                 service_name=cloud_monitor_config.service_name,
                 header_keys=sorted(cloud_monitor_config.headers),
+                span_transform=_prepare_cloud_monitor_spans,
             )
             _register_span_processor(
                 provider,

ksadk/version.py

@@ -1,4 +1,4 @@
 """KsADK 版本信息"""
 
-VERSION = "0.8.1"
+VERSION = "0.8.2"
 __version__ = VERSION