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

ksadk/studio/codex_builder.py

@@ -51,6 +51,13 @@ class CodexBuildRecord(ContractModel):
     # New builds always persist a mapping (possibly empty), so run resolution
     # never consults mutable Catalog state after the build has been created.
     model_profiles: dict[str, dict[str, Any]] | None = None
+    # Resource ids and model names are different namespaces.  Keep the exact
+    # Studio bindings separately so currentness checks never compare a model
+    # name (``glm-5.2``) with a Catalog id (``model:provider:glm-5-2:live``).
+    # ``None`` only allows older local records to be read and rejected as
+    # stale with an actionable rebuild; Phase 2 has not shipped yet, so the
+    # deployment path does not carry a legacy identity-migration branch.
+    model_profile_ids: list[str] | None = None
     created_at: datetime
 
 
@@ -272,7 +279,12 @@ class CodexStudioBuilder:
             allowed_models=snapshot.manifest.allowed_models,
             ignore_missing=True,
         )
-        build_id = self._build_id(snapshot.manifest_sha256, model_profiles)
+        model_profile_ids = self._bound_model_profile_ids(snapshot.manifest.name)
+        build_id = self._build_id(
+            snapshot.manifest_sha256,
+            model_profiles,
+            model_profile_ids=model_profile_ids,
+        )
         try:
             existing = self.repository.get(build_id)
         except StudioError as exc:
@@ -337,6 +349,7 @@ class CodexStudioBuilder:
             proxy_mode=current_proxy_mode(),
             runtime_lock=lock,
             model_profiles=model_profiles,
+            model_profile_ids=model_profile_ids,
             created_at=datetime.now(timezone.utc),
         )
         return self.repository.save(record)
@@ -347,29 +360,41 @@ class CodexStudioBuilder:
             return False
         if record.model_profiles is None:
             return True
-        try:
-            current_profiles = self._model_profile_snapshot(
-                snapshot.manifest.name,
-                allowed_models=snapshot.manifest.allowed_models,
-            )
-        except StudioError as exc:
-            if exc.code == "RESOURCE_NOT_FOUND":
-                # A completed Build owns its connection snapshot.  A later
-                # Catalog cleanup must not make that immutable Build
-                # undeployable; launch resolution reads the snapshot instead.
-                return True
-            raise
+        if record.model_profile_ids is None:
+            return False
+        draft = self.drafts.get(record.agent_name) if self.drafts is not None else None
+        if draft is None:
+            return not record.model_profiles
+
+        bound_ids = set(self._bound_model_profile_ids(record.agent_name))
+        if set(record.model_profile_ids) != bound_ids:
+            return False
+        current_profiles = self._model_profile_snapshot(
+            snapshot.manifest.name,
+            allowed_models=snapshot.manifest.allowed_models,
+            ignore_missing=True,
+        )
+        # Provider-discovered Catalog entries are process-local.  A restart may
+        # temporarily remove them, but the Build still owns an immutable,
+        # runnable connection snapshot and must remain deployable.
+        if bound_ids and not current_profiles:
+            return True
         return record.model_profiles == current_profiles
 
     @staticmethod
     def _build_id(
         manifest_sha256: str,
         model_profiles: dict[str, dict[str, Any]],
+        *,
+        model_profile_ids: list[str] | None = None,
     ) -> str:
-        if not model_profiles:
+        if not model_profiles and not model_profile_ids:
             return f"build_{manifest_sha256[:20]}"
         fingerprint = json.dumps(
-            model_profiles,
+            {
+                "profiles": model_profiles,
+                "resourceIds": sorted(model_profile_ids or []),
+            },
             ensure_ascii=False,
             sort_keys=True,
             separators=(",", ":"),
@@ -417,10 +442,24 @@ class CodexStudioBuilder:
                 by_alias=True,
                 exclude_defaults=True,
                 exclude_none=True,
+                exclude={"metadata", "discovery"},
                 mode="json",
             )
         return profiles
 
+    def _bound_model_profile_ids(self, agent_id: str) -> list[str]:
+        if self.drafts is None:
+            return []
+        draft = self.drafts.get(agent_id)
+        if draft is None:
+            return []
+        bindings = draft.spec.bindings
+        resource_ids = list(getattr(bindings, "model_profile_ids", []) or [])
+        default_id = getattr(bindings, "model_profile_id", None)
+        if not resource_ids and default_id:
+            resource_ids = [default_id]
+        return list(dict.fromkeys(resource_ids))
+
     @staticmethod
     def _runtime_lock(artifact_path: Path) -> dict:
         if artifact_path.suffix == ".zip":

