daknode-mcp 0.3.3__tar.gz → 0.3.5__tar.gz

{daknode_mcp-0.3.3/daknode_mcp.egg-info → daknode_mcp-0.3.5}/PKG-INFO

@@ -1,21 +1,25 @@
 Metadata-Version: 2.4
 Name: daknode-mcp
-Version: 0.3.3
+Version: 0.3.5
 Summary: DakNode's email and calendar API tools over local and authenticated remote MCP.
 Project-URL: Homepage, https://daknode.com
-Project-URL: Documentation, https://daknode.com/developers
+Project-URL: Documentation, https://daknode.com/integrations/mcp/
+Project-URL: Security, https://daknode.com/security/reporting/
+Keywords: daknode,mcp,email,calendar,developer-tools
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: daknode<0.4,>=0.3.8
+Requires-Dist: daknode<0.4,>=0.3.9
 Requires-Dist: mcp<3,>=2.2
 
 # DakNode MCP server
 
 <!-- mcp-name: io.github.Subodh103/daknode -->
 
-DakNode 0.3.3 exposes email and Calendar API tools over **stdio**, with a separate authenticated
-Streamable HTTP process prepared for hosting. No hosted deployment or OAuth
-availability is implied by this checkout.
+DakNode MCP 0.3.5 exposes 21 email and calendar API tools over **stdio**,
+including availability, reliable booking, reminders and recurring-event edits.
+An authenticated hosted endpoint is also available at
+`https://api.daknode.com/mcp`; local installation does not connect to it or
+authorize any action automatically.
 
 ## Install
 
@@ -43,8 +47,13 @@ checkout, `"command": "python", "args": ["-m", "mcp_server.server"]`.
 
 The key comes from the environment and **never from a command-line argument**:
 argv is visible to every process through `ps`, and shells record it in history.
-The server refuses to start without it, so a misconfiguration is obvious at
-launch rather than looking like a broken tool.
+Version 0.3.5 supports
+credential-free local `initialize`, `tools/list` and empty `prompts/list`, so a
+client can inspect static schemas before setup. Every operation still requires credentials and fails with structured
+`authentication_required` setup guidance if the key is missing; no API request
+is sent. Configure the key privately, then restart/reconnect the client.
+Hosted MCP authentication and permission-filtered discovery are unchanged:
+this is not anonymous access to the remote endpoint or to customer data.
 
 ## Tools
 
@@ -53,9 +62,31 @@ launch rather than looking like a broken tool.
 
 Calendar: `get_calendar_event` · `create_calendar_event` · `update_calendar_event`
 · `cancel_calendar_event` · `respond_calendar_event` · `send_calendar_invitations`.
-These six tools require generated Python SDK **>=0.3.8,<0.4** and each invokes
-exactly its published operation once. No Calendar deletion, exception, agenda,
-or unrelated management tools are added by this release.
+This release requires Python SDK **>=0.3.9,<0.4** and also exposes
+`list_calendar_events`, `get_calendar_agenda`,
+`get_calendar_free_busy`, `get_calendar_availability`, `book_calendar_event`,
+`get_calendar_reminders`, `set_calendar_reminders`, and `edit_calendar_series`.
+Each invokes exactly one corresponding generated SDK operation. No Calendar
+deletion or unrelated management tools are added.
+
+The list/agenda/free-busy/availability/reminder reads require `calendar.read`;
+booking, reminder changes and series edits require `calendar.write`.
+Free-busy takes `request: {start, end}`. Availability takes `request` with that
+window plus IANA `timezone`, `working_hours: [{weekday, start, end}]` (Monday=0,
+local HH:MM), `duration_minutes`, `step_minutes` and optional before/after buffer
+minutes. Windows are explicit and at most 31 days. Slots are advisory and
+inbox-only: external attendee calendars are unknown, never represented as free.
+Booking takes `booking: {event, buffer_before_minutes?, buffer_after_minutes?}`
+and a stable `idempotency_key`; only one non-recurring timed event is accepted.
+
+Reminder writes take `revision` and `minutes_before_start`: up to five unique
+integer offsets from 0 through 40320, or `[]` to clear. They configure developer
+notifications, not attendee email. Series edits take `revision`, a stable retry
+key, and `edit: {scope, recurrence_id?, cancelled?, changes?}` with explicit
+`occurrence`, `series` or `following` scope. A following edit can return a new
+future event ID; other edits return the original event. Optional patch fields
+and explicit nulls retain their API meaning. No conflict triggers an automatic
+revision refresh or retry.
 
 `get_calendar_event` requires `calendar.read`. The Calendar writes require
 `calendar.write`; invitation dispatch additionally requires `messages.send`.
@@ -224,7 +255,7 @@ Two distinct capabilities are implemented and wire-tested:
 
 The default verifier exposes `message.received` for `messages.read`, and
 `calendar.event.created`, `.updated`, `.cancelled`, `.responded`, `.starting`,
-`.ending` for `calendar.read`. Inbox-scoped credentials can subscribe only to
+`.ending`, `.reminder` for `calendar.read` in this source checkout. Inbox-scoped credentials can subscribe only to
 their own inbox. Event payloads contain identifiers and calendar revision only;
 no bodies, subjects, event titles, attendees or email addresses. This is not a
 claim of AgentMail's exact spam/authentication filtering policy: retained mail

daknode_mcp-0.3.3/PKG-INFO → daknode_mcp-0.3.5/README.md

@@ -1,21 +1,12 @@
-Metadata-Version: 2.4
-Name: daknode-mcp
-Version: 0.3.3
-Summary: DakNode's email and calendar API tools over local and authenticated remote MCP.
-Project-URL: Homepage, https://daknode.com
-Project-URL: Documentation, https://daknode.com/developers
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-Requires-Dist: daknode<0.4,>=0.3.8
-Requires-Dist: mcp<3,>=2.2
-
 # DakNode MCP server
 
 <!-- mcp-name: io.github.Subodh103/daknode -->
 
-DakNode 0.3.3 exposes email and Calendar API tools over **stdio**, with a separate authenticated
-Streamable HTTP process prepared for hosting. No hosted deployment or OAuth
-availability is implied by this checkout.
+DakNode MCP 0.3.5 exposes 21 email and calendar API tools over **stdio**,
+including availability, reliable booking, reminders and recurring-event edits.
+An authenticated hosted endpoint is also available at
+`https://api.daknode.com/mcp`; local installation does not connect to it or
+authorize any action automatically.
 
 ## Install
 
@@ -43,8 +34,13 @@ checkout, `"command": "python", "args": ["-m", "mcp_server.server"]`.
 
 The key comes from the environment and **never from a command-line argument**:
 argv is visible to every process through `ps`, and shells record it in history.
-The server refuses to start without it, so a misconfiguration is obvious at
-launch rather than looking like a broken tool.
+Version 0.3.5 supports
+credential-free local `initialize`, `tools/list` and empty `prompts/list`, so a
+client can inspect static schemas before setup. Every operation still requires credentials and fails with structured
+`authentication_required` setup guidance if the key is missing; no API request
+is sent. Configure the key privately, then restart/reconnect the client.
+Hosted MCP authentication and permission-filtered discovery are unchanged:
+this is not anonymous access to the remote endpoint or to customer data.
 
 ## Tools
 
