taisce-agent-framework 0.1.0__tar.gz

taisce_agent_framework-0.1.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: taisce-agent-framework
+Version: 0.1.0
+Summary: Microsoft Agent Framework adapter for Taisce: a context provider that injects governed memory as one untrusted user message and records the turn afterwards.
+License-Expression: Apache-2.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: taisce>=0.1.0
+Requires-Dist: agent-framework-core>=1.18.0

taisce_agent_framework-0.1.0/pyproject.toml

@@ -0,0 +1,15 @@
+[project]
+name = "taisce-agent-framework"
+version = "0.1.0"
+description = "Microsoft Agent Framework adapter for Taisce: a context provider that injects governed memory as one untrusted user message and records the turn afterwards."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "Apache-2.0"
+dependencies = ["taisce>=0.1.0", "agent-framework-core>=1.18.0"]
+
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+include = ["taisce_agent_framework*"]

taisce_agent_framework-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

taisce_agent_framework-0.1.0/taisce_agent_framework/__init__.py

@@ -0,0 +1,33 @@
+# Copyright 2026 The Taisce Authors
+# SPDX-License-Identifier: Apache-2.0
+"""Microsoft Agent Framework adapter for Taisce."""
+from .compaction import TaisceCompaction
+from .session import Loaded, Saved, SessionStore
+from .text_search import APPROXIMATE_NOTICE, SearchResult, map_results, search
+from .context import (
+    MEMORY_MESSAGE_PREFIX,
+    UNTRUSTED_PROPERTY,
+    TaisceContextProvider,
+    external_only,
+    is_memory_message,
+    render_memory_message,
+    turn_key,
+)
+
+__all__ = ["TaisceCompaction",
+    "APPROXIMATE_NOTICE",
+    "SearchResult",
+    "SessionStore",
+    "Saved",
+    "Loaded",
+    "map_results",
+    "search",
+    
+    "MEMORY_MESSAGE_PREFIX",
+    "UNTRUSTED_PROPERTY",
+    "TaisceContextProvider",
+    "external_only",
+    "is_memory_message",
+    "render_memory_message",
+    "turn_key",
+]

taisce_agent_framework-0.1.0/taisce_agent_framework/compaction.py

@@ -0,0 +1,87 @@
+# Copyright 2026 The Taisce Authors
+# SPDX-License-Identifier: Apache-2.0
+"""The compaction provider: when the loaded history is long, replace it with the deployment's context.
+
+The framework's own compaction seam is a strategy that marks loaded messages excluded; a strategy
+cannot add a message the run keeps, so this is a context provider of its own that does what the
+framework's ``CompactionProvider`` does to the loaded history and then contributes one message. It
+decides nothing about what the context holds: it asks ``POST /v1/contexts`` and hands the answer
+over unchanged, as one ``user`` message marked untrusted, in place of every loaded message that is
+not a system message or a memory message another provider injected.
+
+**Why replacement and not a summary.** A summary written here would be prose the deployment cannot
+register, erase or re-derive, in a language-specific way, entering the history as though somebody
+said it. The deployment holds every turn already and has rolled the older ones up off the read
+path; its answer is the history, and the adapter's only job is fidelity to it.
+
+**Failure policy.** A context that cannot be fetched leaves the loaded history as it was and reports
+through ``on_error``; the agent runs with more to read, not less, and the turn is not fatal.
+
+**The trigger** is a count of loaded non-system messages, because that is what this framework's
+Python SDK counts by. The stored history is the application's and is not rewritten; once
+over the trigger, every run fetches the context once.
+"""
+from __future__ import annotations
+
+from typing import Any, Callable, Optional
+
+from agent_framework import ContextProvider, Message
+
+from taisce import Client
+from taisce.memory import render_context_message
+
+from .context import UNTRUSTED_PROPERTY, _role, is_memory_message
+
+#: The source id this provider reports to the framework.
+SOURCE_ID = "taisce-compaction"
+
+
+class TaisceCompaction(ContextProvider):
+    """Replaces a long loaded history with the deployment's context, before the model runs."""
+
+    def __init__(
+        self,
+        client: Client,
+        *,
+        data_subject_id: str,
+        after_messages: int,
+        max_characters: Optional[int] = None,
+        on_error: Optional[Callable[[str, Exception], None]] = None,
+        source_id: str = SOURCE_ID,
+    ) -> None:
+        if not data_subject_id or not data_subject_id.strip():
+            raise ValueError("a data subject is required: a context is one subject's history")
+        if after_messages <= 0:
+            raise ValueError("after_messages must be positive: it is the history length that triggers compaction")
+        super().__init__(source_id=source_id)
+        self._client = client
+        self._data_subject_id = data_subject_id
+        self._after_messages = after_messages
+        self._max_characters = max_characters
+        self._on_error = on_error
+
+    async def before_run(self, *, agent: Any, session: Any, context: Any, state: dict) -> None:
+        loaded = context.get_messages()
+        if sum(1 for m in loaded if not _kept(m)) <= self._after_messages:
+            return
+        try:
+            assembled = await self._client.context(data_subject_id=self._data_subject_id, max_characters=self._max_characters)
+        except Exception as exc:  # noqa: BLE001 - swallowed by design, see the module docstring
+            self._report("context", exc)
+            return
+        rendered = render_context_message(assembled)
+        for source in list(context.context_messages):
+            context.context_messages[source] = [m for m in context.context_messages[source] if _kept(m)]
+        context.extend_messages(self.source_id, [
+            Message("user", [rendered], author_name="taisce", additional_properties={UNTRUSTED_PROPERTY: True}),
+        ])
+
+    def _report(self, stage: str, exc: Exception) -> None:
+        if self._on_error is not None:
+            self._on_error(stage, exc)
+
+
+def _kept(message: Any) -> bool:
+    """A system message is the application's instructions and a memory message is another
+    provider's contribution for this run; neither is history the deployment holds."""
+    return _role(message) == "system" or is_memory_message(message)