ksadk/studio/codex_manifest.py

@@ -13,8 +13,9 @@ import yaml  # type: ignore[import-untyped]
 from pydantic import BaseModel, ConfigDict, Field, ValidationError, model_validator
 
 from ksadk.builders.managed_runtime_builder import serialize_managed_runtime_manifest
-from ksadk.studio.contracts import ContextSpec, MemorySpec
+from ksadk.studio.contracts import ContextSpec, MemorySpec, SoulDocument
 from ksadk.studio.errors import StudioError, not_found
+from ksadk.studio.soul import soul_digest as compute_soul_digest
 from ksadk.studio.workspace import Workspace
 
 
@@ -43,6 +44,12 @@ class CodexAgentManifest(BaseModel):
     # Codex Runtime 最终仍消费合并后的 base_instructions；该字段用于在 AgentVersion /
     # Build 中保留任务契约来源，避免为了运行投影而破坏 PromptSection 审计。
     task_prompt: str | None = Field(default=None, max_length=32768)
+    # Soul remains reviewed source in the ManagedRuntime manifest. Runtime
+    # launch deterministically compiles it before ``prompt``; these provenance
+    # fields prevent a Draft-only Soul from masquerading as deployed behavior.
+    soul: SoulDocument | None = None
+    soul_source: Literal["AgentSpec.soul"] | None = None
+    soul_digest: str | None = Field(default=None, pattern=r"^sha256:[0-9a-f]{64}$")
     skills: list[str] | None = None
     mcp_servers: list[dict[str, Any]] | None = None
     sandbox: str | None = None
@@ -98,6 +105,17 @@ class CodexAgentManifest(BaseModel):
                 mcp_seen.add(name)
                 mcp_deduped.append(server)
             self.mcp_servers = mcp_deduped
+        if self.soul is None:
+            if self.soul_source is not None or self.soul_digest is not None:
+                raise ValueError("soul source/digest require a SoulDocument")
+        else:
+            expected_digest = compute_soul_digest(self.soul)
+            if self.soul_source not in {None, "AgentSpec.soul"}:
+                raise ValueError("soul_source must identify AgentSpec.soul")
+            if self.soul_digest not in {None, expected_digest}:
+                raise ValueError("soul_digest does not match the SoulDocument")
+            self.soul_source = "AgentSpec.soul"
+            self.soul_digest = expected_digest
         return self
 
     @property
@@ -113,6 +131,8 @@ def normalized_manifest_bytes(manifest: CodexAgentManifest) -> bytes:
         payload["context"] = manifest.context.model_dump(mode="python", by_alias=True)
     if manifest.memory is not None:
         payload["memory"] = manifest.memory.model_dump(mode="python", by_alias=True)
+    if manifest.soul is not None:
+        payload["soul"] = manifest.soul.model_dump(mode="python", by_alias=True)
     return serialize_managed_runtime_manifest(payload)
 
 

ksadk/studio/codex_run.py

@@ -12,9 +12,10 @@ from ksadk.configs import ModelConfig
 from ksadk.runtime import RuntimeLaunchContext
 from ksadk.studio.codex_builder import CodexBuildRepository
 from ksadk.studio.codex_manifest import CodexAgentManifest, CodexManifestRepository
-from ksadk.studio.contracts import ModelSpec
+from ksadk.studio.contracts import Instructions, ModelSpec
 from ksadk.studio.errors import StudioError
 from ksadk.studio.run_service import StudioRunSpec
+from ksadk.studio.soul import compose_system_instruction
 from ksadk.studio.workspace import Workspace
 from ksadk.tools.gateway import normalize_tool_approval_mode
 
@@ -87,18 +88,22 @@ class CodexRunSpecResolver:
         if runtime_env:
             launch_config["env"] = runtime_env
         agent_task = str(manifest.task_prompt or "").strip()