@@ -53,9 +49,31 @@ launch rather than looking like a broken tool.
 
 Calendar: `get_calendar_event` · `create_calendar_event` · `update_calendar_event`
 · `cancel_calendar_event` · `respond_calendar_event` · `send_calendar_invitations`.
-These six tools require generated Python SDK **>=0.3.8,<0.4** and each invokes
-exactly its published operation once. No Calendar deletion, exception, agenda,
-or unrelated management tools are added by this release.
+This release requires Python SDK **>=0.3.9,<0.4** and also exposes
+`list_calendar_events`, `get_calendar_agenda`,
+`get_calendar_free_busy`, `get_calendar_availability`, `book_calendar_event`,
+`get_calendar_reminders`, `set_calendar_reminders`, and `edit_calendar_series`.
+Each invokes exactly one corresponding generated SDK operation. No Calendar
+deletion or unrelated management tools are added.
+
+The list/agenda/free-busy/availability/reminder reads require `calendar.read`;
+booking, reminder changes and series edits require `calendar.write`.
+Free-busy takes `request: {start, end}`. Availability takes `request` with that
+window plus IANA `timezone`, `working_hours: [{weekday, start, end}]` (Monday=0,
+local HH:MM), `duration_minutes`, `step_minutes` and optional before/after buffer
+minutes. Windows are explicit and at most 31 days. Slots are advisory and
+inbox-only: external attendee calendars are unknown, never represented as free.
+Booking takes `booking: {event, buffer_before_minutes?, buffer_after_minutes?}`
+and a stable `idempotency_key`; only one non-recurring timed event is accepted.
+
+Reminder writes take `revision` and `minutes_before_start`: up to five unique
+integer offsets from 0 through 40320, or `[]` to clear. They configure developer
+notifications, not attendee email. Series edits take `revision`, a stable retry
+key, and `edit: {scope, recurrence_id?, cancelled?, changes?}` with explicit
+`occurrence`, `series` or `following` scope. A following edit can return a new
+future event ID; other edits return the original event. Optional patch fields
+and explicit nulls retain their API meaning. No conflict triggers an automatic
+revision refresh or retry.
 
 `get_calendar_event` requires `calendar.read`. The Calendar writes require
 `calendar.write`; invitation dispatch additionally requires `messages.send`.
@@ -224,7 +242,7 @@ Two distinct capabilities are implemented and wire-tested:
 
 The default verifier exposes `message.received` for `messages.read`, and
 `calendar.event.created`, `.updated`, `.cancelled`, `.responded`, `.starting`,
-`.ending` for `calendar.read`. Inbox-scoped credentials can subscribe only to
+`.ending`, `.reminder` for `calendar.read` in this source checkout. Inbox-scoped credentials can subscribe only to
 their own inbox. Event payloads contain identifiers and calendar revision only;
 no bodies, subjects, event titles, attendees or email addresses. This is not a
 claim of AgentMail's exact spam/authentication filtering policy: retained mail

daknode_mcp-0.3.5/calendar_models.py