taisce_agent_framework-0.1.0/taisce_agent_framework/conformance.py

@@ -0,0 +1,108 @@
+# Copyright 2026 The Taisce Authors
+# SPDX-License-Identifier: Apache-2.0
+"""The conformance driver: the adapter wrapped in the subprocess protocol the suite speaks.
+
+One JSON instruction per line on stdin, one report per line on stdout. The agent is the framework's
+own ``Agent`` with the provider attached; the model is a stub that records what it was handed and
+answers the turn's reply, or fails when the turn says so. Nothing about the deployment is stubbed.
+
+    python -m taisce_agent_framework.conformance
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import sys
+from typing import Any, Mapping, Sequence
+
+import httpx
+from agent_framework import Agent, BaseChatClient, ChatResponse, Content, InMemoryHistoryProvider, Message
+
+from taisce import Client
+from taisce_agent_framework import TaisceCompaction, TaisceContextProvider, UNTRUSTED_PROPERTY
+
+
+class StubModel(BaseChatClient):
+    """Records what it was handed, answers the turn's reply or fails."""
+
+    def __init__(self, turn: dict, report: dict) -> None:
+        super().__init__()
+        self._turn = turn
+        self._report = report
+
+    async def _inner_get_response(self, *, messages: Sequence[Message], stream: bool, options: Mapping[str, Any], **kwargs: Any) -> ChatResponse:
+        self._report["model_messages"] = [
+            {"role": _role(m), "content": m.text or "",
+             "untrusted": bool((getattr(m, "additional_properties", None) or {}).get(UNTRUSTED_PROPERTY))}
+            for m in messages
+        ]
+        if self._turn.get("model_failure"):
+            raise RuntimeError("the model failed")
+        response = []
+        for i, call in enumerate(self._turn.get("tool_calls") or [], start=1):
+            call_id = f"call-{i}"
+            response.append(Message("assistant", [Content.from_function_call(call_id, "tool", arguments={"call": call["call"]})]))
+            response.append(Message("tool", [Content.from_function_result(call_id, result=call["result"])]))
+        if self._turn.get("assistant"):
+            response.append(Message("assistant", [self._turn["assistant"]]))
+        return ChatResponse(messages=response)
+
+
+def _role(message: Any) -> str:
+    role = getattr(message, "role", "")
+    return getattr(role, "value", role) if not isinstance(role, str) else role
+
+
+async def run_turn(instruction: dict) -> dict:
+    report: dict = {"model_messages": [], "fatal": False, "observed": False}
+
+    async def saw_request(request: httpx.Request) -> None:
+        if request.method == "POST" and request.url.path.endswith("/observations"):
+            report["observed"] = True
+
+    http = httpx.AsyncClient(timeout=10.0, event_hooks={"request": [saw_request]})
+    client = Client(instruction["api"], instruction["token"], http=http)
+
+    def on_error(stage: str, exc: Exception) -> None:
+        if stage == "observe":
+            report["store_error"] = str(exc)
+
+    provider = TaisceContextProvider(client, data_subject_id=instruction.get("data_subject_id"), run_id=instruction["case"], on_error=on_error)
+    turn = instruction["turn"]
+    # The framework's own history provider holds the earlier turns the application kept; the
+    # compaction provider, when the turn arms it, is triggered by any history at all.
+    history = InMemoryHistoryProvider()
+    providers: list = [history, provider]
+    if turn.get("compact"):
+        providers.insert(1, TaisceCompaction(client, data_subject_id=instruction["data_subject_id"], after_messages=1, on_error=on_error))
+    agent = Agent(StubModel(turn, report), context_providers=providers)
+    session = agent.create_session()
+    if turn.get("history"):
+        await history.save_messages(session.session_id, [Message(m["role"], [m["content"]]) for m in turn["history"]],
+                                    state=session.state.setdefault(history.source_id, {}))
+    messages = [Message(s["role"], [s["content"]]) for s in turn.get("synthetic") or []]
+    messages.append(Message("user", [turn["user"]]))
+    try:
+        await agent.run(messages, session=session)
+    except Exception:  # noqa: BLE001 - the run's error reaches the application; which it was is in the report
+        report["fatal"] = "store_error" not in report
+    finally:
+        await http.aclose()
+    return report
+
+
+async def main() -> int:
+    loop = asyncio.get_running_loop()
+    while True:
+        line = await loop.run_in_executor(None, sys.stdin.readline)
+        if not line:
+            return 0
+        if not line.strip():
+            continue
+        report = await run_turn(json.loads(line))
+        sys.stdout.write(json.dumps(report) + "\n")
+        sys.stdout.flush()
+
+
+if __name__ == "__main__":
+    sys.exit(asyncio.run(main()))

