sediment-api 0.6.1__tar.gz → 0.7.1__tar.gz

{sediment_api-0.6.1 → sediment_api-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sediment-api
-Version: 0.6.1
+Version: 0.7.1
 Summary: Sediment ingest API: facts in through three doors
 Project-URL: Source, https://github.com/sediment-ai/sediment
 Project-URL: Documentation, https://github.com/sediment-ai/sediment/tree/main/docs
@@ -9,12 +9,12 @@ Project-URL: Changelog, https://github.com/sediment-ai/sediment/blob/main/CHANGE
 License-Expression: AGPL-3.0-or-later
 License-File: LICENSE
 Requires-Python: >=3.12
-Requires-Dist: anyio>=4.15.1
+Requires-Dist: anyio>=4.16.0
 Requires-Dist: fastapi>=0.142.2
 Requires-Dist: httpx>=0.27
-Requires-Dist: pydantic-settings>=2.16.0
-Requires-Dist: sediment-capture==0.6.1
-Requires-Dist: sediment-core==0.6.1
-Requires-Dist: sediment-derive==0.6.1
-Requires-Dist: sediment-export==0.6.1
+Requires-Dist: pydantic-settings>=2.16.2
+Requires-Dist: sediment-capture==0.7.1
+Requires-Dist: sediment-core==0.7.1
+Requires-Dist: sediment-derive==0.7.1
+Requires-Dist: sediment-export==0.7.1
 Requires-Dist: uvicorn>=0.54.0

{sediment_api-0.6.1 → sediment_api-0.7.1}/pyproject.toml

@@ -1,21 +1,21 @@
 [project]
 name = "sediment-api"
-version = "0.6.1"
+version = "0.7.1"
 description = "Sediment ingest API: facts in through three doors"
 requires-python = ">=3.12"
 license = "AGPL-3.0-or-later"
 license-files = ["LICENSE"]
 dependencies = [
     # Security floor for HTTPX/Starlette, including installations from wheels.
-    "anyio>=4.15.1",
+    "anyio>=4.16.0",
     "fastapi>=0.142.2",
     "httpx>=0.27",
     "uvicorn>=0.54.0",
-    "pydantic-settings>=2.16.0",
-    "sediment-core==0.6.1",
-    "sediment-capture==0.6.1",
-    "sediment-derive==0.6.1",
-    "sediment-export==0.6.1",
+    "pydantic-settings>=2.16.2",
+    "sediment-core==0.7.1",
+    "sediment-capture==0.7.1",
+    "sediment-derive==0.7.1",
+    "sediment-export==0.7.1",
 ]
 
 [project.urls]

{sediment_api-0.6.1 → sediment_api-0.7.1}/sediment_api/__init__.py

@@ -3,4 +3,4 @@
 
 # Single source for the API version string — FastAPI's ``app.version``
 # (reported by /health) and GET /v1/me both read it, so the two cannot drift.
-__version__ = "0.6.1"
+__version__ = "0.7.1"

{sediment_api-0.6.1 → sediment_api-0.7.1}/sediment_api/deps.py

@@ -14,8 +14,7 @@ from __future__ import annotations
 import json
 import secrets
 from dataclasses import dataclass
-from typing import Literal
-from typing import Any
+from typing import Any, Literal
 
 from fastapi import Depends, Header, HTTPException, Request
 from sediment_capture import verify_signature

sediment_api-0.7.1/sediment_api/ingest_envelopes.py

@@ -0,0 +1,55 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+"""Typed response envelopes for the ingest doors (AGENTS.md §API Conventions).
+
+Routers return these instead of bare dicts so the generated OpenAPI names
+each outcome. The wire bodies stay exactly the documented shapes.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Annotated, Literal
+
+from pydantic import ConfigDict, Field
+
+_CLOSED = ConfigDict(extra="forbid")
+
+
+@dataclass(frozen=True)
+class IngestReceipt:
+    """The retained Fact for one single-Fact ingest request."""
+
+    __pydantic_config__ = _CLOSED
+
+    fact_id: Annotated[
+        str,
+        Field(description="ID of the retained Fact, including on redelivery"),
+    ]
+    stored: Annotated[
+        bool,
+        Field(
+            description=(
+                "False when a redelivery collapsed on a UNIQUE index (ADR "
+                "0003); success, not an error"
+            )
+        ),
+    ]
+
+
+@dataclass(frozen=True)
+class IngestSkipped:
+    """A declined delivery that the sender shouldn't retry."""
+
+    __pydantic_config__ = _CLOSED
+
+    skipped: Literal[True]
+    reason: Annotated[
+        str, Field(description="Why the route stored nothing for this delivery")
+    ]
+
+
+@dataclass(frozen=True)
+class OTLPExportLogsResponse:
+    """The empty OTLP/HTTP JSON ExportLogsServiceResponse: full success."""
+
+    __pydantic_config__ = _CLOSED

{sediment_api-0.6.1 → sediment_api-0.7.1}/sediment_api/main.py

@@ -34,7 +34,7 @@ from sqlalchemy.exc import (
 from . import __version__
 from .config import settings
 from .deps import BodySizeLimitMiddleware
-from .routers import ci_vendor, forge, gateway, otlp, query, reports, v1
+from .routers import ci_vendor, compute, forge, gateway, otlp, query, reports, v1
 from .workers import WorkerSupervisor
 
 logging.basicConfig(
@@ -229,6 +229,7 @@ app.include_router(gateway.router, prefix="/ingest")
 # free for a vendor-neutral push door later.
 app.include_router(forge.router, prefix="/ingest/github")
 app.include_router(ci_vendor.router, prefix="/ingest")
+app.include_router(compute.router, prefix="/ingest")
 # OTLP receiver: path fixed by the exporter (<endpoint>/v1/logs), no prefix.
 app.include_router(otlp.router)
 app.include_router(query.router, prefix="/query")

sediment_api-0.7.1/sediment_api/reports/compute_report.py

@@ -0,0 +1,157 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+"""Compute report: Session completion time by final Compute allocation.
+
+sediment report compute --org acme-corp
+sediment report compute --org acme-corp --json
+sediment report compute --org acme-corp --rows-out sessions.jsonl
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+
+from sediment_core import normalize_org_id
+from sediment_derive import ComputeArm
+from sediment_export import (
+    ComputeReport,
+    DurationDistribution,
+    compute_report_to_json,
+    compute_timings_to_export_rows,
+    generate_compute_report_result,
+    write_jsonl,
+)
+from sediment_export.significance import MedianDifference
+
+from ..database import add_database_url_argument, one_shot_fact_store
+
+
+def _arm(arm: ComputeArm) -> str:
+    cpu = "unknown" if arm.cpu_millicores is None else f"{arm.cpu_millicores}m"
+    memory = (
+        "unknown" if arm.memory_bytes is None else f"{arm.memory_bytes / 2**30:.2f}GiB"
+    )
+    return f"{arm.allocation_source.value} cpu={cpu} memory={memory}"
+
+
+def _seconds(milliseconds: float | None) -> str:
+    return "n/a" if milliseconds is None else f"{milliseconds / 1000:.1f}s"
+
+
+def _distribution(name: str, distribution: DurationDistribution) -> str:
+    return (
+        f"{name} median={_seconds(distribution.median)} "
+        f"p25={_seconds(distribution.p25)} p75={_seconds(distribution.p75)}"
+    )
+
+
+def _difference(name: str, difference: MedianDifference) -> str:
+    sizes = f"n={difference.n_a}/{difference.n_b}"
+    if difference.insufficient_data:
+        return f"    {name}: insufficient data ({sizes})"
+    flag = " small-n" if difference.small_n else ""
+    level = round(difference.confidence * 100)
+    return (
+        f"    {name}: {_seconds(difference.difference)} "
+        f"[{level}% CI {_seconds(difference.ci_low)}, "
+        f"{_seconds(difference.ci_high)}] {sizes}{flag}"
+    )
+
+
+def _print_table(report: ComputeReport) -> None:
+    print(f"Sessions with a Compute allocation: {report.sessions_with_allocation}")
+    print(f"timed Sessions: {report.timed_sessions}")
+    skipped = ", ".join(f"{key}={value}" for key, value in report.skipped.items())
+    print(f"skipped Sessions: {skipped}")
+    print(
+        "randomized Sessions reassigned to another source: "
+        f"{report.randomized_reassigned_sessions} "
+        "(excluded from randomized comparisons)"
+    )
+    if not report.arms:
+        print("arms: no data")
+    for summary in report.arms:
+        print(
+            f"{_arm(summary.arm)}: n={summary.sessions} "
+            f"(allocation changed in {summary.allocation_changed_sessions})"
+        )
+        for name in ("elapsed_ms", "model_ms", "between_calls_ms"):
+            print(f"  {_distribution(name, getattr(summary, name))}")
+    if report.comparisons:
+        print("comparisons (arm B minus arm A; negative means arm B finished faster):")
+    for comparison in report.comparisons:
+        reading = "randomized" if comparison.randomized else "observational"
+        print(f"  {_arm(comparison.arm_a)} -> {_arm(comparison.arm_b)} ({reading})")
+        print(_difference("elapsed_ms", comparison.elapsed_ms))
+        print(_difference("between_calls_ms", comparison.between_calls_ms))
+    print(f"provenance: {report.provenance}")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Return the argv contract consumed by the generated CLI reference."""
+    parser = argparse.ArgumentParser(
+        prog="compute_report",
+        description=(
+            "Compare Session completion time across final Compute allocations."
+        ),
+    )
+    parser.add_argument(
+        "--org",
+        default=os.environ.get("SEDIMENT_ORG_ID"),
+        required=not os.environ.get("SEDIMENT_ORG_ID"),
+        help="org id (default: $SEDIMENT_ORG_ID)",
+    )
+    parser.add_argument(
+        "--json", action="store_true", help="emit JSON instead of a text report"
+    )
+    parser.add_argument(
+        "--rows-out",
+        metavar="FILE",
+        help="write one Session compute timing per line to FILE as JSONL",
+    )
+    add_database_url_argument(parser)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    try:
+        org_id = normalize_org_id(args.org)
+    except ValueError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 2
+    with one_shot_fact_store(
+        args.database_url, operation="generate compute report"
+    ) as store:
+        result = generate_compute_report_result(store, org_id)
+    if args.json:
+        print(json.dumps(compute_report_to_json(result.report), indent=2))
+    else:
+        _print_table(result.report)
+    if args.rows_out:
+        try:
+            write_result = write_jsonl(
+                compute_timings_to_export_rows(result.timings),
+                args.rows_out,
+                split_enabled=False,
+            )
+        except (OSError, TypeError, ValueError) as exc:
+            print(f"error: couldn't write compute timing rows: {exc}", file=sys.stderr)
+            return 1
+        if write_result.written:
+            print(
+                f"wrote {len(result.timings)} compute timing rows to {args.rows_out}",
+                file=sys.stderr,
+            )
+        else:
+            print(
+                f"wrote 0 compute timing rows; left {args.rows_out} unchanged",
+                file=sys.stderr,
+            )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{sediment_api-0.6.1 → sediment_api-0.7.1}/sediment_api/routers/ci_vendor.py

@@ -16,8 +16,6 @@ collapses redeliveries; ``stored: false`` means success, not an error.
 
 from __future__ import annotations
 
-from typing import Any
-
 from fastapi import APIRouter, Depends
 from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
 from sediment_core import (
@@ -40,6 +38,7 @@ from sediment_core import (
 
 from ..config import settings
 from ..deps import get_store, verify_ingest_token
+from ..ingest_envelopes import IngestReceipt
 
 router = APIRouter(tags=["ci-vendor"])
 
@@ -121,7 +120,7 @@ def ingest_ci_vendor(
     body: VendorCIRequest,
     _: None = Depends(verify_ingest_token),
     store: FactStore = Depends(get_store),
-) -> dict[str, Any]:
+) -> IngestReceipt:
     outcome = CIOutcome(
         org_id=settings.org_id,
         provider=body.provider,
@@ -146,4 +145,4 @@ def ingest_ci_vendor(
         source_event_id=body.source_event_id,
     )
     receipt = store.store_ci_outcome_receipt(outcome)
-    return {"fact_id": receipt.fact_id, "stored": receipt.stored}
+    return IngestReceipt(fact_id=receipt.fact_id, stored=receipt.stored)

sediment_api-0.7.1/sediment_api/routers/compute.py

@@ -0,0 +1,101 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+"""
+POST /ingest/compute — vendor-neutral Compute allocation ingest.
+
+The execution platform that runs a coding agent (a sandbox, a container
+scheduler, a CI runner) posts the CPU and memory limits a Session's
+environment received: once when the environment starts, and again on every
+resize. ``allocation_source`` records who chose the allocation, so the
+compute report never presents an agent's own request as an assigned
+treatment. The sender is bearer-authenticated; Sediment stores its assertion
+and does not verify it against the platform.
+
+Dedup: the store's ``uq_compute_allocations_natural`` UNIQUE index on the
+complete allocation collapses redeliveries; ``stored: false`` means success,
+not an error.
+"""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+from sediment_core import (
+    ComputeAllocation,
+    ComputeAllocationSource,
+    FactStore,
+    NonEmptyId,
+    UtcRepresentableDatetime,
+)
+
+from ..config import settings
+from ..deps import get_store, verify_ingest_token
+from ..ingest_envelopes import IngestReceipt
+
+router = APIRouter(tags=["compute"])
+
+
+class ComputeAllocationRequest(BaseModel):
+    """One Compute allocation as the execution platform observed it.
+
+    ``extra="forbid"`` so a caller naming an org or fabricating fields is
+    rejected at the boundary. The limits carry the Fact's own bounds, so
+    malformed input 422s at the door rather than inside the handler."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    session_id: NonEmptyId = Field(
+        description=(
+            "The Session ID the coding agent's captured Facts carry, such as "
+            "the gateway Session header"
+        )
+    )
+    allocation_source: ComputeAllocationSource = Field(
+        description=(
+            "Who chose the allocation: default, agent_request, operator, or "
+            "randomized. Only randomized supports a causal comparison"
+        )
+    )
+    cpu_millicores: int | None = Field(
+        default=None,
+        ge=1,
+        le=2**63 - 1,
+        strict=True,
+        description="CPU limit in millicores; 1000 is one CPU",
+    )
+    memory_bytes: int | None = Field(
+        default=None,
+        ge=1,
+        le=2**63 - 1,
+        strict=True,
+        description="Memory limit in bytes",
+    )
+    occurred_at: UtcRepresentableDatetime = Field(
+        description=(
+            "When the allocation took effect, by the sender's clock; it must "
+            "convert to a UTC instant"
+        )
+    )
+
+    @model_validator(mode="after")
+    def _require_limit(self):
+        if self.cpu_millicores is None and self.memory_bytes is None:
+            raise ValueError("send cpu_millicores, memory_bytes, or both")
+        return self
+
+
+@router.post("/compute")
+def ingest_compute_allocation(
+    body: ComputeAllocationRequest,
+    _: None = Depends(verify_ingest_token),
+    store: FactStore = Depends(get_store),
+) -> IngestReceipt:
+    allocation = ComputeAllocation(
+        org_id=settings.org_id,
+        session_id=body.session_id,
+        allocation_source=body.allocation_source,
+        cpu_millicores=body.cpu_millicores,
+        memory_bytes=body.memory_bytes,
+        occurred_at=body.occurred_at,
+    )
+    receipt = store.store_compute_allocation_receipt(allocation)
+    return IngestReceipt(fact_id=receipt.fact_id, stored=receipt.stored)

{sediment_api-0.6.1 → sediment_api-0.7.1}/sediment_api/routers/forge.py

@@ -2,8 +2,8 @@
 """
 GitHub webhook ingest routes, mounted under /ingest/github in main.py.
 
-One module for both routes: they share the HMAC intake and differ only in
-which parser/store pair the payload walks through. The signature is
+One module for all four routes: they share the HMAC intake and differ only
+in which parser/store pair the payload walks through. The signature is
 verified BEFORE the event type is examined: a wrong-secret delivery must
 401 even for event types a route skips, or GitHub's setup ping would
 green-light a misconfigured webhook. The push route stores the Push fact,
@@ -19,7 +19,6 @@ from __future__ import annotations
 import logging
 from collections import Counter
 from datetime import UTC, datetime
-from typing import Any
 
 from fastapi import APIRouter, BackgroundTasks, Depends, Header, Request
 from sediment_capture import (
@@ -53,6 +52,7 @@ from starlette.concurrency import run_in_threadpool
 
 from ..config import settings
 from ..deps import get_store, read_verified_webhook
+from ..ingest_envelopes import IngestReceipt, IngestSkipped
 
 logger = logging.getLogger("sediment.api.forge")
 router = APIRouter(tags=["forge"])
@@ -295,15 +295,15 @@ async def ingest_push(
     x_hub_signature_256: str | None = Header(None),
     x_github_event: str = Header(...),
     store: FactStore = Depends(get_store),
-) -> dict[str, Any]:
+) -> IngestReceipt | IngestSkipped:
     payload = await read_verified_webhook(request, x_hub_signature_256)
     # GitHub delivers every subscribed event (incl. ping) to the one URL;
     # the X-GitHub-Event header is the discriminator.
     if x_github_event != "push":
-        return {"skipped": True, "reason": "not a push event"}
+        return IngestSkipped(skipped=True, reason="not a push event")
     push = parse_push(payload, org_id=settings.org_id, github_host=settings.github_host)
     if push is None:
-        return {"skipped": True, "reason": "not a storable push"}
+        return IngestSkipped(skipped=True, reason="not a storable push")
     receipt = await run_in_threadpool(store.store_push_receipt, push)
     fetch_repo, fetch_clone_url = push.repo, push.clone_url
     push = receipt.fact
@@ -325,12 +325,11 @@ async def ingest_push(
             push, fetch_repo=fetch_repo, fetch_clone_url=fetch_clone_url
         )
         background.add_task(request.app.state.workers.wait_background, task)
-    return {"fact_id": push.push_id, "stored": stored}
+    return IngestReceipt(fact_id=push.push_id, stored=stored)
 
 
 @router.post(
     "/repository",
-    response_model=dict[str, Any],
     responses={
         503: {
             "description": "Mirror work capacity, storage, or execution budget exceeded."
@@ -343,11 +342,11 @@ async def ingest_repository(
     x_github_event: str = Header(...),
     x_github_delivery: str | None = Header(None),
     store: FactStore = Depends(get_store),
-) -> dict[str, Any]:
+) -> IngestReceipt | IngestSkipped:
     """Store an immutable rename receipt independently of mirror availability."""
     payload = await read_verified_webhook(request, x_hub_signature_256)
     if x_github_event != "repository":
-        return {"skipped": True, "reason": "not a repository event"}
+        return IngestSkipped(skipped=True, reason="not a repository event")
     rename, reason = parse_repository_rename(
         payload,
         org_id=settings.org_id,
@@ -356,12 +355,12 @@ async def ingest_repository(
     )
     if rename is None:
         assert reason is not None
-        return {"skipped": True, "reason": reason.value}
+        return IngestSkipped(skipped=True, reason=reason.value)
     receipt = await run_in_threadpool(store.store_repository_rename_receipt, rename)
     logger.info(
         "repository_rename_stored fact_id=%s stored=%s", receipt.fact_id, receipt.stored
     )
-    return {"fact_id": receipt.fact_id, "stored": receipt.stored}
+    return IngestReceipt(fact_id=receipt.fact_id, stored=receipt.stored)
 
 
 @router.post("/ci")
@@ -371,10 +370,10 @@ async def ingest_ci(
     x_github_event: str = Header(...),
     x_github_delivery: str | None = Header(None),
     store: FactStore = Depends(get_store),
-) -> dict[str, Any]:
+) -> IngestReceipt | IngestSkipped:
     payload = await read_verified_webhook(request, x_hub_signature_256)
     if x_github_event != "workflow_run":
-        return {"skipped": True, "reason": "not a workflow_run event"}
+        return IngestSkipped(skipped=True, reason="not a workflow_run event")
     outcome = parse_workflow_run(
         payload,
         org_id=settings.org_id,
@@ -382,7 +381,7 @@ async def ingest_ci(
         github_host=settings.github_host,
     )
     if outcome is None:
-        return {"skipped": True, "reason": "not a completed workflow_run"}
+        return IngestSkipped(skipped=True, reason="not a completed workflow_run")
     receipt = await run_in_threadpool(store.store_ci_outcome_receipt, outcome)
     outcome = receipt.fact
     stored = receipt.stored
@@ -393,7 +392,7 @@ async def ingest_ci(
         outcome.repo,
         outcome.result,
     )
-    return {"fact_id": outcome.outcome_id, "stored": stored}
+    return IngestReceipt(fact_id=outcome.outcome_id, stored=stored)
 
 
 @router.post("/pull-request")
@@ -403,10 +402,10 @@ async def ingest_pull_request(
     x_github_event: str = Header(...),
     x_github_delivery: str | None = Header(None),
     store: FactStore = Depends(get_store),
-) -> dict[str, Any]:
+) -> IngestReceipt | IngestSkipped:
     payload = await read_verified_webhook(request, x_hub_signature_256)
     if x_github_event != "pull_request":
-        return {"skipped": True, "reason": "not a pull_request event"}
+        return IngestSkipped(skipped=True, reason="not a pull_request event")
     if payload.get("action") == "closed":
         merge = parse_pull_request_merge(
             payload,
@@ -415,7 +414,7 @@ async def ingest_pull_request(
             github_host=settings.github_host,
         )
         if merge is None:
-            return {"skipped": True, "reason": "not a merged pull_request"}
+            return IngestSkipped(skipped=True, reason="not a merged pull_request")
         receipt = await run_in_threadpool(store.store_pull_request_merge_receipt, merge)
         merge = receipt.fact
         stored = receipt.stored
@@ -426,7 +425,7 @@ async def ingest_pull_request(
             merge.repo,
             merge.pr_number,
         )
-        return {"fact_id": merge.merge_id, "stored": stored}
+        return IngestReceipt(fact_id=merge.merge_id, stored=stored)
 
     revision, skip_reason = parse_pull_request_revision(
         payload,
@@ -436,7 +435,7 @@ async def ingest_pull_request(
     )
     if revision is None:
         assert skip_reason is not None
-        return {"skipped": True, "reason": skip_reason.value}
+        return IngestSkipped(skipped=True, reason=skip_reason.value)
     receipt = await run_in_threadpool(
         store.store_pull_request_revision_receipt, revision
     )
@@ -449,4 +448,4 @@ async def ingest_pull_request(
         revision.repo,
         revision.pr_number,
     )
-    return {"fact_id": revision.revision_id, "stored": stored}
+    return IngestReceipt(fact_id=revision.revision_id, stored=stored)

{sediment_api-0.6.1 → sediment_api-0.7.1}/sediment_api/routers/gateway.py

@@ -20,6 +20,7 @@ from sediment_core.models import AwareDatetime
 
 from ..config import settings
 from ..deps import get_store, verify_ingest_token
+from ..ingest_envelopes import IngestReceipt, IngestSkipped
 
 logger = logging.getLogger("sediment.api.gateway")
 router = APIRouter(tags=["gateway"])
@@ -57,7 +58,7 @@ def ingest_gateway(
     body: GatewayIngestRequest,
     _: None = Depends(verify_ingest_token),
     store: FactStore = Depends(get_store),
-) -> dict[str, Any]:
+) -> IngestReceipt | IngestSkipped:
     adapter = ADAPTERS.get(body.provider)
     if adapter is None:
         raise HTTPException(
@@ -85,7 +86,7 @@ def ingest_gateway(
                 body.provider,
                 body.payload.get("litellm_call_id"),
             )
-            return {"skipped": True, "reason": "no_session"}
+            return IngestSkipped(skipped=True, reason="no_session")
 
     try:
         inference_call = adapter.normalize(
@@ -134,4 +135,4 @@ def ingest_gateway(
         receipt.fact_id,
         receipt.stored,
     )
-    return {"fact_id": receipt.fact_id, "stored": receipt.stored}
+    return IngestReceipt(fact_id=receipt.fact_id, stored=receipt.stored)

{sediment_api-0.6.1 → sediment_api-0.7.1}/sediment_api/routers/otlp.py

@@ -12,7 +12,6 @@ from __future__ import annotations
 
 import json
 import logging
-from typing import Any
 
 from fastapi import APIRouter, Depends, HTTPException, Request
 from sediment_capture import parse_otlp_logs
@@ -21,6 +20,7 @@ from starlette.concurrency import run_in_threadpool
 
 from ..config import settings
 from ..deps import get_store, verify_ingest_token
+from ..ingest_envelopes import OTLPExportLogsResponse
 
 logger = logging.getLogger("sediment.api.otlp")
 router = APIRouter(tags=["otlp"])
@@ -31,7 +31,7 @@ async def ingest_otlp_logs(
     request: Request,
     _: None = Depends(verify_ingest_token),
     store: FactStore = Depends(get_store),
-) -> dict[str, Any]:
+) -> OTLPExportLogsResponse:
     try:
         payload = await request.json()
     except HTTPException:
@@ -98,7 +98,7 @@ async def ingest_otlp_logs(
         },
     )
     # Empty ExportLogsServiceResponse = full success (OTLP/HTTP JSON).
-    return {}
+    return OTLPExportLogsResponse()
 
 
 def _store_translated_facts(