+        agent_system = compose_system_instruction(
+            Instructions(system=manifest.prompt),
+            manifest.soul,
+        ).system
         # PCM 策略从不可变 Manifest 读取（方案 §5.1：Build 锁定后 sidecar 修改不影响旧 Build）
         # manifest.context/memory 由 _manifest() 从 AgentSpec 写入，随 Build 进入 Artifact
         resolved_context = manifest.context
         resolved_memory = manifest.memory
-        base_instructions = manifest.prompt
+        base_instructions = agent_system
         if agent_task:
-            base_instructions = f"{manifest.prompt}\n\n{agent_task}"
+            base_instructions = f"{agent_system}\n\n{agent_task}"
         request_config: dict[str, Any] = {
             # Codex 原生只接收 base_instructions，因此运行前合并；PCM 证据仍使用下面
             # 两个独立来源生成 agent_identity / agent_policy 的分段 hash。
             "base_instructions": base_instructions,
-            "agent_system": manifest.prompt,
+            "agent_system": agent_system,
             "agent_task": agent_task,
             "cwd": str(project_dir),
             "skills": skills,
@@ -136,6 +141,13 @@ class CodexRunSpecResolver:
         }
         if approval_profile:
             request_config["tool_approval_mode"] = approval_profile
+        if manifest.soul is not None:
+            request_config.update(
+                {
+                    "soul_source": manifest.soul_source,
+                    "soul_digest": manifest.soul_digest,
+                }
+            )
         return StudioRunSpec(
             launch_context=RuntimeLaunchContext(
                 runtime_type="codex",

ksadk/studio/compatibility_report.py

@@ -0,0 +1,445 @@
+"""Deterministic build-time compatibility report for AgentBundle v2.
+
+The report contains only immutable, already-resolved facts.  It deliberately
+does not inspect environment variables, import plugin entrypoints, or claim
+that a process is healthy.  Runtime readiness remains an Activation concern.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from collections.abc import Callable, Mapping
+from typing import Any
+
+from ksadk.plugins.contracts import LockedCapability, PluginLockEntry, PluginManifest
+from ksadk.plugins.resolver import (
+    PluginResolutionError,
+    ResolvedComposition,
+    version_satisfies,
+)
+from ksadk.studio.contracts import AgentDraft
+
+COMPATIBILITY_REPORT_FORMAT = "agentkit.compatibility-report/v1"
+CURRENT_KERNEL_API_VERSION = "1.0.0"
+CURRENT_RUNTIME_CONTRACT = "agentkit.runtime/v1"
+SUPPORTED_RUNTIME_PROTOCOLS = (CURRENT_RUNTIME_CONTRACT,)
+
+
+def compatibility_facts_digest(
+    *,
+    draft: AgentDraft,
+    composition: ResolvedComposition | None,
+    runtime_lock: Mapping[str, Any],
+) -> str:
+    """Address every static input that can change a compatibility conclusion."""
+
+    payload: dict[str, Any] = {
+        "allowedPermissions": sorted(set(draft.spec.security.allowed_permissions)),
+        "runtime": {
+            "type": str(runtime_lock.get("type") or ""),
+            "version": str(runtime_lock.get("version") or ""),
+        },
+        "composition": None,
+    }
+    if composition is not None:
+        payload["composition"] = {
+            "profileDigest": composition.profile_digest,
+            "pluginLockDigest": composition.plugin_lock_digest,
+            "manifests": [
+                manifest.model_dump(
+                    by_alias=True,
+                    exclude_none=True,
+                    mode="json",
+                )
+                for manifest in sorted(
+                    composition.manifests,
+                    key=lambda item: (item.metadata.id, item.metadata.version),
+                )
+            ],
+        }
+    canonical = json.dumps(
+        payload,
+        ensure_ascii=False,
+        sort_keys=True,
+        separators=(",", ":"),
+    ).encode("utf-8")
+    return f"sha256:{hashlib.sha256(canonical).hexdigest()}"
+
+
+def build_bundle_compatibility_report(
+    *,
+    draft: AgentDraft,
+    composition: ResolvedComposition | None,
+    runtime_lock: Mapping[str, Any],
+    resolved_digest: str,
+    facts_digest: str,
+    plugin_lock_digest: str,
+    composition_profile_digest: str | None,
+) -> dict[str, Any]:
+    """Project auditable static compatibility without reading host secrets."""
+
+    bundle = {
+        "bundleFormat": "agentkit.bundle/v2",
+        "compatibilityFactsDigest": facts_digest,
+        "resolvedDigest": resolved_digest,
+        "pluginLockDigest": plugin_lock_digest,
+        **(
+            {"compositionProfileDigest": composition_profile_digest}
+            if composition_profile_digest is not None
+            else {}
+        ),
+    }
+    allowed_permissions = sorted(set(draft.spec.security.allowed_permissions))
+    if composition is None:
+        return _legacy_report(
+            bundle=bundle,
+            runtime_lock=runtime_lock,
+            allowed_permissions=allowed_permissions,
+        )
+
+    manifests = {manifest.metadata.id: manifest for manifest in composition.manifests}
+    locked = {entry.id: entry for entry in composition.plugin_lock.plugins}
+    blockers: list[dict[str, str]] = []
+
+    def block(code: str, subject: str, reason: str) -> None:
+        blockers.append({"code": code, "subject": subject, "reason": reason})
+
+    permission_items: list[dict[str, Any]] = []
+    protocol_items: list[dict[str, Any]] = []
+    kernel_items: list[dict[str, str]] = []
+    capability_items: list[dict[str, str]] = []
+
+    for entry in composition.plugin_lock.plugins:
+        manifest = manifests.get(entry.id)
+        if manifest is None:
+            block(
+                "plugin_manifest_facts_missing",
+                entry.id,
+                "The exact manifest used to resolve this lock entry is unavailable.",
+            )
+            permission_items.append(
+                {
+                    "pluginId": entry.id,
+                    "required": [],
+                    "unapproved": [],
+                    "status": "blocked",
+                }
+            )
+            protocol_items.append(
+                {
+                    "pluginId": entry.id,
+                    "required": [],
+                    "supported": list(SUPPORTED_RUNTIME_PROTOCOLS),
+                    "status": "blocked",
+                }
+            )
+            kernel_items.append(
+                {
+                    "pluginId": entry.id,
+                    "required": "unknown",
+                    "resolved": CURRENT_KERNEL_API_VERSION,
+                    "status": "blocked",
+                }
+            )
+            for capability in entry.provides:
+                capability_items.append(
+                    _capability_item(entry, capability, mode="unknown", status="blocked")
+                )
+            continue
+
+        _append_manifest_conclusions(
+            entry=entry,
+            manifest=manifest,
+            allowed_permissions=allowed_permissions,
+            permission_items=permission_items,
+            protocol_items=protocol_items,
+            kernel_items=kernel_items,
+            capability_items=capability_items,
+            block=block,
+        )
+
+    provider_ref = composition.profile.agent_provider.ref
+    provider_id, requested_version = _plugin_ref_parts(provider_ref)
+    provider_entry = locked.get(provider_id)
+    provider_manifest = manifests.get(provider_id)
+    if provider_entry is None:
+        block(
+            "agent_provider_lock_missing",
+            provider_id,
+            "The CompositionProfile AgentProvider has no exact PluginLock entry.",
+        )
+    elif provider_entry.version != requested_version:
+        block(
+            "agent_provider_version_mismatch",
+            provider_id,
+            (
+                f"Profile requests {requested_version}, but the lock resolves "
+                f"{provider_entry.version}."
+            ),
+        )
+
+    blockers.sort(key=lambda item: (item["code"], item["subject"], item["reason"]))
+    blocked_subjects = {item["subject"] for item in blockers}
+    overall = "blocked" if blockers else "compatible"
+    provider_status = "blocked" if provider_id in blocked_subjects else "compatible"
+
+    return {
+        "format": COMPATIBILITY_REPORT_FORMAT,
+        "scope": "build-time-static",
+        "overallStatus": overall,
+        "bundle": bundle,
+        "host": {
+            "kind": _host_kind(provider_manifest),
+            "kernelApiVersion": CURRENT_KERNEL_API_VERSION,
+            "runtimeContract": CURRENT_RUNTIME_CONTRACT,
+            "readiness": "notEvaluated",
+            "status": overall,
+        },
+        "provider": _provider_conclusion(
+            provider_ref=provider_ref,
+            provider_id=provider_id,
+            requested_version=requested_version,
+            entry=provider_entry,
+            manifest=provider_manifest,
+            status=provider_status,
+        ),
+        "kernelApi": sorted(kernel_items, key=lambda item: item["pluginId"]),
+        "protocols": sorted(protocol_items, key=lambda item: item["pluginId"]),
+        "permissions": {
+            "allowed": allowed_permissions,
+            "plugins": sorted(permission_items, key=lambda item: item["pluginId"]),
+            "status": (
+                "blocked"
+                if any(item["status"] == "blocked" for item in permission_items)
+                else "compatible"
+            ),
+        },
+        "capabilities": sorted(
+            capability_items,
+            key=lambda item: (item["definition"], item["slot"], item["owner"]),
+        ),
+        "blockingReasons": blockers,
+    }
+
+
+def _legacy_report(
+    *,
+    bundle: dict[str, Any],
+    runtime_lock: Mapping[str, Any],
+    allowed_permissions: list[str],
+) -> dict[str, Any]:
+    runtime_type = str(runtime_lock.get("type") or "")
+    version = str(runtime_lock.get("version") or "")
+    return {
+        "format": COMPATIBILITY_REPORT_FORMAT,
+        "scope": "build-time-static",
+        "overallStatus": "compatible",
+        "bundle": bundle,
+        "host": {
+            "kind": "legacy-runtime",
+            "kernelApiVersion": CURRENT_KERNEL_API_VERSION,
+            "runtimeContract": CURRENT_RUNTIME_CONTRACT,
+            "readiness": "notEvaluated",
+            "status": "compatible",
+        },
+        "provider": {
+            "ref": None,
+            "id": runtime_type or "builtin.legacy",
+            "hostRuntime": runtime_type or "unknown",
+            "isolation": "legacy",
+            "source": "builtin",
+            "digest": None,
+            "version": {
+                "requested": version or None,
+                "resolved": version or None,
+                "status": "compatible" if version else "unknown",
+            },
+            "status": "compatible",
+        },
+        "kernelApi": [],
+        "protocols": [
+            {
+                "pluginId": runtime_type or "builtin.legacy",
+                "required": [CURRENT_RUNTIME_CONTRACT],
+                "supported": list(SUPPORTED_RUNTIME_PROTOCOLS),
+                "status": "compatible",
+            }
+        ],
+        "permissions": {
+            "allowed": allowed_permissions,
+            "plugins": [],
+            "status": "compatible",
+        },
+        "capabilities": [],
+        "blockingReasons": [],
+    }
+
+
+def _append_manifest_conclusions(
+    *,
+    entry: PluginLockEntry,
+    manifest: PluginManifest,
+    allowed_permissions: list[str],
+    permission_items: list[dict[str, Any]],
+    protocol_items: list[dict[str, Any]],
+    kernel_items: list[dict[str, str]],
+    capability_items: list[dict[str, str]],
+    block: Callable[[str, str, str], None],
+) -> None:
+    if (
+        manifest.metadata.id != entry.id
+        or manifest.metadata.version != entry.version
+        or manifest.spec.provenance.digest != entry.digest
+    ):
+        block(
+            "plugin_manifest_lock_mismatch",
+            entry.id,
+            "Resolved manifest identity or digest does not match the PluginLock entry.",
+        )
+
+    required_permissions = sorted(set(manifest.spec.permissions))
+    unapproved = sorted(set(required_permissions) - set(allowed_permissions))
+    permission_status = "blocked" if unapproved else "compatible"
+    permission_items.append(
+        {
+            "pluginId": entry.id,
+            "required": required_permissions,
+            "unapproved": unapproved,
+            "status": permission_status,
+        }
+    )
+    if unapproved:
+        block(
+            "plugin_permission_unapproved",
+            entry.id,
+            "Unapproved permissions: " + ", ".join(unapproved),
+        )
+
+    protocols = sorted(set(manifest.spec.compatibility.runtime_protocols))
+    protocol_status = (
+        "compatible" if not protocols or CURRENT_RUNTIME_CONTRACT in protocols else "blocked"
+    )
+    protocol_items.append(
+        {
+            "pluginId": entry.id,
+            "required": protocols,
+            "supported": list(SUPPORTED_RUNTIME_PROTOCOLS),
+            "status": protocol_status,
+        }
+    )
+    if protocol_status == "blocked":
+        block(
+            "runtime_protocol_incompatible",
+            entry.id,
+            f"Plugin accepts {', '.join(protocols)}, host provides {CURRENT_RUNTIME_CONTRACT}.",
+        )
+
+    kernel_constraint = manifest.spec.compatibility.kernel_api
+    try:
+        kernel_compatible = version_satisfies(
+            CURRENT_KERNEL_API_VERSION,
+            kernel_constraint,
+        )
+    except PluginResolutionError:
+        kernel_compatible = False
+    kernel_items.append(
+        {
+            "pluginId": entry.id,
+            "required": kernel_constraint,
+            "resolved": CURRENT_KERNEL_API_VERSION,
+            "status": "compatible" if kernel_compatible else "blocked",
+        }
+    )
+    if not kernel_compatible:
+        block(
+            "kernel_api_incompatible",
+            entry.id,
+            f"Plugin requires {kernel_constraint}, host provides {CURRENT_KERNEL_API_VERSION}.",
+        )
+
+    offers = {(offer.definition, offer.slot): offer for offer in manifest.spec.provides}
+    for capability in entry.provides:
+        offer = offers.get((capability.definition, capability.slot))
+        status = "compatible" if capability.owner == entry.id and offer is not None else "blocked"
+        capability_items.append(
+            _capability_item(
+                entry,
+                capability,
+                mode=offer.mode if offer is not None else "unknown",
+                status=status,
+            )
+        )
+        if status == "blocked":
+            block(
+                "capability_lock_mismatch",
+                entry.id,
+                f"Locked capability {capability.definition} at {capability.slot} "
+                "does not match the resolved manifest owner.",
+            )
+
+
+def _capability_item(
+    entry: PluginLockEntry,
+    capability: LockedCapability,
+    *,
+    mode: str,
+    status: str,
+) -> dict[str, str]:
+    return {
+        "definition": capability.definition,
+        "slot": capability.slot,
+        "owner": capability.owner,
+        "version": entry.version,
+        "mode": mode,
+        "status": status,
+    }
+
+
+def _provider_conclusion(
+    *,
+    provider_ref: str,
+    provider_id: str,
+    requested_version: str,
+    entry: PluginLockEntry | None,
+    manifest: PluginManifest | None,
+    status: str,
+) -> dict[str, Any]:
+    return {
+        "ref": provider_ref,
+        "id": provider_id,
+        "hostRuntime": manifest.spec.runtime if manifest is not None else "unknown",
+        "isolation": manifest.spec.isolation if manifest is not None else "unknown",
+        "source": entry.source if entry is not None else "unknown",
+        "digest": entry.digest if entry is not None else None,
+        "version": {
+            "requested": requested_version,
+            "resolved": entry.version if entry is not None else None,
+            "status": (
+                "compatible"
+                if entry is not None and entry.version == requested_version
+                else "blocked"
+            ),
+        },
+        "status": status,
+    }
+
+
+def _host_kind(provider: PluginManifest | None) -> str:
+    if provider is not None and provider.spec.domain == "runtime-native":
+        return "runtime-native"
+    return "composition-host"
+
+
+def _plugin_ref_parts(value: str) -> tuple[str, str]:
+    plugin_id, version = value.removeprefix("plugin://").rsplit("@", 1)
+    return plugin_id, version
+
+
+__all__ = [
+    "COMPATIBILITY_REPORT_FORMAT",
+    "CURRENT_KERNEL_API_VERSION",
+    "CURRENT_RUNTIME_CONTRACT",
+    "build_bundle_compatibility_report",
+    "compatibility_facts_digest",
+]

ksadk/studio/compiler.py

@@ -20,6 +20,7 @@ from ksadk.studio.contracts import (
 )
 from ksadk.studio.errors import StudioError
 from ksadk.studio.resource_catalog import LocalResourceCatalog
+from ksadk.studio.soul import compose_system_instruction
 from ksadk.studio.validator import AgentValidator
 from ksadk.studio.workspace import Workspace
 
@@ -72,7 +73,11 @@ class AgentCompiler:
         resolved = ResolvedAgentSpec(
             agent_id=draft.metadata.id,
             source_revision=draft.metadata.revision,
-            instructions=materialized.spec.instructions,
+            instructions=compose_system_instruction(
+                materialized.spec.instructions,
+                materialized.spec.soul,
+            ),
+            soul=materialized.spec.soul,
             model=self.resolver.resolve_model(materialized.spec.model),
             capabilities=ResolvedCapabilities(
                 skills=skills,