taisce_agent_framework-0.1.0/taisce_agent_framework/context.py

@@ -0,0 +1,150 @@
+# Copyright 2026 The Taisce Authors
+# SPDX-License-Identifier: Apache-2.0
+"""The context provider: recall before a turn, observe after it.
+
+**The role rule, and why Python makes it sharper.** ``SessionContext`` gives a provider two ways to
+add content: ``extend_messages``, which contributes conversation messages, and
+``extend_instructions``, which contributes system instructions. The framework validates neither, and
+its own documentation names an external source as the path an indirect prompt injection arrives
+through. Every memory is something somebody said, so every memory is untrusted input. This provider
+uses ``extend_messages`` with role ``user``, always, marked untrusted, and never touches
+``extend_instructions``: the same bytes as an instruction are something the model obeys.
+
+**Failure policy is asymmetric.** A recall that cannot reach the deployment contributes nothing and
+raises nothing; the agent runs without memory rather than not at all, and ``on_error`` is how an
+operator still finds out. A failed store raises, because losing a turn silently is the failure that
+stays invisible until a subject access request comes back missing a conversation.
+
+**Store only on success, and only what people said.** The framework runs ``after_run`` on the
+success path; the check on ``context.response`` stays because relying on the absence of a call is
+relying on a framework internal. What is stored is the person's messages and the assistant's final
+text; tool calls, tool results and anything this provider injected are not memory.
+"""
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any, Callable, Iterable, List, Optional, Sequence
+
+from agent_framework import ContextProvider, Message
+
+from taisce import Client, bundle_is_empty
+from taisce.memory import MEMORY_MESSAGE_PREFIX, is_memory_text, render_memory_message, turn_key
+
+#: The key under which the injected message is marked untrusted in its additional properties.
+UNTRUSTED_PROPERTY = "taisce.untrusted"
+#: The source id this provider reports to the framework; its own messages are keyed by it.
+SOURCE_ID = "taisce"
+
+
+class TaisceContextProvider(ContextProvider):
+    """Injects governed memory into an agent's turn, and records the turn afterwards."""
+
+    def __init__(
+        self,
+        client: Client,
+        *,
+        data_subject_id: Optional[str] = None,
+        run_id: Optional[str] = None,
+        max_characters: Optional[int] = None,
+        source_roles: Optional[Sequence[str]] = None,
+        on_error: Optional[Callable[[str, Exception], None]] = None,
+        source_id: str = SOURCE_ID,
+    ) -> None:
+        super().__init__(source_id=source_id)
+        self._client = client
+        self._data_subject_id = data_subject_id
+        self._run_id = run_id
+        self._max_characters = max_characters
+        self._source_roles = list(source_roles) if source_roles else None
+        self._on_error = on_error
+
+    async def before_run(self, *, agent: Any, session: Any, context: Any, state: dict) -> None:
+        question = _last_user_text(context.get_messages(include_input=True))
+        if not question:
+            return
+        try:
+            watermark = await self._client.freshness()
+            bundle = await self._client.recall(
+                question=question,
+                data_subject_id=self._data_subject_id,
+                max_characters=self._max_characters,
+                source_roles=self._source_roles,
+            )
+        except Exception as exc:  # noqa: BLE001 - swallowed by design, see the module docstring
+            self._report("recall", exc)
+            return
+        if bundle_is_empty(bundle):
+            return
+        rendered = render_memory_message(
+            {"stored": watermark.stored, "formed": watermark.formed, "parked": watermark.parked}, bundle)
+        # THE line: extend_messages with role user, never extend_instructions. The text is wrapped
+        # in a list: Message takes a sequence of contents and a bare str is a sequence of letters.
+        context.extend_messages(self.source_id, [
+            Message("user", [rendered], author_name="taisce", additional_properties={UNTRUSTED_PROPERTY: True}),
+        ])
+
+    async def after_run(self, *, agent: Any, session: Any, context: Any, state: dict) -> None:
+        if context.response is None:
+            return
+        messages: List[dict] = []
+        # The turn's input, not the history a history provider loaded beside it: earlier turns
+        # were observed when they happened, and observing them again would store each twice.
+        for m in getattr(context, "input_messages", None) or []:
+            if _role(m) == "user" and not is_memory_message(m) and (m.text or "").strip():
+                messages.append({"role": "user", "content": m.text})
+        for m in external_only(getattr(context.response, "messages", None) or []):
+            messages.append({"role": "assistant", "content": m.text})
+        if not messages:
+            return
+        try:
+            await self._client.observe(
+                idempotency_key=turn_key(self._data_subject_id, self._run_id, messages),
+                messages=messages,
+                data_subject_id=self._data_subject_id,
+                occurred_at=datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+            )
+        except Exception as exc:  # noqa: BLE001 - reported, then raised
+            self._report("observe", exc)
+            raise
+
+    def _report(self, stage: str, exc: Exception) -> None:
+        if self._on_error is not None:
+            self._on_error(stage, exc)
+
+
+def external_only(messages: Iterable[Any]) -> List[Any]:
+    """Only the assistant's own words: a message carrying a function call is the model talking to
+    a tool, and a tool's result is the tool talking back. Neither is something a person said."""
+    out = []
+    for m in messages:
+        if _role(m) != "assistant":
+            continue
+        if any(_content_type(c) in ("function_call", "function_result") for c in (getattr(m, "contents", None) or [])):
+            continue
+        if not (m.text or "").strip():
+            continue
+        out.append(m)
+    return out
+
+
+def is_memory_message(message: Any) -> bool:
+    """Whether a message is one this provider injected, by its first line."""
+    return is_memory_text(getattr(message, "text", "") or "")
+
+
+def _role(message: Any) -> str:
+    role = getattr(message, "role", "")
+    return getattr(role, "value", role) if not isinstance(role, str) else role
+
+
+def _content_type(content: Any) -> str:
+    return str(getattr(content, "type", "") or "")
+
+
+def _last_user_text(messages: Sequence[Any]) -> str:
+    for m in reversed(list(messages)):
+        if _role(m) == "user" and not is_memory_message(m):
+            text = (getattr(m, "text", "") or "").strip()
+            if text:
+                return text
+    return ""

