idun-sdk 0.1.0__tar.gz

idun_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: idun-sdk
+Version: 0.1.0
+Summary: Thin client + CLI for Azure AI Foundry agent NatureLM-Idun-5-MoE
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Dynamic: classifier
+Dynamic: requires-python
+Dynamic: summary

idun_sdk-0.1.0/README.md

@@ -0,0 +1,120 @@
+# Idun SDK
+
+Thin client + CLI for the **NatureLM-Idun-5-MoE** agent on **Azure AI Foundry**.
+Stdlib-only (no httpx / azure.identity) so it runs headless on Termux/Android.
+
+Idun is a **tool agent** (it calls `web_search`, `memory_search`). This SDK
+surfaces the full agent trajectory — not just the final chat text — so you can
+see every reasoning step and tool call instead of a black-box chatbot wheel.
+
+## Install
+
+```bash
+cd idun_sdk
+pip install -e .        # provides the `idun` command
+```
+
+## Authenticate (device-code, Entra)
+
+```bash
+idun login
+# opens https://microsoft.com/devicelogin — enter the printed code,
+# sign in with your QMFI-Research admin account.
+# Token is saved to ~/foundry_token.txt (FOUNDRY_TOKEN).
+```
+
+## Use
+
+```bash
+# final answer only
+idun chat "Fasse in einem Satz zusammen, was Contoso im Bereich Nachhaltigkeit kommuniziert."
+
+# full agent trajectory (reasoning + web_search tool steps)
+idun trace "Use web_search to find the current CEO of Contoso and report the name."
+```
+
+### Python
+
+```python
+from idun import IdunClient
+res = IdunClient().complete("Your prompt here")
+print(res.text)            # final answer
+for s in res.steps:        # agent trajectory
+    if s.kind == "tool":
+        print("TOOL", s.tool, s.status, s.query)
+    else:
+        print("REASON", s.text[:80])
+```
+
+## Request shape (verified working)
+
+```
+POST {base}/api/projects/{project}/agents/{agent}/endpoint/protocols/openai/responses?api-version=2025-05-15-preview
+Authorization: Bearer <FOUNDRY_TOKEN>
+Content-Type: application/json
+
+{"model": "model-router", "input": "<prompt string>", "max_output_tokens": 4096}
+```
+
+Notes:
+- `model` MUST be `"model-router"` (the agent id is already in the URL).
+- Do **not** send a `tools` key — the agent owns its capabilities; doing so
+  returns `400 invalid_payload`.
+- The answer is in `output[].content[].text`; tool calls appear as
+  `web_search_call` items with `action.queries` and `status`.
+
+## Files
+
+- `idun/client.py` — `IdunClient` (sync `complete()`) + `_normalize_output()`
+- `idun/auth.py` — stdlib device-code `login()` + `load_token()`
+- `idun_cli.py` — `idun login | chat | trace`
+
+## MCP — agent + docs
+
+Idun is available as an MCP server **and** has a GitMCP docs mirror, so other
+agents can both call Idun and read its documentation without hallucinating.
+
+### 1. Idun MCP server (stdlib-only, local)
+
+`idun_mcp.py` is a zero-dependency stdio MCP server — no FastMCP / httpx
+needed (runs on bare Python, ideal for Termux/Android).
+
+```bash
+python3 idun_mcp.py        # stdio MCP server
+```
+
+Tools exposed:
+- `idun_chat(prompt)` — final answer text
+- `idun_trace(prompt)` — full agent trajectory (steps + text)
+
+Add to any MCP client (e.g. Cursor `~/.cursor/mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "idun": { "command": "python3", "args": ["/abs/path/idun-sdk/idun_mcp.py"] }
+  }
+}
+```
+
+### 2. GitMCP docs mirror (remote, zero-setup)
+
+Point an MCP client at the GitMCP URL to give it live access to this repo's
+docs + code (prefers `llms.txt`):
+
+```
+https://gitmcp.io/qapdex-maker/idun-sdk/sse
+```
+
+For stdio-only clients (Claude Desktop, Cline, Msty):
+
+```json
+{ "mcpServers": { "idun-docs": { "command": "npx", "args": ["mcp-remote", "https://gitmcp.io/qapdex-maker/idun-sdk/sse"] } } }
+```
+
+**Recommended combo for a foreign agent:** both `idun` (calls the agent) and
+`idun-docs` (reads the SDK docs) — it can invoke Idun *and* look up the exact
+`IdunClient` signature on its own.
+
+[![GitMCP](https://img.shields.io/endpoint?url=https://gitmcp.io/badge/qapdex-maker/idun-sdk)](https://gitmcp.io/qapdex-maker/idun-sdk)
+

idun_sdk-0.1.0/idun/__init__.py

@@ -0,0 +1,6 @@
+"""Idun SDK public API."""
+from .client import IdunClient, IdunResult, Step, _normalize_output
+from .auth import login, load_token
+
+__all__ = ["IdunClient", "IdunResult", "Step", "login", "load_token", "_normalize_output"]
+__version__ = "0.1.0"

idun_sdk-0.1.0/idun/auth.py

@@ -0,0 +1,75 @@
+"""Stdlib-only Entra device-code login for Idun (no azure.identity needed).
+
+Flow: POST devicecode -> show user code -> poll token endpoint until granted
+-> save FOUNDRY_TOKEN to ~/foundry_token.txt. Same endpoint/params the Azure
+CLI uses, so it works headless on Termux.
+"""
+from __future__ import annotations
+
+import json
+import os
+import time
+import urllib.parse
+import urllib.request
+from typing import Optional
+
+TENANT = "885f01ab-7364-4484-be0a-231d541c9e7f"
+SCOPE = "https://ai.azure.com/.default"
+CLIENT_ID = "04b07795-8ddb-461a-bbee-02f9e1bf7b46"  # Azure CLI first-party app
+TOKEN_FILE = os.path.join(os.path.expanduser("~"), "foundry_token.txt")
+CODE_FILE = os.path.join(os.path.expanduser("~"), "foundry_code.txt")
+AUTH_ENDPOINT = f"https://login.microsoftonline.com/{TENANT}/oauth2/v2.0"
+
+
+def _post(url: str, form: dict, headers=None) -> dict:
+    data = urllib.parse.urlencode(form).encode()
+    req = urllib.request.Request(url, data=data, headers=headers or {"Content-Type": "application/x-www-form-urlencoded"}, method="POST")
+    with urllib.request.urlopen(req, timeout=60) as r:
+        return json.loads(r.read())
+
+
+def login() -> str:
+    # 1) request device code
+    dc = _post(f"{AUTH_ENDPOINT}/devicecode", {"client_id": CLIENT_ID, "scope": SCOPE})
+    msg = (f"To sign in, use a web browser to open {dc['verification_uri']} "
+           f"and enter the code {dc['user_code']} to authenticate.")
+    with open(CODE_FILE, "w") as f:
+        f.write(msg + "\n")
+    print(msg, flush=True)
+    print(f"(code also saved to {CODE_FILE})", flush=True)
+
+    # 2) poll for token
+    interval = int(dc.get("interval", 5))
+    expires = time.time() + float(dc.get("expires_in", 900))
+    form = {
+        "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
+        "client_id": CLIENT_ID,
+        "device_code": dc["device_code"],
+    }
+    while time.time() < expires:
+        try:
+            tok = _post(f"{AUTH_ENDPOINT}/token", form)
+            if "access_token" in tok:
+                token = tok["access_token"]
+                with open(TOKEN_FILE, "w") as f:
+                    f.write(token)
+                print(f"TOKEN_OK len={len(token)}")
+                print(f"saved to {TOKEN_FILE}")
+                return token
+        except urllib.error.HTTPError as e:
+            err = json.loads(e.read().decode("utf-8", "replace"))
+            if err.get("error") == "authorization_pending":
+                time.sleep(interval)
+                continue
+            if err.get("error") == "slow_down":
+                interval += 5
+                time.sleep(interval)
+                continue
+            raise RuntimeError(f"Login failed: {err.get('error_description', err)}")
+    raise RuntimeError("Login timed out. Re-run `idun login`.")
+
+
+def load_token() -> Optional[str]:
+    if os.path.exists(TOKEN_FILE):
+        return open(TOKEN_FILE).read().strip()
+    return None

idun_sdk-0.1.0/idun/client.py

@@ -0,0 +1,130 @@
+"""Idun SDK — thin client + CLI for Azure AI Foundry agent NatureLM-Idun-5-MoE.
+
+Stdlib-only (urllib, no httpx / azure.identity) so it runs on Termux/Android.
+Mirrors the working request shape discovered during integration:
+  POST {base}/api/projects/{project}/agents/{agent}/endpoint/protocols/openai/responses?api-version={ver}
+  body: {"model": "model-router", "input": "<prompt string>", "max_output_tokens": N}
+  auth: Entra Bearer token (FOUNDRY_TOKEN), scope https://ai.azure.com/.default
+
+Returns both the final text AND the agent trajectory ("steps"):
+  - kind=reasoning  -> assistant plan / reasoning text
+  - kind=tool        -> web_search call: {tool, query, status}
+This is what makes Idun a visible tool-agent, not a chatbot wheel.
+"""
+from __future__ import annotations
+
+import json
+import os
+import time
+import urllib.error
+import urllib.request
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+# --- defaults (verified working for qmfi-research-project, 2026-07-25) ---
+FOUNDRY_BASE_DEFAULT = "https://qmfi-research-project-resource.services.ai.azure.com"
+FOUNDRY_PROJECT_DEFAULT = "qmfi-research-project"
+FOUNDRY_AGENT_DEFAULT = "NatureLM-Idun-5-MoE"
+FOUNDRY_API_VERSION_DEFAULT = "2025-05-15-preview"
+FOUNDRY_SCOPE = "https://ai.azure.com/.default"
+FOUNDRY_TENANT = "885f01ab-7364-4484-be0a-231d541c9e7f"
+TOKEN_FILE = os.path.join(os.path.expanduser("~"), "foundry_token.txt")
+
+
+@dataclass
+class Step:
+    kind: str  # "reasoning" | "tool" | "message"
+    text: str = ""
+    tool: str = ""
+    query: str = ""
+    status: str = ""
+    id: str = ""
+
+
+@dataclass
+class IdunResult:
+    text: str
+    steps: List[Step] = field(default_factory=list)
+    model: str = ""
+    raw: dict = field(default_factory=dict)
+
+
+def _normalize_output(data: dict) -> IdunResult:
+    """Convert Foundry Responses output[] into (final_text, steps[])."""
+    text = ""
+    steps: List[Step] = []
+    for o in data.get("output", []):
+        otype = o.get("type")
+        if otype == "message" and o.get("role") == "assistant":
+            t = "".join(c.get("text", "") for c in o.get("content", []) if c.get("type") == "output_text")
+            if t:
+                text += t + "\n\n"
+                steps.append(Step(kind="reasoning", text=t))
+        elif otype == "web_search_call":
+            action = o.get("action") or {}
+            q = action.get("query") or ""
+            if action.get("queries"):
+                q = action["queries"][0]
+            steps.append(Step(kind="tool", tool="web_search", query=q,
+                              status=o.get("status", "unknown"), id=o.get("id")))
+        elif otype == "message":
+            t = "".join(c.get("text", "") for c in o.get("content", []) if c.get("type") == "output_text")
+            if t:
+                text += t + "\n\n"
+                steps.append(Step(kind="message", text=t))
+    return IdunResult(text=text.strip(), steps=steps,
+                      model=data.get("model", ""), raw=data)
+
+
+class IdunClient:
+    def __init__(
+        self,
+        token: Optional[str] = None,
+        base: str = FOUNDRY_BASE_DEFAULT,
+        project: str = FOUNDRY_PROJECT_DEFAULT,
+        agent: str = FOUNDRY_AGENT_DEFAULT,
+        api_version: str = FOUNDRY_API_VERSION_DEFAULT,
+        timeout: int = 600,
+    ) -> None:
+        self.token = token or os.environ.get("FOUNDRY_TOKEN")
+        self.base = base.rstrip("/")
+        self.project = project
+        self.agent = agent
+        self.api_version = api_version
+        self.timeout = timeout
+
+    def _url(self) -> str:
+        return (f"{self.base}/api/projects/{self.project}/agents/{self.agent}"
+                f"/endpoint/protocols/openai/responses?api-version={self.api_version}")
+
+    def _headers(self) -> dict:
+        if not self.token:
+            raise RuntimeError("No FOUNDRY_TOKEN set. Run `idun login` or export FOUNDRY_TOKEN.")
+        return {"Authorization": f"Bearer {self.token}", "Content-Type": "application/json"}
+
+    def _build_payload(self, prompt: str, max_output_tokens: int = 4096) -> dict:
+        """Verified working request shape for the agent-in-URL endpoint.
+
+        Model MUST stay 'model-router' (agent name -> invalid_payload).
+        No 'tools' key (agent owns capabilities -> 400 invalid_payload).
+        """
+        return {
+            "model": "model-router",
+            "input": prompt,
+            "max_output_tokens": max_output_tokens,
+        }
+
+    def complete(self, prompt: str, max_output_tokens: int = 4096) -> IdunResult:
+        """Synchronous completion. Returns final text + agent trajectory."""
+        payload = self._build_payload(prompt, max_output_tokens)
+        req = urllib.request.Request(
+            self._url(), data=json.dumps(payload).encode("utf-8"),
+            headers=self._headers(), method="POST",
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                data = json.loads(resp.read())
+        except urllib.error.HTTPError as e:
+            body = e.read().decode("utf-8", "replace")[:400]
+            raise RuntimeError(f"Foundry HTTP {e.code}: {body}") from e
+        return _normalize_output(data)

idun_sdk-0.1.0/idun_cli.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""Idun CLI — terminal client for NatureLM-Idun-5-MoE on Azure AI Foundry.
+
+Usage:
+  idun login                 # device-code Entra login -> ~/foundry_token.txt
+  idun chat  "your prompt"   # print final answer
+  idun trace "your prompt"   # print agent trajectory (reasoning + web_search steps)
+
+Stdlib-only; needs FOUNDRY_TOKEN (from `idun login` or env).
+"""
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+
+from idun import IdunClient, login as do_login, load_token
+
+
+def _client() -> IdunClient:
+    tok = load_token() or os.environ.get("FOUNDRY_TOKEN")
+    if not tok:
+        sys.exit("No token. Run `idun login` first (or export FOUNDRY_TOKEN).")
+    return IdunClient(token=tok)
+
+
+def cmd_login(_args):
+    do_login()
+
+
+def cmd_chat(args):
+    c = _client()
+    res = c.complete(args.prompt, max_output_tokens=args.max_tokens)
+    print(res.text)
+
+
+def cmd_trace(args):
+    c = _client()
+    res = c.complete(args.prompt, max_output_tokens=args.max_tokens)
+    print(f"Model: {res.model}\n")
+    print("AGENT TRACE ({})".format(len(res.steps)))
+    print("=" * 60)
+    for i, s in enumerate(res.steps, 1):
+        if s.kind == "tool":
+            print(f"  {i:>2}. TOOL   web_search  [{s.status}]")
+            print(f"        query: {s.query}")
+        else:
+            head = s.text.replace("\n", " ").strip()[:90]
+            label = "REASON" if s.kind == "reasoning" else "MSG"
+            print(f"  {i:>2}. {label}  {head}{'…' if len(s.text) > 90 else ''}")
+    print("=" * 60)
+    print("\nFINAL ANSWER:")
+    print(res.text)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="idun", description="NatureLM-Idun-5-MoE CLI")
+    sub = p.add_subparsers(dest="command", required=True)
+
+    sub.add_parser("login", help="device-code Entra login").set_defaults(func=cmd_login)
+
+    pc = sub.add_parser("chat", help="print final answer")
+    pc.add_argument("prompt")
+    pc.add_argument("--max-tokens", type=int, default=4096, dest="max_tokens")
+    pc.set_defaults(func=cmd_chat)
+
+    pt = sub.add_parser("trace", help="print agent trajectory (steps)")
+    pt.add_argument("prompt")
+    pt.add_argument("--max-tokens", type=int, default=4096, dest="max_tokens")
+    pt.set_defaults(func=cmd_trace)
+    return p
+
+
+def main():
+    args = build_parser().parse_args()
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

idun_sdk-0.1.0/idun_mcp.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+"""Idun MCP server (stdio, stdlib-only).
+
+Exposes the NatureLM-Idun-5-MoE agent as MCP tools so other agents/clients
+can call it. No FastMCP / httpx / pydantic: implements the minimal MCP
+JSON-RPC-over-stdio wire contract with only the standard library.
+
+Tools:
+  idun_chat(prompt) -> final answer text
+  idun_trace(prompt) -> full agent trajectory (steps + text)
+
+Auth: reads FOUNDRY_TOKEN / FOUNDRY_RESOURCE / FOUNDRY_AGENT from the
+environment (same as the CLI). Entra device-code login is the caller's job
+(`idun login`); this server only relays.
+
+Run:
+  python3 idun_mcp.py            # stdio MCP server
+"""
+import sys, os, json
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from idun.client import IdunClient
+
+
+TOOLS = [
+    {
+        "name": "idun_chat",
+        "description": "Ask the NatureLM-Idun-5-MoE agent a question and return the final answer text.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {"prompt": {"type": "string",
+                                      "description": "The user prompt for the Idun agent."}},
+            "required": ["prompt"],
+        },
+    },
+    {
+        "name": "idun_trace",
+        "description": ("Ask the Idun agent and return the FULL trajectory (reasoning + "
+                        "tool calls) plus the final text — for auditable, visible tool-agent use."),
+        "inputSchema": {
+            "type": "object",
+            "properties": {"prompt": {"type": "string",
+                                      "description": "The user prompt for the Idun agent."}},
+            "required": ["prompt"],
+        },
+    },
+]
+
+
+def _tool_chat(prompt):
+    cli = IdunClient()
+    res = dict(cli.complete(prompt))
+    return res.get("text", "")
+
+
+def _tool_trace(prompt):
+    cli = IdunClient()
+    res = dict(cli.complete(prompt))
+    return {
+        "text": res.get("text", ""),
+        "steps": res.get("steps", []),
+        "model": res.get("model", ""),
+    }
+
+
+def _dispatch(req):
+    method = req.get("method")
+    rid = req.get("id")
+    params = req.get("params") or {}
+
+    if method == "initialize":
+        return {
+            "jsonrpc": "2.0", "id": rid,
+            "result": {
+                "protocolVersion": "2024-11-05",
+                "capabilities": {"tools": {}},
+                "serverInfo": {"name": "idun-mcp", "version": "0.1.0"},
+            },
+        }
+    if method == "notifications/initialized":
+        return None  # notification: no response
+    if method == "tools/list":
+        return {"jsonrpc": "2.0", "id": rid, "result": {"tools": TOOLS}}
+    if method == "tools/call":
+        name = params.get("name")
+        args = params.get("arguments") or {}
+        try:
+            if name == "idun_chat":
+                out = _tool_chat(args.get("prompt", ""))
+                content = [{"type": "text", "text": str(out)}]
+            elif name == "idun_trace":
+                out = _tool_trace(args.get("prompt", ""))
+                content = [{"type": "text", "text": json.dumps(out, ensure_ascii=False, indent=2)}]
+            else:
+                raise ValueError(f"unknown tool: {name}")
+            return {"jsonrpc": "2.0", "id": rid, "result": {"content": content}}
+        except Exception as e:
+            return {"jsonrpc": "2.0", "id": rid,
+                    "error": {"code": -32603, "message": str(e)[:400]}}
+    if rid is not None:
+        return {"jsonrpc": "2.0", "id": rid,
+                "error": {"code": -32601, "message": f"method not found: {method}"}}
+    return None
+
+
+def main():
+    for line in sys.stdin:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            req = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        resp = _dispatch(req)
+        if resp is not None:
+            sys.stdout.write(json.dumps(resp, ensure_ascii=False) + "\n")
+            sys.stdout.flush()
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: idun-sdk
+Version: 0.1.0
+Summary: Thin client + CLI for Azure AI Foundry agent NatureLM-Idun-5-MoE
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Dynamic: classifier
+Dynamic: requires-python
+Dynamic: summary

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

@@ -0,0 +1,13 @@
+README.md
+idun_cli.py
+idun_mcp.py
+setup.py
+idun/__init__.py
+idun/auth.py
+idun/client.py
+idun_sdk.egg-info/PKG-INFO
+idun_sdk.egg-info/SOURCES.txt
+idun_sdk.egg-info/dependency_links.txt
+idun_sdk.egg-info/entry_points.txt
+idun_sdk.egg-info/top_level.txt
+tests/test_sdk.py

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

@@ -0,0 +1 @@
+

idun_sdk-0.1.0/idun_sdk.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+idun = idun_cli:main

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

@@ -0,0 +1,3 @@
+idun
+idun_cli
+idun_mcp

idun_sdk-0.1.0/setup.cfg

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

idun_sdk-0.1.0/setup.py

@@ -0,0 +1,18 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="idun-sdk",
+    version="0.1.0",
+    description="Thin client + CLI for Azure AI Foundry agent NatureLM-Idun-5-MoE",
+    packages=find_packages(),
+    py_modules=["idun_cli", "idun_mcp"],
+    python_requires=">=3.8",
+    # stdlib-only: no runtime dependencies. Works headless on Termux.
+    install_requires=[],
+    entry_points={"console_scripts": ["idun=idun_cli:main"]},
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    ],
+)

idun_sdk-0.1.0/tests/test_sdk.py

@@ -0,0 +1,65 @@
+"""pytest suite for idun-sdk (offline; no live Foundry call).
+
+Covers:
+- trajectory normalization (output array -> steps + text)
+- request payload shape (model-router, no tools key)
+- CLI entrypoint exposes login/chat/trace
+- package importable as `idun`
+"""
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from idun.client import IdunClient, _normalize_output
+
+
+SAMPLE = {
+    "model": "gpt-5.4-2026-03-05",
+    "output": [
+        {"type": "message", "role": "assistant",
+         "content": [{"type": "output_text", "text": "Ich habe recherchiert: "}]},
+        {"type": "reasoning", "text": "Ich pruefe, ob Contoso eine reale Marke ist."},
+        {"type": "message", "role": "assistant",
+         "content": [{"type": "output_text", "text": "Contoso setzt auf Kreislauf."}]},
+        {"type": "web_search_call", "action": {"query": "Contoso Nachhaltigkeit"},
+         "status": "completed", "id": "call_1"},
+    ],
+}
+
+
+def test_normalize_trajectory():
+    out = _normalize_output(SAMPLE)
+    assert out.text.startswith("Ich habe recherchiert")
+    assert "Contoso setzt auf Kreislauf" in out.text
+    assert out.model == "gpt-5.4-2026-03-05"
+    steps = out.steps
+    kinds = [s.kind for s in steps]
+    assert "reasoning" in kinds
+    assert "tool" in kinds
+    tool = next(s for s in steps if s.kind == "tool")
+    assert tool.tool == "web_search"
+    assert tool.query == "Contoso Nachhaltigkeit"
+    assert tool.status == "completed"
+
+
+def test_request_payload_shape():
+    cli = IdunClient.__new__(IdunClient)
+    payload = cli._build_payload("Hallo")
+    assert payload["model"] == "model-router"
+    assert payload["input"] == "Hallo"
+    assert payload["max_output_tokens"] == 4096
+    assert "tools" not in payload
+
+
+def test_cli_entrypoint():
+    from idun_cli import build_parser
+    parser = build_parser()
+    args = parser.parse_args(["trace", "Was macht Contoso?"])
+    assert args.command == "trace"
+    assert args.prompt == "Was macht Contoso?"
+
+
+def test_package_importable():
+    import idun
+    assert hasattr(idun, "__version__")