@@ -0,0 +1,110 @@
+"""MCP input schemas matching the published Calendar request bodies.
+
+These are validation-only transport models. Generated SDK models still build
+the API requests. Timezone, recurrence and organizer authority stay in the API.
+Explicit nulls and omitted patch fields must remain different.
+"""
+from datetime import date, datetime, timedelta
+from typing import Annotated, Literal
+
+from pydantic import AwareDatetime, BaseModel, ConfigDict, Field, model_validator
+
+Title = Annotated[str, Field(min_length=1, max_length=1000)]
+Timezone = Annotated[str, Field(min_length=1, max_length=100)]
+Description = Annotated[str, Field(max_length=50000)]
+Location = Annotated[str, Field(max_length=2000)]
+Recurrence = Annotated[str, Field(max_length=2000)]
+
+
+class CalendarAttendee(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    email: Annotated[str, Field(min_length=3, max_length=320)]
+    name: Annotated[str, Field(max_length=255)] | None = None
+
+
+Attendees = Annotated[list[CalendarAttendee], Field(max_length=100)]
+
+
+class CalendarCreate(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    title: Title
+    timezone: Timezone
+    all_day: bool = False
+    attendees: Attendees = Field(default_factory=list)
+    description: Description | None = None
+    location: Location | None = None
+    rrule: Recurrence | None = None
+    starts_at: datetime | None = None
+    ends_at: datetime | None = None
+    start_date: date | None = None
+    end_date: date | None = None
+
+
+class CalendarPatch(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    title: Title | None = None
+    timezone: Timezone | None = None
+    all_day: bool | None = None
+    attendees: Attendees | None = None
+    description: Description | None = None
+    location: Location | None = None
+    rrule: Recurrence | None = None
+    starts_at: datetime | None = None
+    ends_at: datetime | None = None
+    start_date: date | None = None
+    end_date: date | None = None
+
+
+class CalendarWindow(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    start: AwareDatetime
+    end: AwareDatetime
+
+    @model_validator(mode="after")
+    def bounded_window(self):
+        if not timedelta(0) < self.end - self.start <= timedelta(days=31):
+            raise ValueError("Scheduling windows must be positive and at most 31 days")
+        return self
+
+
+class CalendarWorkingHours(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    weekday: Annotated[int, Field(ge=0, le=6, strict=True)]
+    start: Annotated[str, Field(pattern=r"^(?:[01]\d|2[0-3]):[0-5]\d$")]
+    end: Annotated[str, Field(pattern=r"^(?:[01]\d|2[0-3]):[0-5]\d$")]
+
+
+BufferMinutes = Annotated[int, Field(ge=0, le=1440, strict=True)]
+PositiveMinutes = Annotated[int, Field(ge=1, le=1440, strict=True)]
+ReminderOffsets = Annotated[list[Annotated[int, Field(ge=0, le=40320, strict=True)]], Field(max_length=5)]
+
+
+class CalendarAvailability(CalendarWindow):
+    timezone: Timezone
+    working_hours: Annotated[list[CalendarWorkingHours], Field(min_length=1, max_length=70)]
+    duration_minutes: PositiveMinutes
+    step_minutes: PositiveMinutes
+    buffer_before_minutes: BufferMinutes = 0
+    buffer_after_minutes: BufferMinutes = 0
+
+
+class CalendarBooking(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    event: CalendarCreate
+    buffer_before_minutes: BufferMinutes = 0
+    buffer_after_minutes: BufferMinutes = 0
+
+    @model_validator(mode="after")
+    def timed_booking(self):
+        if self.event.all_day or self.event.rrule is not None:
+            raise ValueError("Bookings require one non-recurring timed event")
+        CalendarWindow(start=self.event.starts_at, end=self.event.ends_at)
+        return self
+
+
+class CalendarSeriesEdit(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    scope: Literal["occurrence", "following", "series"]
+    recurrence_id: Annotated[str, Field(min_length=1, max_length=40)] | None = None
+    cancelled: Annotated[bool, Field(strict=True)] = False
+    changes: CalendarPatch | None = None

daknode_mcp-0.3.3/README.md → daknode_mcp-0.3.5/daknode_mcp.egg-info/PKG-INFO

@@ -1,10 +1,25 @@
+Metadata-Version: 2.4
+Name: daknode-mcp
+Version: 0.3.5
+Summary: DakNode's email and calendar API tools over local and authenticated remote MCP.
+Project-URL: Homepage, https://daknode.com
+Project-URL: Documentation, https://daknode.com/integrations/mcp/
+Project-URL: Security, https://daknode.com/security/reporting/
+Keywords: daknode,mcp,email,calendar,developer-tools
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: daknode<0.4,>=0.3.9
+Requires-Dist: mcp<3,>=2.2
+
 # DakNode MCP server
 
 <!-- mcp-name: io.github.Subodh103/daknode -->
 
-DakNode 0.3.3 exposes email and Calendar API tools over **stdio**, with a separate authenticated
-Streamable HTTP process prepared for hosting. No hosted deployment or OAuth
-availability is implied by this checkout.
+DakNode MCP 0.3.5 exposes 21 email and calendar API tools over **stdio**,
+including availability, reliable booking, reminders and recurring-event edits.
+An authenticated hosted endpoint is also available at
+`https://api.daknode.com/mcp`; local installation does not connect to it or
+authorize any action automatically.
 
 ## Install
 
@@ -32,8 +47,13 @@ checkout, `"command": "python", "args": ["-m", "mcp_server.server"]`.
 
 The key comes from the environment and **never from a command-line argument**:
 argv is visible to every process through `ps`, and shells record it in history.
-The server refuses to start without it, so a misconfiguration is obvious at
-launch rather than looking like a broken tool.
+Version 0.3.5 supports
+credential-free local `initialize`, `tools/list` and empty `prompts/list`, so a
+client can inspect static schemas before setup. Every operation still requires credentials and fails with structured
+`authentication_required` setup guidance if the key is missing; no API request
+is sent. Configure the key privately, then restart/reconnect the client.
+Hosted MCP authentication and permission-filtered discovery are unchanged:
+this is not anonymous access to the remote endpoint or to customer data.
 
 ## Tools
 
@@ -42,9 +62,31 @@ launch rather than looking like a broken tool.
 
 Calendar: `get_calendar_event` · `create_calendar_event` · `update_calendar_event`
 · `cancel_calendar_event` · `respond_calendar_event` · `send_calendar_invitations`.
-These six tools require generated Python SDK **>=0.3.8,<0.4** and each invokes
-exactly its published operation once. No Calendar deletion, exception, agenda,
-or unrelated management tools are added by this release.
+This release requires Python SDK **>=0.3.9,<0.4** and also exposes
+`list_calendar_events`, `get_calendar_agenda`,
+`get_calendar_free_busy`, `get_calendar_availability`, `book_calendar_event`,
+`get_calendar_reminders`, `set_calendar_reminders`, and `edit_calendar_series`.
+Each invokes exactly one corresponding generated SDK operation. No Calendar
+deletion or unrelated management tools are added.
+
+The list/agenda/free-busy/availability/reminder reads require `calendar.read`;
+booking, reminder changes and series edits require `calendar.write`.
+Free-busy takes `request: {start, end}`. Availability takes `request` with that
+window plus IANA `timezone`, `working_hours: [{weekday, start, end}]` (Monday=0,
+local HH:MM), `duration_minutes`, `step_minutes` and optional before/after buffer
+minutes. Windows are explicit and at most 31 days. Slots are advisory and
+inbox-only: external attendee calendars are unknown, never represented as free.
+Booking takes `booking: {event, buffer_before_minutes?, buffer_after_minutes?}`
+and a stable `idempotency_key`; only one non-recurring timed event is accepted.
+
+Reminder writes take `revision` and `minutes_before_start`: up to five unique
+integer offsets from 0 through 40320, or `[]` to clear. They configure developer
+notifications, not attendee email. Series edits take `revision`, a stable retry
+key, and `edit: {scope, recurrence_id?, cancelled?, changes?}` with explicit
+`occurrence`, `series` or `following` scope. A following edit can return a new
+future event ID; other edits return the original event. Optional patch fields
+and explicit nulls retain their API meaning. No conflict triggers an automatic
+revision refresh or retry.
 
 `get_calendar_event` requires `calendar.read`. The Calendar writes require
 `calendar.write`; invitation dispatch additionally requires `messages.send`.
@@ -213,7 +255,7 @@ Two distinct capabilities are implemented and wire-tested:
 
 The default verifier exposes `message.received` for `messages.read`, and
 `calendar.event.created`, `.updated`, `.cancelled`, `.responded`, `.starting`,
-`.ending` for `calendar.read`. Inbox-scoped credentials can subscribe only to
+`.ending`, `.reminder` for `calendar.read` in this source checkout. Inbox-scoped credentials can subscribe only to
 their own inbox. Event payloads contain identifiers and calendar revision only;
 no bodies, subjects, event titles, attendees or email addresses. This is not a
 claim of AgentMail's exact spam/authentication filtering policy: retained mail

{daknode_mcp-0.3.3 → daknode_mcp-0.3.5}/daknode_mcp.egg-info/SOURCES.txt

@@ -20,4 +20,6 @@ daknode_mcp.egg-info/dependency_links.txt
 daknode_mcp.egg-info/entry_points.txt
 daknode_mcp.egg-info/requires.txt
 daknode_mcp.egg-info/top_level.txt
+tests/test_calendar_scheduling.py
+tests/test_local_discovery.py
 tests/test_write_tools.py

daknode_mcp-0.3.5/daknode_mcp.egg-info/requires.txt

@@ -0,0 +1,2 @@
+daknode<0.4,>=0.3.9
+mcp<3,>=2.2

{daknode_mcp-0.3.3 → daknode_mcp-0.3.5}/event_source.py

@@ -16,7 +16,7 @@ import httpx
 from .server import Authority, DEFAULT_BASE_URL
 
 CALENDAR_NAMES = frozenset(f"calendar.event.{kind}" for kind in
-    ("created", "updated", "cancelled", "responded", "starting", "ending"))
+    ("created", "updated", "cancelled", "responded", "starting", "ending", "reminder"))
 EVENT_NAMES = CALENDAR_NAMES | {"message.received"}
 
 

{daknode_mcp-0.3.3 → daknode_mcp-0.3.5}/identity.py

@@ -18,6 +18,14 @@ PERMISSIONS = {
     "search": frozenset({"search.read"}),
     "send": frozenset({"messages.send"}),
     "get_calendar_event": frozenset({"calendar.read"}),
+    "list_calendar_events": frozenset({"calendar.read"}),
+    "get_calendar_agenda": frozenset({"calendar.read"}),
+    "get_calendar_free_busy": frozenset({"calendar.read"}),
+    "get_calendar_availability": frozenset({"calendar.read"}),
+    "get_calendar_reminders": frozenset({"calendar.read"}),
+    "book_calendar_event": frozenset({"calendar.write"}),
+    "set_calendar_reminders": frozenset({"calendar.write"}),
+    "edit_calendar_series": frozenset({"calendar.write"}),
     "create_calendar_event": frozenset({"calendar.write"}),
     "update_calendar_event": frozenset({"calendar.write"}),
     "cancel_calendar_event": frozenset({"calendar.write"}),

{daknode_mcp-0.3.3 → daknode_mcp-0.3.5}/pyproject.toml

@@ -7,18 +7,20 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "daknode-mcp"
-version = "0.3.3"
+version = "0.3.5"
 description = "DakNode's email and calendar API tools over local and authenticated remote MCP."
 readme = "README.md"
 requires-python = ">=3.10"
+keywords = ["daknode", "mcp", "email", "calendar", "developer-tools"]
 dependencies = [
-    "daknode>=0.3.8,<0.4",
+    "daknode>=0.3.9,<0.4",
     "mcp>=2.2,<3",
 ]
 
 [project.urls]
 Homepage = "https://daknode.com"
-Documentation = "https://daknode.com/developers"
+Documentation = "https://daknode.com/integrations/mcp/"
+Security = "https://daknode.com/security/reporting/"
 
 [project.scripts]
 daknode-mcp = "daknode_mcp.server:main"

{daknode_mcp-0.3.3 → daknode_mcp-0.3.5}/server.py

@@ -32,7 +32,7 @@ from typing import Any, Annotated, Literal
 from uuid import UUID
 
 import httpx
-from pydantic import Field
+from pydantic import AwareDatetime, Field
 
 _SDK = Path(__file__).resolve().parents[1] / "sdk" / "python"
 if str(_SDK) not in sys.path:  # pragma: no cover - import plumbing
@@ -41,14 +41,18 @@ if str(_SDK) not in sys.path:  # pragma: no cover - import plumbing
 from mcp.server.mcpserver import MCPServer  # noqa: E402
 from mcp.types import CallToolResult, TextContent, ToolAnnotations
 from mcp.server.mcpserver.exceptions import ToolError
-from .calendar_models import CalendarCreate, CalendarPatch
+from .calendar_models import (CalendarCreate, CalendarPatch, CalendarWindow,
+    CalendarAvailability, CalendarBooking, CalendarSeriesEdit, ReminderOffsets)
 
 DEFAULT_BASE_URL = "https://api.daknode.com"
 MAX_UPSTREAM_BYTES = 1024 * 1024
 TOOL_NAMES = frozenset({"create_inbox", "list_threads", "list_messages", "get_thread",
                         "get_message", "search", "send", "get_calendar_event",
                         "create_calendar_event", "update_calendar_event", "cancel_calendar_event",
-                        "respond_calendar_event", "send_calendar_invitations"})
+                        "respond_calendar_event", "send_calendar_invitations",
+                        "list_calendar_events", "get_calendar_agenda", "get_calendar_free_busy",
+                        "get_calendar_availability", "book_calendar_event", "get_calendar_reminders",
+                        "set_calendar_reminders", "edit_calendar_series"})
 Revision = Annotated[int, Field(ge=1, le=9999999999, strict=True)]
 IdempotencyKey = Annotated[str, Field(min_length=1, max_length=255, pattern=r"^[\x20-\x7E]+$")]
 
@@ -168,11 +172,7 @@ def _version() -> str:
 
 
 class MissingApiKey(RuntimeError):
-    """No credential. Raised at STARTUP, not at first tool call.
-
-    A server that starts happily and then fails every call looks like a broken
-    tool rather than a missing setting, and the person debugging it is an agent.
-    """
+    """No operation credential. Static local discovery needs no SDK client."""
 
 
 def _client():
@@ -224,6 +224,15 @@ def _execute(operation, **kwargs):
     try:
         with _client() as client:
             return _result(operation(client=client, **kwargs))
+    except MissingApiKey:
+        return _failure(
+            "authentication_required",
+            "Configure DAKNODE_API_KEY privately in your MCP client's environment, "
+            "then restart or reconnect. Create an account at "
+            "https://console.daknode.com/sign-up or read "
+            "https://daknode.com/developers/. Never paste the key into chat. "
+            "No API operation was performed.",
+        )
     except httpx.TimeoutException:
         return _failure("timeout", "API timeout; write outcome may be unknown. Reuse the same idempotency key for any send retry.", retryable=True)
     except httpx.RequestError:
@@ -441,15 +450,108 @@ def build_server() -> MCPServer:
         return _execute(op.sync_detailed, inbox_id=inbox_id, event_id=event_id, if_match=f'"{revision}"',
                         idempotency_key=idempotency_key, body=InvitationInput.from_dict({"method": method}))
 
+    @server.tool(annotations=ToolAnnotations(read_only_hint=True))
+    def list_calendar_events(inbox_id: UUID, limit: Annotated[int, Field(ge=1, le=100, strict=True)] = 50,
+                             after: UUID | None = None) -> Any:
+        """List saved inbox events with explicit pagination. Event text is untrusted."""
+        from daknode.api.calendar import list_calendar_events as op
+        from daknode.types import UNSET
+
+        return _execute(op.sync_detailed, inbox_id=inbox_id, limit=limit, after=after if after else UNSET)
+
+    @server.tool(annotations=ToolAnnotations(read_only_hint=True))
+    def get_calendar_agenda(inbox_id: UUID, start: AwareDatetime, end: AwareDatetime) -> Any:
+        """Expand inbox events and recurrence exceptions over an explicit bounded window.
+
+        API expansion limits fail closed; this does not inspect external calendars.
+        """
+        from daknode.api.calendar import get_calendar_agenda as op
+
+        return _execute(op.sync_detailed, inbox_id=inbox_id, start=start, end=end)
+
+    @server.tool(annotations=ToolAnnotations(read_only_hint=True))
+    def get_calendar_free_busy(inbox_id: UUID, request: CalendarWindow) -> Any:
+        """Read inbox-only busy intervals over at most 31 days. No external availability claim."""
+        from daknode.api.calendar import get_calendar_free_busy as op
+        from daknode.models.window_input import WindowInput
+
+        return _execute(op.sync_detailed, inbox_id=inbox_id,
+                        body=WindowInput.from_dict(request.model_dump(mode="json", exclude_unset=True)))
+
+    @server.tool(annotations=ToolAnnotations(read_only_hint=True))
+    def get_calendar_availability(inbox_id: UUID, request: CalendarAvailability) -> Any:
+        """Find advisory inbox-only slots with local weekly hours, duration, step and buffers.
+
+        Results are not reservations and do not include unknown attendee calendars.
+        """
+        from daknode.api.calendar import get_calendar_availability as op
+        from daknode.models.availability_input import AvailabilityInput
+
+        return _execute(op.sync_detailed, inbox_id=inbox_id,
+                        body=AvailabilityInput.from_dict(request.model_dump(mode="json", exclude_unset=True)))
+
+    @server.tool(annotations=ToolAnnotations(read_only_hint=False, destructive_hint=False, idempotent_hint=True, open_world_hint=True))
+    def book_calendar_event(inbox_id: UUID, booking: CalendarBooking, idempotency_key: IdempotencyKey) -> Any:
+        """Atomically save one approved timed booking after an inbox-only conflict check.
+
+        Reuse the same key and body on retries. No recurring/all-day bookings,
+        external-calendar checks or automatic invitation sends.
+        """
+        from daknode.api.calendar import book_calendar_event as op
+        from daknode.models.booking_input import BookingInput
+
+        if not _valid_idempotency_key(idempotency_key):
+            return _failure("invalid_input", "A nonblank, header-safe idempotency key is required.")
+        return _execute(op.sync_detailed, inbox_id=inbox_id, idempotency_key=idempotency_key,
+                        body=BookingInput.from_dict(booking.model_dump(mode="json", exclude_unset=True)))
+
+    @server.tool(annotations=ToolAnnotations(read_only_hint=True))
+    def get_calendar_reminders(inbox_id: UUID, event_id: UUID) -> Any:
+        """Read configured developer reminder offsets and the current event revision."""
+        from daknode.api.calendar import get_calendar_reminders as op
+
+        return _execute(op.sync_detailed, inbox_id=inbox_id, event_id=event_id)
+
+    @server.tool(annotations=ToolAnnotations(read_only_hint=False, destructive_hint=True, idempotent_hint=False, open_world_hint=True))
+    def set_calendar_reminders(inbox_id: UUID, event_id: UUID, revision: Revision,
+                               minutes_before_start: ReminderOffsets) -> Any:
+        """Replace up to five developer reminder offsets at the observed revision.
+
+        An empty list clears reminders. These are notifications, not attendee email.
+        Refusals do not authorize refreshing the revision or replaying reminders.
+        """
+        from daknode.api.calendar import set_calendar_reminders as op
+        from daknode.models.reminder_input import ReminderInput
+
+        if len(set(minutes_before_start)) != len(minutes_before_start):
+            return _failure("invalid_input", "Reminder offsets must be unique.")
+        return _execute(op.sync_detailed, inbox_id=inbox_id, event_id=event_id, if_match=f'"{revision}"',
+                        body=ReminderInput.from_dict({"minutes_before_start": minutes_before_start}))
+
+    @server.tool(annotations=ToolAnnotations(read_only_hint=False, destructive_hint=True, idempotent_hint=True, open_world_hint=True))
+    def edit_calendar_series(inbox_id: UUID, event_id: UUID, revision: Revision,
+                             edit: CalendarSeriesEdit, idempotency_key: IdempotencyKey) -> Any:
+        """Save an explicitly approved occurrence, series or this-and-following edit.
+
+        Preserve the supplied revision, recurrence identity, scope and retry key.
+        A conflict is a refusal, never authority to widen scope or overwrite.
+        Saving does not dispatch invitations.
+        """
+        from daknode.api.calendar import edit_calendar_series as op
+        from daknode.models.series_edit_input import SeriesEditInput
+
+        if not _valid_idempotency_key(idempotency_key):
+            return _failure("invalid_input", "A nonblank, header-safe idempotency key is required.")
+        return _execute(op.sync_detailed, inbox_id=inbox_id, event_id=event_id, if_match=f'"{revision}"',
+                        idempotency_key=idempotency_key,
+                        body=SeriesEditInput.from_dict(edit.model_dump(mode="json", exclude_unset=True)))
+
     return server
 
 
 def main() -> int:  # pragma: no cover - process entry point
-    try:
-        _client()
-    except MissingApiKey as exc:
-        print(f"daknode-mcp: {exc}", file=sys.stderr)
-        return 2
+    # Local discovery exposes static schemas only. Each operation still calls
+    # _client(), which refuses absent credentials before constructing transport.
     build_server().run()
     return 0
 

daknode_mcp-0.3.5/tests/test_calendar_scheduling.py

@@ -0,0 +1,233 @@
+"""Calendar scheduling adapters: generated SDK + local and remote MCP wire.
+
+Pure mocked HTTP; no API runtime imports, database, mail or external calendar.
+"""
+import asyncio
+import json
+from pathlib import Path
+
+import httpx
+import pytest
+from daknode import AuthenticatedClient
+
+from mcp_server import server
+from mcp_server.calendar_models import (CalendarWindow, CalendarWorkingHours,
+    CalendarAvailability, CalendarBooking, CalendarSeriesEdit)
+from mcp_server.event_source import CALENDAR_NAMES, JournalSource
+from mcp_server.events import Events, ListParams
+from mcp_server.identity import IdentityVerifier, PERMISSIONS
+from mcp_server.remote import create_app
+
+INBOX = "11111111-1111-4111-8111-111111111111"
+EVENT = "22222222-2222-4222-8222-222222222222"
+FUTURE = "33333333-3333-4333-8333-333333333333"
+IDS = dict(inbox_id=INBOX, event_id=EVENT)
+WINDOW = dict(start="2026-11-02T09:00:00Z", end="2026-11-02T13:00:00Z")
+CREATE = dict(title="Approved meeting", timezone="UTC", starts_at="2026-11-02T10:00:00Z", ends_at="2026-11-02T11:00:00Z")
+AVAILABILITY = dict(**WINDOW, timezone="UTC", working_hours=[dict(weekday=0, start="09:00", end="17:00")],
+    duration_minutes=30, step_minutes=15, buffer_before_minutes=5, buffer_after_minutes=10)
+BOOKING = dict(event=CREATE, buffer_before_minutes=5, buffer_after_minutes=10)
+EDIT = dict(scope="following", recurrence_id="2026-11-02T10:00:00+00:00", changes={"description": None})
+EVENT_BODY = dict(**CREATE, id=EVENT, inbox_id=INBOX, uid="synthetic@daknode", source="local",
+    organizer="synthetic@example.test", all_day=False, description=None, location=None, start_date=None,
+    end_date=None, rrule=None, status="confirmed", revision=2, sequence=0, response="needs_action",
+    send_state="not_sent", attendees=[], created_at="2026-11-01T00:00:00Z", updated_at="2026-11-01T00:00:00Z")
+READS = {"list_calendar_events", "get_calendar_agenda", "get_calendar_free_busy",
+         "get_calendar_availability", "get_calendar_reminders"}
+WRITES = {"book_calendar_event", "set_calendar_reminders", "edit_calendar_series"}
+
+
+async def wire(method, params, authority=None):
+    async def verify(key):
+        return authority or server.Authority(key, server.TOOL_NAMES, CALENDAR_NAMES, workspace_id=INBOX)
+    app = create_app(verify)
+    protocol = "2025-11-25"
+    if method.startswith("events/"):
+        protocol = "2026-07-28"
+        params = {**params, "_meta": {"io.modelcontextprotocol/protocolVersion": protocol,
+            "io.modelcontextprotocol/clientInfo": {"name": "scheduling-contract", "version": "1"},
+            "io.modelcontextprotocol/clientCapabilities": {"extensions": {"io.modelcontextprotocol/events": {}}}}}
+    async with app.app.router.lifespan_context(app.app):
+        async with httpx.AsyncClient(transport=httpx.ASGITransport(app=app), base_url=server.DEFAULT_BASE_URL) as client:
+            response = await client.post("/mcp", json={"jsonrpc": "2.0", "id": 1, "method": method, "params": params},
+                headers={"Authorization": "Bearer synthetic-calendar", "Accept": "application/json, text/event-stream",
+                         "MCP-Protocol-Version": protocol, "MCP-Method": method})
+            assert response.status_code == 200, response.text
+            return response.json()["result"]
+
+
+@pytest.fixture
+def upstream(monkeypatch):
+    calls = []
+    def handle(request):
+        calls.append(request)
+        path = request.url.path
+        if path.endswith("/free-busy"):
+            return httpx.Response(200, json=dict(busy=[WINDOW], scope="inbox_only"))
+        if path.endswith("/availability"):
+            return httpx.Response(200, json=dict(slots=[WINDOW], scope="inbox_only", advisory=True))
+        if path.endswith("/reminders"):
+            return httpx.Response(200, json=dict(event_id=EVENT, revision=2, minutes_before_start=[0, 15, 40320]))
+        if path.endswith("/series-edit"):
+            return httpx.Response(200, json={**EVENT_BODY, "id": FUTURE})
+        if path.endswith("/events"):
+            return httpx.Response(200, json=dict(items=[EVENT_BODY], has_more=True, next_after=EVENT))
+        if path.endswith("/agenda"):
+            return httpx.Response(200, json=dict(items=[]))
+        return httpx.Response(201, json=EVENT_BODY)
+    def client():
+        authority = server.request_authority.get()
+        return AuthenticatedClient(base_url=server.DEFAULT_BASE_URL,
+            token=authority.api_key if authority else "synthetic-local",
+            httpx_args={"transport": httpx.MockTransport(handle)})
+    monkeypatch.setattr(server, "_client", client)
+    return calls
+
+
+@pytest.mark.parametrize("remote", [False, True], ids=["local", "remote"])
+@pytest.mark.parametrize("name,args,method,suffix,body", [
+    ("list_calendar_events", dict(inbox_id=INBOX, limit=7, after=EVENT), "GET", "/events", None),
+    ("get_calendar_agenda", dict(inbox_id=INBOX, **WINDOW), "GET", "/agenda", None),
+    ("get_calendar_free_busy", dict(inbox_id=INBOX, request=WINDOW), "POST", "/free-busy", WINDOW),
+    ("get_calendar_availability", dict(inbox_id=INBOX, request=AVAILABILITY), "POST", "/availability", AVAILABILITY),
+    ("book_calendar_event", dict(inbox_id=INBOX, booking=BOOKING, idempotency_key="book-once"), "POST", "/bookings", BOOKING),
+    ("get_calendar_reminders", IDS, "GET", f"/events/{EVENT}/reminders", None),
+    ("set_calendar_reminders", dict(**IDS, revision=2, minutes_before_start=[0, 15, 40320]), "PUT", f"/events/{EVENT}/reminders", dict(minutes_before_start=[0, 15, 40320])),
+    ("edit_calendar_series", dict(**IDS, revision=2, edit=EDIT, idempotency_key="split-once"), "POST", f"/events/{EVENT}/series-edit", EDIT),
+])
+def test_one_generated_sdk_request_per_tool(upstream, remote, name, args, method, suffix, body):
+    if remote:
+        result = asyncio.run(wire("tools/call", {"name": name, "arguments": args}))
+        assert not result.get("isError"), result
+    else:
+        result = asyncio.run(server.build_server().call_tool(name, args))
+        assert not result.is_error, result
+    assert len(upstream) == 1
+    request = upstream[0]
+    assert request.method == method
+    assert request.url.path == f"/v1/inboxes/{INBOX}/calendar{suffix}"
+    assert request.headers["Authorization"] == ("Bearer synthetic-calendar" if remote else "Bearer synthetic-local")
+    if body is not None:
+        actual = json.loads(request.content)
+        # Generated datetime transport normalizes UTC Z to an explicit offset.
+        for k in ("start", "end", "starts_at", "ends_at"):
+            if k in actual:
+                actual[k] = actual[k].replace("+00:00", "Z")
+            if k in actual.get("event", {}):
+                actual["event"][k] = actual["event"][k].replace("+00:00", "Z")
+        expected = {**body}
+        if name == "book_calendar_event":
+            expected["event"] = {"attendees": [], **body["event"]}
+        assert actual == expected
+    if "revision" in args:
+        assert request.headers["If-Match"] == '"2"'
+    if "idempotency_key" in args:
+        assert request.headers["Idempotency-Key"] == args["idempotency_key"]
+    if name == "list_calendar_events":
+        assert dict(request.url.params) == {"limit": "7", "after": EVENT}
+    if name == "get_calendar_agenda":
+        assert request.url.params["start"].replace("+00:00", "Z") == WINDOW["start"]
+    if name == "edit_calendar_series":
+        assert FUTURE in str(result)
+
+
+@pytest.mark.parametrize("permissions,expected", [
+    (["calendar.read"], READS), (["calendar.write"], WRITES), ([], set()), (None, READS | WRITES),
+])
+def test_scoped_local_remote_discovery_and_reminder_events(permissions, expected):
+    async def run():
+        verifier = IdentityVerifier(transport=httpx.MockTransport(lambda request: httpx.Response(200, json={
+            "resource": server.DEFAULT_BASE_URL, "workspace_id": INBOX, "inbox_id": INBOX,
+            "permissions": permissions, "expires_at": None})))
+        authority = await verifier("synthetic-calendar")
+        assert authority.inbox_id == INBOX
+        assert authority.tools & (READS | WRITES) == expected
+        token = server.request_authority.set(authority)
+        try:
+            local = {t.name for t in await server.build_server().list_tools()}
+            events = await Events(verifier).list_events(None, ListParams())
+        finally:
+            server.request_authority.reset(token)
+        remote = await wire("tools/list", {}, authority)
+        assert local == {t["name"] for t in remote["tools"]} == authority.tools
+        names = {e["name"] for e in events["events"]}
+        remote_events = await wire("events/list", {}, authority)
+        assert {e["name"] for e in remote_events["events"]} == names
+        assert ("calendar.event.reminder" in names) == (permissions is None or "calendar.read" in permissions)
+        assert "create_inbox" not in local
+        return authority
+    asyncio.run(run())
+
+
+@pytest.mark.parametrize("name,args", [
+    ("get_calendar_free_busy", dict(inbox_id=INBOX, request={**WINDOW, "end": "2027-01-01T00:00:00Z"})),
+    ("get_calendar_free_busy", dict(inbox_id=INBOX, request={**WINDOW, "start": "2026-11-02T09:00:00"})),
+    ("get_calendar_availability", dict(inbox_id=INBOX, request={**AVAILABILITY, "step_minutes": True})),
+    ("book_calendar_event", dict(inbox_id=INBOX, booking=BOOKING)),
+    ("book_calendar_event", dict(inbox_id=INBOX, booking=BOOKING, idempotency_key=" ")),
+    ("book_calendar_event", dict(inbox_id=INBOX, booking={"event": {**CREATE, "rrule": "FREQ=DAILY"}}, idempotency_key="bad")),
+    ("set_calendar_reminders", dict(**IDS, revision=True, minutes_before_start=[15])),
+    ("set_calendar_reminders", dict(**IDS, revision=2, minutes_before_start=[40321])),
+    ("set_calendar_reminders", dict(**IDS, revision=2, minutes_before_start=[15] * 6)),
+    ("set_calendar_reminders", dict(**IDS, revision=2, minutes_before_start=[15, 15])),
+    ("edit_calendar_series", dict(**IDS, revision=2, edit={**EDIT, "scope": "auto"}, idempotency_key="bad")),
+    ("edit_calendar_series", dict(**IDS, revision=2, edit=EDIT, idempotency_key="bad\r\nheader")),
+])
+def test_invalid_inputs_do_not_reach_http(upstream, name, args):
+    result = asyncio.run(wire("tools/call", {"name": name, "arguments": args}))
+    assert result["isError"] and not upstream
+
+
+@pytest.mark.parametrize("name,args", [
+    ("get_calendar_free_busy", dict(inbox_id=INBOX, request=WINDOW)),
+    ("book_calendar_event", dict(inbox_id=INBOX, booking=BOOKING, idempotency_key="blocked")),
+    ("edit_calendar_series", dict(**IDS, revision=2, edit=EDIT, idempotency_key="blocked")),
+])
+def test_permission_denied_tools_never_reach_http(upstream, name, args):
+    authority = server.Authority("synthetic-calendar", frozenset(), workspace_id=INBOX, inbox_id=INBOX)
+    result = asyncio.run(wire("tools/call", {"name": name, "arguments": args}, authority))
+    assert result["isError"] and not upstream
+
+
+@pytest.mark.parametrize("name,args", [
+    ("book_calendar_event", dict(inbox_id=INBOX, booking=BOOKING, idempotency_key="retry-same")),
+    ("edit_calendar_series", dict(**IDS, revision=2, edit=EDIT, idempotency_key="retry-same")),
+    ("set_calendar_reminders", dict(**IDS, revision=2, minutes_before_start=[])),
+])
+def test_conflict_does_not_retry_or_refresh(monkeypatch, name, args):
+    calls = []
+    def handle(request):
+        calls.append(request)
+        return httpx.Response(409, json={"error": {"code": "conflict"}})
+    monkeypatch.setattr(server, "_client", lambda: AuthenticatedClient(base_url=server.DEFAULT_BASE_URL,
+        token="synthetic", httpx_args={"transport": httpx.MockTransport(handle)}))
+    result = asyncio.run(wire("tools/call", {"name": name, "arguments": args}))
+    assert result["isError"] and len(calls) == 1
+
+
+def test_new_schema_fields_match_public_contract():
+    spec = json.loads((Path(__file__).resolve().parents[2] / "sdk/openapi.public.json").read_text())
+    for model, schema in [(CalendarWindow, "WindowInput"), (CalendarWorkingHours, "WorkingHours"),
+        (CalendarAvailability, "AvailabilityInput"), (CalendarBooking, "BookingInput"),
+        (CalendarSeriesEdit, "SeriesEditInput")]:
+        actual, expected = model.model_json_schema(), spec["components"]["schemas"][schema]
+        assert set(actual["properties"]) == set(expected["properties"])
+        assert set(actual.get("required", [])) == set(expected.get("required", []))
+        assert actual["additionalProperties"] is False
+    assert server.TOOL_NAMES == frozenset(PERMISSIONS)
+
+
+def test_reminder_journal_metadata_is_bounded_and_scoped():
+    from datetime import datetime, timezone
+    calls = []
+    def handle(request):
+        calls.append(request)
+        return httpx.Response(200, json={"items": [dict(id=FUTURE, event_id=EVENT, event_revision=2,
+            type="calendar.event.reminder", occurred_at=datetime.now(timezone.utc).isoformat())],
+            "next_cursor": "signed-cursor", "has_more": False})
+    authority = server.Authority("synthetic", frozenset(), CALENDAR_NAMES, workspace_id=INBOX, inbox_id=INBOX)
+    page = asyncio.run(JournalSource(transport=httpx.MockTransport(handle)).poll(authority,
+        "calendar.event.reminder", INBOX, None, 300000))
+    assert page.events[0]["data"] == dict(inboxId=INBOX, eventId=EVENT, revision=2)
+    assert calls[0].url.path.endswith(f"/{INBOX}/calendar/changes")
+    assert calls[0].url.params["limit"] == "1"

daknode_mcp-0.3.5/tests/test_local_discovery.py

@@ -0,0 +1,148 @@
+"""Credential-free local metadata; operations and remote access stay protected."""
+import asyncio
+import json
+import os
+from pathlib import Path
+import sys
+
+import pytest
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+
+from mcp_server import server
+
+ID = "11111111-1111-4111-8111-111111111111"
+IDS = {"inbox_id": ID, "event_id": ID}
+WINDOW = {"start": "2030-11-04T09:00:00Z", "end": "2030-11-04T17:00:00Z"}
+EVENT = {"title": "Synthetic test", "timezone": "UTC", "starts_at": WINDOW["start"], "ends_at": WINDOW["end"]}
+ARGS = {
+    "create_inbox": {"alias": "synthetic"},
+    "list_threads": {"inbox_id": ID}, "list_messages": {"inbox_id": ID},
+    "get_thread": {"thread_id": ID}, "get_message": {"message_id": ID},
+    "search": {"query": "private-input-sentinel"},
+    "send": {"inbox_id": ID, "to": "synthetic@example.test", "subject": "Synthetic", "body_text": "No send", "idempotency_key": "synthetic-operation"},
+    "get_calendar_event": IDS,
+    "create_calendar_event": {"inbox_id": ID, "event": EVENT, "idempotency_key": "synthetic-operation"},
+    "update_calendar_event": {**IDS, "revision": 1, "patch": {"description": "Synthetic"}},
+    "cancel_calendar_event": {**IDS, "revision": 1},
+    "respond_calendar_event": {**IDS, "revision": 1, "response": "accepted"},
+    "send_calendar_invitations": {**IDS, "revision": 1, "idempotency_key": "synthetic-operation"},
+    "list_calendar_events": {"inbox_id": ID},
+    "get_calendar_agenda": {"inbox_id": ID, **WINDOW},
+    "get_calendar_free_busy": {"inbox_id": ID, "request": WINDOW},
+    "get_calendar_availability": {"inbox_id": ID, "request": {**WINDOW, "timezone": "UTC", "working_hours": [{"weekday": 0, "start": "09:00", "end": "17:00"}], "duration_minutes": 30, "step_minutes": 15}},
+    "book_calendar_event": {"inbox_id": ID, "booking": {"event": EVENT}, "idempotency_key": "synthetic-operation"},
+    "get_calendar_reminders": IDS,
+    "set_calendar_reminders": {**IDS, "revision": 1, "minutes_before_start": [15]},
+    "edit_calendar_series": {**IDS, "revision": 1, "edit": {"scope": "series", "changes": {"description": "Synthetic"}}, "idempotency_key": "synthetic-operation"},
+}
+
+
+def assert_setup_refusal(result):
+    assert result.is_error, result
+    payload = json.loads(result.content[0].text)
+    assert payload["error"]["code"] == "authentication_required"
+    assert "https://console.daknode.com/sign-up" in payload["error"]["message"]
+    assert "privately" in payload["error"]["message"]
+    assert "private-input-sentinel" not in result.content[0].text
+
+
+def test_no_new_tool_or_fake_prompt_is_introduced(monkeypatch):
+    monkeypatch.delenv("DAKNODE_API_KEY", raising=False)
+    def forbidden(*args, **kwargs):
+        pytest.fail("Discovery constructed an authenticated client")
+    monkeypatch.setattr(server, "_client", forbidden)
+    async def run():
+        adapter = server.build_server()
+        assert {tool.name for tool in await adapter.list_tools()} == set(ARGS) == server.TOOL_NAMES
+        assert await adapter.list_prompts() == []
+    asyncio.run(run())
+
+
+@pytest.mark.parametrize("name", sorted(ARGS))
+@pytest.mark.parametrize("key", [None, "", " \t\n"])
+def test_every_valid_operation_refuses_missing_credentials_before_transport(monkeypatch, name, key):
+    if key is None:
+        monkeypatch.delenv("DAKNODE_API_KEY", raising=False)
+    else:
+        monkeypatch.setenv("DAKNODE_API_KEY", key)
+    def forbidden(*args, **kwargs):
+        pytest.fail("No key must mean no HTTP transport")
+    monkeypatch.setattr(server, "BoundedTransport", forbidden)
+    result = asyncio.run(server.build_server().call_tool(name, ARGS[name]))
+    assert_setup_refusal(result)
+
+
+def test_main_does_not_construct_a_client_or_write_protocol_noise(monkeypatch, capsys):
+    monkeypatch.delenv("DAKNODE_API_KEY", raising=False)
+    ran = []
+    class Adapter:
+        def run(self):
+            ran.append(True)
+    monkeypatch.setattr(server, "build_server", Adapter)
+    monkeypatch.setattr(server, "_client", lambda: pytest.fail("Startup must not build an operation client"))
+    assert server.main() == 0
+    assert ran == [True]
+    captured = capsys.readouterr()
+    assert captured.out == captured.err == ""
+
+
+def test_actual_stdio_initialize_discovery_and_refusal_without_key(monkeypatch):
+    monkeypatch.delenv("DAKNODE_API_KEY", raising=False)
+    # A real child process, not the already-installed public0.3.4 entry point.
+    # Deny sockets so this can never hit a real API even if the guard regresses.
+    bootstrap = (
+        "import runpy,socket; "
+        "socket.socket.connect=lambda *a,**k: (_ for _ in ()).throw(RuntimeError('Network forbidden in discovery test')); "
+        "runpy.run_module('mcp_server.server',run_name='__main__')"
+    )
+    params = StdioServerParameters(command=sys.executable, args=["-c", bootstrap],
+        cwd=str(Path(__file__).resolve().parents[2]), env={"PATH": os.defpath})
+    async def run():
+        async with stdio_client(params) as (reader, writer):
+            async with ClientSession(reader, writer) as client:
+                await client.initialize()
+                tools = await client.list_tools()
+                assert {tool.name for tool in tools.tools} == server.TOOL_NAMES
+                assert (await client.list_prompts()).prompts == []
+                for name in ("list_messages", "send", "book_calendar_event"):
+                    assert_setup_refusal(await client.call_tool(name, ARGS[name]))
+                assert len((await client.list_tools()).tools) == 21
+    asyncio.run(run())
+
+
+@pytest.mark.parametrize("status", [200, 403])
+def test_actual_stdio_first_read_uses_authenticated_sdk_and_preserves_refusal(status):
+    """Real MCP wire and generated client, synthetic HTTP only, no sockets."""
+    bootstrap = f'''
+import httpx, socket
+from mcp_server import server
+socket.socket.connect = lambda *a, **k: (_ for _ in ()).throw(RuntimeError("Network forbidden"))
+def handle(request):
+    assert request.method == "GET"
+    assert str(request.url) == "https://api.daknode.com/v1/inboxes/{ID}/messages?limit=5"
+    assert request.headers["authorization"] == "Bearer synthetic-onboarding-only"
+    assert request.headers["accept-encoding"] == "identity"
+    return httpx.Response({status}, json={{"items": [], "has_more": False, "next_cursor": None}} if {status} == 200 else {{"error": {{"code": "forbidden"}}}})
+server.BoundedTransport = lambda: httpx.MockTransport(handle)
+server.main()
+'''
+    params = StdioServerParameters(command=sys.executable, args=["-c", bootstrap],
+        cwd=str(Path(__file__).resolve().parents[2]),
+        env={"PATH": os.defpath, "DAKNODE_API_KEY": "synthetic-onboarding-only"})
+
+    async def run():
+        async with stdio_client(params) as (reader, writer):
+            async with ClientSession(reader, writer) as client:
+                await client.initialize()
+                assert "list_messages" in {tool.name for tool in (await client.list_tools()).tools}
+                result = await client.call_tool("list_messages", {"inbox_id": ID, "limit": 5})
+                text = " ".join(block.text for block in result.content if hasattr(block, "text"))
+                assert "synthetic-onboarding-only" not in text
+                if status == 200:
+                    assert not result.is_error
+                    assert json.loads(text)["items"] == []
+                else:
+                    assert result.is_error
+                    assert "403" in text
+    asyncio.run(run())

daknode_mcp-0.3.3/calendar_models.py

@@ -1,55 +0,0 @@
-"""MCP input schemas matching the published Calendar request bodies.
-
-These are validation-only transport models. Generated SDK models still build
-the API requests. Timezone, recurrence and organizer authority stay in the API.
-Explicit nulls and omitted patch fields must remain different.
-"""
-from datetime import date, datetime
-from typing import Annotated
-
-from pydantic import BaseModel, ConfigDict, Field
-
-Title = Annotated[str, Field(min_length=1, max_length=1000)]
-Timezone = Annotated[str, Field(min_length=1, max_length=100)]
-Description = Annotated[str, Field(max_length=50000)]
-Location = Annotated[str, Field(max_length=2000)]
-Recurrence = Annotated[str, Field(max_length=2000)]
-
-
-class CalendarAttendee(BaseModel):
-    model_config = ConfigDict(extra="forbid")
-    email: Annotated[str, Field(min_length=3, max_length=320)]
-    name: Annotated[str, Field(max_length=255)] | None = None
-
-
-Attendees = Annotated[list[CalendarAttendee], Field(max_length=100)]
-
-
-class CalendarCreate(BaseModel):
-    model_config = ConfigDict(extra="forbid")
-    title: Title
-    timezone: Timezone
-    all_day: bool = False
-    attendees: Attendees = Field(default_factory=list)
-    description: Description | None = None
-    location: Location | None = None
-    rrule: Recurrence | None = None
-    starts_at: datetime | None = None
-    ends_at: datetime | None = None
-    start_date: date | None = None
-    end_date: date | None = None
-
-
-class CalendarPatch(BaseModel):
-    model_config = ConfigDict(extra="forbid")
-    title: Title | None = None
-    timezone: Timezone | None = None
-    all_day: bool | None = None
-    attendees: Attendees | None = None
-    description: Description | None = None
-    location: Location | None = None
-    rrule: Recurrence | None = None
-    starts_at: datetime | None = None
-    ends_at: datetime | None = None
-    start_date: date | None = None
-    end_date: date | None = None

daknode_mcp-0.3.3/daknode_mcp.egg-info/requires.txt

@@ -1,2 +0,0 @@
-daknode<0.4,>=0.3.8
-mcp<3,>=2.2