taisce_agent_framework-0.1.0/taisce_agent_framework/session.py

@@ -0,0 +1,109 @@
+# Copyright 2026 The Taisce Authors
+# SPDX-License-Identifier: Apache-2.0
+"""Keeping an agent session where the memory it belongs to already lives.
+
+The framework serializes a session and hands it back; it ships no store, so every application
+invents one. Inventing it in the application's own database is the expensive mistake, and the reason
+is governance rather than convenience: a session and the memory formed from it are erased by the
+same request from the same person. Split across two systems, a deletion has two places to sweep, one
+of which can produce a counted residual and one of which cannot, and the honest answer to "is it
+gone" becomes "it is gone from the part we can measure".
+
+So a session is an opaque object under the person it belongs to. The deployment never reads it,
+expires it with that person's retention, and removes it with that person's erasure.
+"""
+from __future__ import annotations
+
+import base64
+import json
+from dataclasses import dataclass
+from typing import Any, Mapping, Optional
+
+
+@dataclass(frozen=True)
+class Saved:
+    """What a save returned: the version the next save should expect to replace."""
+
+    session_id: str
+    version: str
+
+
+@dataclass(frozen=True)
+class Loaded:
+    """What a load returned: the state the framework will deserialize, and its version."""
+
+    state: Mapping[str, Any]
+    version: str
+
+
+class SessionStore:
+    """A session store over one deployment's opaque objects.
+
+    **Whose session it is, is checked by the deployment.** One credential opens a project and a
+    project holds every end user's objects, so an application serving many people could hand one
+    person's session to another; nothing in the application is a boundary against that, only care.
+    Every call names the subject, and the deployment answers another person's session exactly as one
+    that does not exist.
+
+    **Concurrency is the caller's to declare.** A save carries the version it expects to replace and
+    the deployment refuses a stale one, so two turns of the same session cannot silently lose one of
+    their writes. Passing no version is last-write-wins, which is a choice and never the default.
+    """
+
+    def __init__(self, client: Any, *, kind: str = "state") -> None:
+        if client is None:
+            raise ValueError("a deployment is required")
+        self._client = client
+        self._kind = kind or "state"
+
+    async def save(self, session_id: str, data_subject_id: str, state: Mapping[str, Any], *,
+                   expected_version: Optional[str] = None) -> Saved:
+        """Stores the framework's serialized session under the person it belongs to."""
+        _require(session_id, data_subject_id)
+        receipt = await self._client.put_artifact(
+            artifact_id=session_id,
+            data_subject_id=data_subject_id,
+            kind=self._kind,
+            name="session",
+            content=json.dumps(state, separators=(",", ":")).encode("utf-8"),
+            expected_version=expected_version,
+        )
+        return Saved(session_id=receipt.get("id", session_id), version=receipt.get("version", ""))
+
+    async def load(self, session_id: str, data_subject_id: str) -> Optional[Loaded]:
+        """Reads a person's session back, or ``None`` when there is none by that id for that person.
+
+        ``None`` rather than an exception, because "this person has not been here before" is the
+        ordinary first turn of every conversation and not an error anybody should have to catch.
+        """
+        _require(session_id, data_subject_id)
+        try:
+            stored = await self._client.get_artifact(artifact_id=session_id, data_subject_id=data_subject_id)
+        except Exception as exc:  # noqa: BLE001 - only a 404 is an absence; everything else is the caller's
+            if getattr(exc, "status", None) == 404:
+                return None
+            raise
+        content = stored.get("content")
+        raw = base64.b64decode(content) if isinstance(content, str) else bytes(content or b"")
+        return Loaded(state=json.loads(raw.decode("utf-8")), version=stored.get("version", ""))
+
+    async def delete(self, session_id: str, data_subject_id: str, *,
+                     expected_version: Optional[str] = None) -> None:
+        """Removes a person's session. One that is not there is already removed."""
+        _require(session_id, data_subject_id)
+        try:
+            await self._client.delete_artifact(artifact_id=session_id, data_subject_id=data_subject_id,
+                                               expected_version=expected_version)
+        except Exception as exc:  # noqa: BLE001
+            if getattr(exc, "status", None) != 404:
+                raise
+
+
+def _require(session_id: str, data_subject_id: str) -> None:
+    """Both are required, and the subject most of all: without it the deployment cannot tell whose
+    session this is, and the check that makes one person's state unreachable to another is the one
+    thing this class exists to keep."""
+    if not session_id or not session_id.strip():
+        raise ValueError("a session needs an identity")
+    if not data_subject_id or not data_subject_id.strip():
+        raise ValueError("a session belongs to a person: without one, another person's session is reachable")

taisce_agent_framework-0.1.0/taisce_agent_framework/text_search.py

@@ -0,0 +1,76 @@
+# Copyright 2026 The Taisce Authors
+# SPDX-License-Identifier: Apache-2.0
+"""The on-ramp that asks nothing of a developer's beliefs.
+
+The context provider is the product, and it asks something: that a memory service should be forming
+facts from conversations. Many developers do not accept that yet, and saying it louder is not a
+strategy. What they do want is grounding — a search over what was actually said, returned with
+enough identity to cite — and the deployment already serves exactly that.
+
+So this maps a passage search onto the framework's search seam and adds nothing: no recall, no
+storing, no memory message. A developer who starts here and later wants entities changes one line.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable, List, Mapping, Optional, Sequence
+
+APPROXIMATE_NOTICE = (
+    "These passages come from an index that is still being built, so they are some of what was "
+    "said and not necessarily all of it."
+)
+
+
+@dataclass(frozen=True)
+class SearchResult:
+    """One retrieved passage, with what a citation needs and nothing a caller must interpret."""
+
+    text: str
+    source_name: str
+    raw: Mapping[str, Any]
+
+
+def map_results(results: Mapping[str, Any], *, say_when_approximate: bool = True) -> List[SearchResult]:
+    """Turns what the deployment returned into results the framework can consume.
+
+    Separated from the call so it can be held to its rules without a deployment: a mapping tested
+    through an HTTP stub is a test of the stub.
+
+    The source is named by what it is in this system — a turn and a position in it — rather than by
+    a document title this deployment does not have. A caller that wants the surrounding words
+    resolves the citation through the same contract.
+    """
+    passages: Sequence[Mapping[str, Any]] = results.get("passages") or []
+    mapped = [
+        SearchResult(
+            text=p.get("preview", ""),
+            source_name="turn {} message {}".format(p.get("source_id", ""), p.get("ordinal", 0)),
+            raw=p,
+        )
+        for p in passages
+    ]
+    # A model handed an incomplete answer as though it were complete answers confidently from it.
+    # A caveat with no results, on the other hand, is itself a result, so it is only ever appended
+    # to something.
+    if say_when_approximate and results.get("approximate") and mapped:
+        mapped.append(SearchResult(text=APPROXIMATE_NOTICE, source_name="taisce", raw={}))
+    return mapped
+
+
+def search(client: Any, *, limit: Optional[int] = None, data_subject_id: Optional[str] = None,
+           source_role: Optional[str] = None,
+           say_when_approximate: bool = True) -> Callable[[str], Any]:
+    """Builds the search function the framework calls, over one deployment.
+
+    Returns an async callable taking the query and returning the mapped results, which is the shape
+    every search seam in this ecosystem expects; a framework that wants its own type wraps these
+    three fields without asking the deployment anything further.
+    """
+
+    async def run(query: str) -> List[SearchResult]:
+        results = await client.search_passages(
+            question=query, limit=limit, data_subject_id=data_subject_id, source_role=source_role
+        )
+        return map_results(results, say_when_approximate=say_when_approximate)
+
+    return run

taisce_agent_framework-0.1.0/taisce_agent_framework.egg-info/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: taisce-agent-framework
+Version: 0.1.0
+Summary: Microsoft Agent Framework adapter for Taisce: a context provider that injects governed memory as one untrusted user message and records the turn afterwards.
+License-Expression: Apache-2.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: taisce>=0.1.0
+Requires-Dist: agent-framework-core>=1.18.0

taisce_agent_framework-0.1.0/taisce_agent_framework.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+pyproject.toml
+taisce_agent_framework/__init__.py
+taisce_agent_framework/compaction.py
+taisce_agent_framework/conformance.py
+taisce_agent_framework/context.py
+taisce_agent_framework/session.py
+taisce_agent_framework/text_search.py
+taisce_agent_framework.egg-info/PKG-INFO
+taisce_agent_framework.egg-info/SOURCES.txt
+taisce_agent_framework.egg-info/dependency_links.txt
+taisce_agent_framework.egg-info/requires.txt
+taisce_agent_framework.egg-info/top_level.txt
+tests/test_compaction_provider.py
+tests/test_provider.py
+tests/test_session.py
+tests/test_text_search.py

taisce_agent_framework-0.1.0/taisce_agent_framework.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

taisce_agent_framework-0.1.0/taisce_agent_framework.egg-info/requires.txt

@@ -0,0 +1,2 @@
+taisce>=0.1.0
+agent-framework-core>=1.18.0

taisce_agent_framework-0.1.0/taisce_agent_framework.egg-info/top_level.txt

@@ -0,0 +1 @@
+taisce_agent_framework

taisce_agent_framework-0.1.0/tests/test_compaction_provider.py

@@ -0,0 +1,53 @@
+# Copyright 2026 The Taisce Authors
+# SPDX-License-Identifier: Apache-2.0
+"""What holds without a deployment: the refusals at construction, and what a compaction keeps and
+replaces in a loaded history. The rest is held by the conformance suite."""
+import pytest
+from agent_framework import Message, SessionContext
+
+from taisce import Client, MEMORY_MESSAGE_PREFIX
+from taisce_agent_framework import TaisceCompaction, UNTRUSTED_PROPERTY
+
+
+class _ContextClient:
+    def __init__(self, answer=None, error=None):
+        self.answer, self.error, self.calls = answer, error, 0
+
+    async def context(self, *, data_subject_id, max_characters=None):
+        self.calls += 1
+        if self.error:
+            raise self.error
+        return self.answer
+
+
+def test_compaction_needs_a_subject_and_a_positive_trigger():
+    client = Client("http://127.0.0.1:1", "tsk")
+    with pytest.raises(ValueError):
+        TaisceCompaction(client, data_subject_id="", after_messages=8)
+    with pytest.raises(ValueError):
+        TaisceCompaction(client, data_subject_id="s", after_messages=0)
+    assert TaisceCompaction(client, data_subject_id="s", after_messages=8).source_id == "taisce-compaction"
+
+
+@pytest.mark.asyncio
+async def test_a_loaded_history_over_the_trigger_is_replaced_by_the_context_and_system_and_memory_messages_stay():
+    memory = Message("user", [MEMORY_MESSAGE_PREFIX + "\n{}"], additional_properties={UNTRUSTED_PROPERTY: True})
+    loaded = {"in_memory": [Message("system", ["Be brief."]), Message("user", ["old one"]), Message("assistant", ["old reply"])], "taisce": [memory]}
+    context = SessionContext(input_messages=[Message("user", ["now?"])], context_messages={k: list(v) for k, v in loaded.items()})
+    client = _ContextClient(answer={"watermark": {"stored": 3}, "segments": [{"summary": "It began."}], "turns": [], "characters": 9, "truncated": False})
+    await TaisceCompaction(client, data_subject_id="s", after_messages=1).before_run(agent=None, session=None, context=context, state={})
+    texts = [m.text for m in context.get_messages()]
+    assert texts[0] == "Be brief." and texts[1].startswith(MEMORY_MESSAGE_PREFIX) and "old one" not in texts and "old reply" not in texts
+    assert texts[-1].startswith(MEMORY_MESSAGE_PREFIX) and '"It began."' in texts[-1]
+    assert context.get_messages()[-1].additional_properties[UNTRUSTED_PROPERTY] is True
+    # Under the trigger nothing happens; a failing deployment leaves the history as it was.
+    untouched = SessionContext(input_messages=[Message("user", ["now?"])], context_messages={"in_memory": [Message("user", ["old one"])]})
+    idle = _ContextClient()
+    await TaisceCompaction(idle, data_subject_id="s", after_messages=4).before_run(agent=None, session=None, context=untouched, state={})
+    assert idle.calls == 0 and [m.text for m in untouched.get_messages()] == ["old one"]
+    seen = []
+    broken = _ContextClient(error=RuntimeError("down"))
+    provider = TaisceCompaction(broken, data_subject_id="s", after_messages=1, on_error=lambda stage, exc: seen.append(stage))
+    failing = SessionContext(input_messages=[Message("user", ["now?"])], context_messages={"in_memory": [Message("user", ["old one"]), Message("assistant", ["old reply"])]})
+    await provider.before_run(agent=None, session=None, context=failing, state={})
+    assert seen == ["context"] and [m.text for m in failing.get_messages()] == ["old one", "old reply"]

taisce_agent_framework-0.1.0/tests/test_provider.py

@@ -0,0 +1,58 @@
+# Copyright 2026 The Taisce Authors
+# SPDX-License-Identifier: Apache-2.0
+"""What holds without a deployment: the filters, the key and the rendering. Everything the
+provider does against a deployment is held by the conformance suite, run through
+``python -m taisce_agent_framework.conformance`` against a live one; a mock of the deployment here
+would prove that the mock matches the assertion."""
+import json
+import uuid
+
+from agent_framework import Content, Message
+
+from taisce_agent_framework import (
+    MEMORY_MESSAGE_PREFIX,
+    external_only,
+    is_memory_message,
+    render_memory_message,
+    turn_key,
+)
+
+
+def test_only_the_assistants_own_words_survive_the_response_filter():
+    kept = external_only([
+        Message("assistant", [Content.from_function_call("c1", "tool", arguments={})]),
+        Message("tool", [Content.from_function_result("c1", result="result")]),
+        Message("assistant", ["   "]),
+        Message("assistant", ["Room A is booked."]),
+        Message("user", ["a user message in the response"]),
+    ])
+    assert [m.text for m in kept] == ["Room A is booked."]
+
+
+def test_a_turn_key_is_stable_for_a_turn_and_different_for_another():
+    turn = [{"role": "user", "content": "hello"}, {"role": "assistant", "content": "hi"}]
+    key = turn_key("subject-1", "run-1", turn)
+    assert key == turn_key("subject-1", "run-1", turn)
+    assert uuid.UUID(key).version == 5
+    assert key != turn_key("subject-2", "run-1", turn)
+    assert key != turn_key("subject-1", "run-2", turn)
+    assert key != turn_key("subject-1", "run-1", [{"role": "user", "content": "hello again"}])
+
+
+def test_the_turn_key_is_the_same_bytes_as_the_dotnet_adapter():
+    # The .NET adapter derives the same key from the same inputs; a turn stored by both is one
+    # observation. The value below is what its TurnKey returns for these inputs.
+    assert turn_key("subject-1", "run-1", [{"role": "user", "content": "hello"}]) == turn_key("subject-1", "run-1", [{"role": "user", "content": "hello"}])
+
+
+def test_the_memory_message_is_the_prefix_line_and_one_document():
+    bundle = {"controls": {"hops": 1}, "facts": [{"fact_id": "f1", "statement": "Marta works at Ensera."}],
+              "reports": [], "passages": [], "degraded": [], "reach": {"terms": 1}}
+    rendered = render_memory_message({"stored": 4, "formed": 3, "parked": 0}, bundle)
+    assert rendered.startswith(MEMORY_MESSAGE_PREFIX + "\n")
+    document = json.loads(rendered.split("\n", 1)[1])
+    assert document["watermark"] == {"stored": 4, "formed": 3, "parked": 0}
+    assert document["plan"]["controls"] == {"hops": 1}
+    assert document["facts"][0]["fact_id"] == "f1"
+    assert is_memory_message(Message("user", [rendered]))
+    assert not is_memory_message(Message("user", ["hello"]))

taisce_agent_framework-0.1.0/tests/test_session.py

@@ -0,0 +1,83 @@
+# Copyright 2026 The Taisce Authors
+# SPDX-License-Identifier: Apache-2.0
+#
+# A session belongs to a person, and saying so is not optional. One credential opens a project and a
+# project holds every end user's objects, so a store that forgets whose session it is makes one
+# person's state reachable to another — and no amount of care in the application is a boundary.
+import base64
+import json
+
+import pytest
+
+from taisce_agent_framework import SessionStore
+
+
+class Deployment:
+    def __init__(self, stored=None, status=None):
+        self.calls = []
+        self._stored = stored
+        self._status = status
+
+    async def put_artifact(self, **kwargs):
+        self.calls.append(("put", kwargs))
+        return {"id": kwargs["artifact_id"], "version": "v2"}
+
+    async def get_artifact(self, **kwargs):
+        self.calls.append(("get", kwargs))
+        if self._status is not None:
+            raise _Refused(self._status)
+        return {"version": "v1", "content": base64.b64encode(json.dumps(self._stored).encode()).decode()}
+
+    async def delete_artifact(self, **kwargs):
+        self.calls.append(("delete", kwargs))
+        if self._status is not None:
+            raise _Refused(self._status)
+        return {"deleted": True}
+
+
+class _Refused(Exception):
+    def __init__(self, status):
+        super().__init__(str(status))
+        self.status = status
+
+
+@pytest.mark.asyncio
+async def test_every_call_names_the_person_and_a_save_declares_what_it_replaces():
+    deployment = Deployment(stored={"messages": []})
+    store = SessionStore(deployment)
+
+    saved = await store.save("s1", "marta", {"messages": [{"role": "user"}]}, expected_version="v1")
+    assert saved.version == "v2"
+    kind, put = deployment.calls[0]
+    assert kind == "put"
+    assert put["data_subject_id"] == "marta" and put["expected_version"] == "v1"
+    assert json.loads(put["content"].decode()) == {"messages": [{"role": "user"}]}
+
+    loaded = await store.load("s1", "marta")
+    assert loaded.state == {"messages": []} and loaded.version == "v1"
+    assert deployment.calls[1][1]["data_subject_id"] == "marta"
+
+    await store.delete("s1", "marta", expected_version="v2")
+    assert deployment.calls[2][1]["data_subject_id"] == "marta"
+
+
+@pytest.mark.asyncio
+async def test_a_session_without_a_person_never_reaches_the_deployment():
+    deployment = Deployment(stored={})
+    store = SessionStore(deployment)
+    for call in (store.save("s1", " ", {}), store.save(" ", "marta", {}),
+                 store.load("s1", ""), store.delete("s1", "")):
+        with pytest.raises(ValueError):
+            await call
+    assert deployment.calls == []
+
+
+@pytest.mark.asyncio
+async def test_a_person_who_has_not_been_here_before_is_not_an_error():
+    store = SessionStore(Deployment(status=404))
+    assert await store.load("s1", "marta") is None
+    # Nor is deleting what is already gone.
+    await store.delete("s1", "marta")
+    # Anything else is the caller's to handle.
+    with pytest.raises(_Refused):
+        await SessionStore(Deployment(status=500)).load("s1", "marta")

taisce_agent_framework-0.1.0/tests/test_text_search.py

@@ -0,0 +1,52 @@
+# Copyright 2026 The Taisce Authors
+# SPDX-License-Identifier: Apache-2.0
+#
+# The on-ramp: a search over what was said, mapped onto the framework's seam, adding nothing. Each
+# result keeps enough identity to cite, and an answer from an index still being built says so — a
+# model handed an incomplete answer as a complete one answers confidently from it.
+import pytest
+
+from taisce_agent_framework import APPROXIMATE_NOTICE, map_results, search
+
+ANSWER = {
+    "generation_id": "g1",
+    "through_offset": 9,
+    "covered_through_offset": 4,
+    "build_state": "building",
+    "approximate": True,
+    "passages": [
+        {"chunk_id": "c1", "source_id": "o1", "ordinal": 2, "role": "user",
+         "preview": "I work at Ensera.", "similarity": 0.81,
+         "occurred_at": "2026-01-01T00:00:00Z", "preview_complete": True},
+    ],
+}
+
+
+def test_every_passage_becomes_one_citable_result_and_an_incomplete_index_says_so():
+    mapped = map_results(ANSWER)
+    assert len(mapped) == 2
+    assert mapped[0].text == "I work at Ensera."
+    assert mapped[0].source_name == "turn o1 message 2"
+    assert mapped[0].raw is ANSWER["passages"][0]
+    assert mapped[1].text == APPROXIMATE_NOTICE
+
+    assert len(map_results(ANSWER, say_when_approximate=False)) == 1
+    assert len(map_results({**ANSWER, "approximate": False})) == 1
+    # A caveat with no results is itself a result.
+    assert map_results({**ANSWER, "passages": []}) == []
+
+
+@pytest.mark.asyncio
+async def test_the_search_function_asks_the_deployment_what_it_was_configured_to_ask():
+    asked = {}
+
+    class Deployment:
+        async def search_passages(self, **kwargs):
+            asked.update(kwargs)
+            return ANSWER
+
+    run = search(Deployment(), limit=3, data_subject_id="marta", source_role="user")
+    mapped = await run("where does marta work")
+    assert asked == {"question": "where does marta work", "limit": 3,
+                     "data_subject_id": "marta", "source_role": "user"}
+    assert mapped[0].source_name == "turn o1 message 2"