synth-ai 0.18.2.dev610__tar.gz → 0.18.2.dev612__tar.gz

{synth_ai-0.18.2.dev610/synth_ai.egg-info → synth_ai-0.18.2.dev612}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synth-ai
-Version: 0.18.2.dev610
+Version: 0.18.2.dev612
 Summary: Python SDK and CLI for Synth Managed Research and Research Factory
 Author-email: Synth AI <josh@usesynth.ai>
 License-Expression: MIT

{synth_ai-0.18.2.dev610 → synth_ai-0.18.2.dev612}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "synth-ai"
-version = "0.18.2.dev610"
+version = "0.18.2.dev612"
 description = "Python SDK and CLI for Synth Managed Research and Research Factory"
 authors = [{name = "Synth AI", email = "josh@usesynth.ai"}]
 license = "MIT"

{synth_ai-0.18.2.dev610 → synth_ai-0.18.2.dev612}/synth_ai/mcp/research/tools/research_intern.py

@@ -25,6 +25,7 @@ from synth_ai.sdk.research.contracts.research_intern import (
     InternAsyncEnsureRequest,
     InternAsyncInstructionKind,
     InternAsyncInstructionRequest,
+    InternCrossMetaThreadMessageCreateRequest,
     InternRuntimeOutcome,
     InternSyncCommandKind,
     InternSyncCommandRequest,
@@ -140,7 +141,52 @@ def build_research_intern_tools(
 
     def intern_sync_list(args: JSONDict) -> list[JSONDict]:
         with client_from_args(args) as client:
-            return _wire_list(client.intern.sync_.list(limit=optional_int(args, "limit") or 100))
+            return _wire_list(client.intern.sync_.branches())
+
+    def intern_sync_branches(args: JSONDict) -> list[JSONDict]:
+        with client_from_args(args) as client:
+            return _wire_list(client.intern.sync_.branches())
+
+    def intern_meta_threads(args: JSONDict) -> list[JSONDict]:
+        with client_from_args(args) as client:
+            return _wire_list(client.intern.meta_threads.list())
+
+    def intern_meta_segments(args: JSONDict) -> list[JSONDict]:
+        with client_from_args(args) as client:
+            return _wire_list(
+                client.intern.meta_threads.segments(require_string(args, "meta_thread_id"))
+            )
+
+    def intern_meta_messages(args: JSONDict) -> list[JSONDict]:
+        with client_from_args(args) as client:
+            return _wire_list(
+                client.intern.meta_threads.messages(
+                    require_string(args, "meta_thread_id"),
+                    limit=optional_int(args, "limit") or 200,
+                )
+            )
+
+    def intern_meta_send(args: JSONDict) -> JSONDict:
+        request = InternCrossMetaThreadMessageCreateRequest.model_validate(
+            _request_payload(
+                args,
+                (
+                    "message_id",
+                    "source_meta_thread_id",
+                    "destination_meta_thread_id",
+                    "kind",
+                    "idempotency_key",
+                    "payload",
+                    "linked_message_id",
+                    "sync_session_id",
+                    "segment_id",
+                    "resolution",
+                    "summary",
+                ),
+            )
+        )
+        with client_from_args(args) as client:
+            return client.intern.meta_threads.send(request).to_wire()
 
     def intern_sync_get(args: JSONDict) -> JSONDict:
         with client_from_args(args) as client:
@@ -755,6 +801,76 @@ def build_research_intern_tools(
         "sync_session_id": {"type": "string", "minLength": 1},
     }
     tools = [
+        ToolDefinition(
+            name="intern_meta_threads",
+            description="List the Intern's one Sync and one Async meta-thread.",
+            input_schema=tool_schema({}, required=[]),
+            handler=intern_meta_threads,
+            required_scopes=READ_SCOPES,
+        ),
+        ToolDefinition(
+            name="intern_meta_segments",
+            description="List head, live, and sealed segments for one meta-thread.",
+            input_schema=tool_schema(
+                {"meta_thread_id": {"type": "string", "minLength": 1}},
+                required=["meta_thread_id"],
+            ),
+            handler=intern_meta_segments,
+            required_scopes=READ_SCOPES,
+        ),
+        ToolDefinition(
+            name="intern_meta_messages",
+            description="List durable cross-lane messages visible to one meta-thread.",
+            input_schema=tool_schema(
+                {
+                    "meta_thread_id": {"type": "string", "minLength": 1},
+                    "limit": {"type": "integer", "minimum": 1, "maximum": 500},
+                },
+                required=["meta_thread_id"],
+            ),
+            handler=intern_meta_messages,
+            required_scopes=READ_SCOPES,
+        ),
+        ToolDefinition(
+            name="intern_meta_send",
+            description="Send one exact durable Sync-to-Async protocol object.",
+            input_schema=tool_schema(
+                {
+                    "message_id": {"type": "string", "minLength": 1},
+                    "source_meta_thread_id": {"type": "string", "minLength": 1},
+                    "destination_meta_thread_id": {"type": "string", "minLength": 1},
+                    "kind": {
+                        "type": "string",
+                        "enum": [
+                            "request_decision",
+                            "open_branch_ack",
+                            "decision_resolved",
+                            "steer",
+                            "note",
+                        ],
+                    },
+                    "idempotency_key": {"type": "string", "minLength": 1},
+                    "payload": {"type": "object"},
+                    "linked_message_id": {"type": "string"},
+                    "sync_session_id": {"type": "string"},
+                    "segment_id": {"type": "string"},
+                    "resolution": {
+                        "type": "string",
+                        "enum": ["completed", "denied", "superseded"],
+                    },
+                    "summary": {"type": "string", "maxLength": 4000},
+                },
+                required=[
+                    "message_id",
+                    "source_meta_thread_id",
+                    "destination_meta_thread_id",
+                    "kind",
+                    "idempotency_key",
+                ],
+            ),
+            handler=intern_meta_send,
+            required_scopes=WRITE_SCOPES,
+        ),
         ToolDefinition(
             name="intern_sync_create",
             description="Create or replay one durable operator-present Sync session.",
@@ -774,13 +890,17 @@ def build_research_intern_tools(
             handler=intern_sync_create,
             required_scopes=WRITE_SCOPES,
         ),
+        ToolDefinition(
+            name="intern_sync_branches",
+            description="List the Sync head plus every live or sealed branch.",
+            input_schema=tool_schema({}, required=[]),
+            handler=intern_sync_branches,
+            required_scopes=READ_SCOPES,
+        ),
         ToolDefinition(
             name="intern_sync_list",
-            description="List a bounded page of durable Sync Intern sessions.",
-            input_schema=tool_schema(
-                {"limit": {"type": "integer", "minimum": 1, "maximum": 500}},
-                required=[],
-            ),
+            description="Compatibility alias of intern_sync_branches.",
+            input_schema=tool_schema({}, required=[]),
             handler=intern_sync_list,
             required_scopes=READ_SCOPES,
         ),

{synth_ai-0.18.2.dev610 → synth_ai-0.18.2.dev612}/synth_ai/mcp/research/tools/workspace_inputs.py

@@ -212,8 +212,7 @@ def build_workspace_input_tools(
                 "Confirm an already-pushed workspace commit through project "
                 "authority and return the typed WorkspacePushConfirmationReceipt "
                 "-- the done signal for coding agents driving workspace ingress "
-                "over MCP. If the project is bound to an open Sync session, the "
-                "backend also auto-records a kit-association receipt server-side."
+                "over MCP."
             ),
             input_schema=tool_schema(
                 {

{synth_ai-0.18.2.dev610 → synth_ai-0.18.2.dev612}/synth_ai/sdk/research/contracts/__init__.py

@@ -275,6 +275,7 @@ from synth_ai.sdk.research.contracts.research_intern import (
     DataBindingResponse,
     DatasetRevisionCreateRequest,
     DatasetRevisionResponse,
+    InternAgentConfig,
     InternAsyncBlocker,
     InternAsyncCheckpoint,
     InternAsyncCommandKind,
@@ -291,6 +292,17 @@ from synth_ai.sdk.research.contracts.research_intern import (
     InternAsyncRuntime,
     InternAsyncRuntimeBudget,
     InternAsyncStatus,
+    InternCrossMetaThreadMessage,
+    InternCrossMetaThreadMessageCreateRequest,
+    InternCrossMetaThreadMessageKind,
+    InternCrossMetaThreadMessageResolution,
+    InternMetaHandoff,
+    InternMetaHandoffStatus,
+    InternMetaThread,
+    InternMetaThreadKind,
+    InternMetaThreadLifecycle,
+    InternMetaThreadSegment,
+    InternMetaThreadSegmentStatus,
     InternRuntimeBinding,
     InternRuntimeOutcome,
     InternSyncCommandKind,
@@ -350,15 +362,10 @@ from synth_ai.sdk.research.contracts.research_intern import (
     ResearchInternTurnRequest,
     ResearchInternTurnResponse,
     ResearchInternTurnStatus,
-    SyncKitAssociatedFile,
-    SyncKitAssociationReceipt,
-    SyncKitIngressKind,
-    SyncKitIngressObservation,
-    SyncKitIngressSource,
-    SyncKitReadiness,
-    SyncTemplateProvisionedResource,
-    SyncTemplateProvisioningReceipt,
     SyncTracePublicationReceipt,
+    SyncWorkspaceRunReceipt,
+    SyncWorkspaceSnapshotIdentity,
+    SyncWorkspaceSnapshotKind,
 )
 from synth_ai.sdk.research.contracts.runtime_stream import (
     SwarmEvent,
@@ -839,6 +846,18 @@ __all__ = [
     "InternAsyncRuntime",
     "InternAsyncRuntimeBudget",
     "InternAsyncStatus",
+    "InternAgentConfig",
+    "InternCrossMetaThreadMessage",
+    "InternCrossMetaThreadMessageCreateRequest",
+    "InternCrossMetaThreadMessageKind",
+    "InternCrossMetaThreadMessageResolution",
+    "InternMetaHandoff",
+    "InternMetaHandoffStatus",
+    "InternMetaThread",
+    "InternMetaThreadKind",
+    "InternMetaThreadLifecycle",
+    "InternMetaThreadSegment",
+    "InternMetaThreadSegmentStatus",
     "InternRuntimeBinding",
     "InternRuntimeOutcome",
     "InternSyncCommandKind",
@@ -934,15 +953,10 @@ __all__ = [
     "SwarmTerminalOutcomeMissingError",
     "SwarmEnvironment",
     "SwarmUsage",
-    "SyncKitAssociatedFile",
-    "SyncKitAssociationReceipt",
-    "SyncKitIngressKind",
-    "SyncKitIngressObservation",
-    "SyncKitIngressSource",
-    "SyncKitReadiness",
-    "SyncTemplateProvisionedResource",
-    "SyncTemplateProvisioningReceipt",
     "SyncTracePublicationReceipt",
+    "SyncWorkspaceRunReceipt",
+    "SyncWorkspaceSnapshotIdentity",
+    "SyncWorkspaceSnapshotKind",
     "TaskId",
     "TranscriptCursor",
     "TranscriptCursorKind",

{synth_ai-0.18.2.dev610 → synth_ai-0.18.2.dev612}/synth_ai/sdk/research/contracts/research_intern.py

@@ -144,6 +144,128 @@ class ResearchInternResponse(_StrictContract):
     updated_at: datetime
 
 
+class InternMetaThreadKind(StrEnum):
+    SYNC = "sync"
+    ASYNC = "async"
+
+
+class InternMetaThreadLifecycle(StrEnum):
+    ACTIVE = "active"
+    ARCHIVED = "archived"
+
+
+class InternMetaThreadSegmentStatus(StrEnum):
+    LIVE = "live"
+    SEALED = "sealed"
+
+
+class InternMetaHandoffStatus(StrEnum):
+    SEALED = "sealed"
+    MERGED = "merged"
+
+
+class InternCrossMetaThreadMessageKind(StrEnum):
+    REQUEST_DECISION = "request_decision"
+    OPEN_BRANCH_ACK = "open_branch_ack"
+    DECISION_RESOLVED = "decision_resolved"
+    STEER = "steer"
+    NOTE = "note"
+
+
+class InternCrossMetaThreadMessageResolution(StrEnum):
+    COMPLETED = "completed"
+    DENIED = "denied"
+    SUPERSEDED = "superseded"
+
+
+class InternAgentConfig(_StrictContract):
+    agent_role: str
+    harness: str
+    model: str
+    reasoning_effort: str
+    segment_role: str | None = None
+    harness_command: str | None = None
+    workspace_root: str | None = None
+
+
+class InternMetaThread(_StrictContract):
+    schema_version: Literal["smr.meta-thread.v1"]
+    meta_thread_id: str
+    organization_id: str
+    research_intern_id: str
+    kind: InternMetaThreadKind
+    lifecycle: InternMetaThreadLifecycle
+    head_segment_id: str
+    created_at: datetime
+    updated_at: datetime
+
+
+class InternMetaThreadSegment(_StrictContract):
+    schema_version: Literal["smr.meta-thread-segment.v1"]
+    segment_id: str
+    meta_thread_id: str
+    parent_segment_id: str | None = None
+    lane_runtime_id: str | None = None
+    agent_config: InternAgentConfig | None = None
+    status: InternMetaThreadSegmentStatus
+    opened_at: datetime
+    sealed_at: datetime | None = None
+    linked_message_id: str | None = None
+    handoff_id: str | None = None
+    is_head: bool = False
+
+
+class InternMetaHandoff(_StrictContract):
+    schema_version: Literal["smr.meta-handoff.v1"]
+    handoff_id: str
+    meta_thread_id: str
+    source_segment_id: str
+    summary: str
+    evidence_references: tuple[str, ...] = ()
+    agent_config: InternAgentConfig | None = None
+    status: InternMetaHandoffStatus
+    created_at: datetime
+    sealed_at: datetime
+    merged_at: datetime | None = None
+
+
+class InternCrossMetaThreadMessageCreateRequest(_StrictContract):
+    schema_version: Literal["smr.cross-meta-thread-message-create.v1"] = (
+        "smr.cross-meta-thread-message-create.v1"
+    )
+    message_id: str = Field(min_length=1, max_length=512)
+    source_meta_thread_id: str = Field(min_length=1, max_length=512)
+    destination_meta_thread_id: str = Field(min_length=1, max_length=512)
+    kind: InternCrossMetaThreadMessageKind
+    idempotency_key: str = Field(min_length=1, max_length=512)
+    payload: dict[str, Any] = Field(default_factory=dict)
+    linked_message_id: str | None = None
+    sync_session_id: str | None = None
+    segment_id: str | None = None
+    resolution: InternCrossMetaThreadMessageResolution | None = None
+    summary: str | None = Field(default=None, max_length=4_000)
+
+
+class InternCrossMetaThreadMessage(_StrictContract):
+    schema_version: Literal["smr.cross-meta-thread-message.v1"]
+    message_id: str
+    organization_id: str
+    research_intern_id: str
+    source_meta_thread_id: str
+    source_kind: InternMetaThreadKind
+    destination_meta_thread_id: str
+    destination_kind: InternMetaThreadKind
+    kind: InternCrossMetaThreadMessageKind
+    idempotency_key: str
+    payload: dict[str, Any] = Field(default_factory=dict)
+    linked_message_id: str | None = None
+    sync_session_id: str | None = None
+    segment_id: str | None = None
+    resolution: InternCrossMetaThreadMessageResolution | None = None
+    summary: str | None = None
+    created_at: datetime
+
+
 class InternRuntimeBinding(_StrictContract):
     factory_id: str | None = None
     project_id: str | None = None
@@ -188,40 +310,9 @@ class InternSyncSessionCreateRequest(_StrictContract):
     binding: InternRuntimeBinding = Field(default_factory=InternRuntimeBinding)
     metadata: dict[str, Any] = Field(default_factory=dict)
     execution_mode: Literal["fast", "standard", "deep"] = "standard"
-    task_template: str | None = Field(default=None, min_length=1, max_length=128)
     objective_bounds: dict[str, Any] | None = None
 
 
-class SyncTemplateProvisionedResource(_StrictContract):
-    """One resource decision made while provisioning a task template."""
-
-    resource_kind: Literal[
-        "project",
-        "factory",
-        "factory_project_link",
-        "effort",
-        "intern_factory_membership",
-        "run",
-    ]
-    status: Literal["created", "reused", "unsupported"]
-    resource_id: str | None = None
-    error_code: str | None = None
-
-
-class SyncTemplateProvisioningReceipt(_StrictContract):
-    """Durable record of what starting from a task template provisioned.
-
-    The backend mints this receipt inside the session-create transaction and
-    stamps it into the session projection; the SDK only ever observes it.
-    """
-
-    schema_version: Literal["smr.intern-sync-template-provisioning.v1"]
-    task_template: str
-    binding: InternRuntimeBinding
-    resources: tuple[SyncTemplateProvisionedResource, ...]
-    provisioned_at: datetime
-
-
 class SyncTracePublicationReceipt(_StrictContract):
     """Read-only receipt for the server-side terminal Trace V5 publication.
 
@@ -247,76 +338,59 @@ class SyncTracePublicationReceipt(_StrictContract):
     published_at: datetime | None = None
 
 
-SyncKitIngressKind = Literal[
-    "website_upload",
-    "sdk_upload",
-    "git_push",
-    "project_files",
+SyncWorkspaceSnapshotKind = Literal[
+    "internal_git_head",
+    "stored_file_digest_set",
+    "internal_git_head_with_stored_files",
 ]
 
-SyncKitIngressObservation = Literal[
-    "stored_file_write",
-    "push_confirmation",
-    "upload_url_issuance",
-]
-
-
-class SyncKitAssociatedFile(_StrictContract):
-    """One file observed in a kit ingress, with whatever identity was available."""
-
-    path: str
-    digest: str | None = Field(default=None, pattern=r"^sha256:[0-9a-f]{64}$")
-    size_bytes: int | None = Field(default=None, ge=0)
-    stored_file_id: str | None = None
-
 
-class SyncKitIngressSource(_StrictContract):
-    """Source identity of one kit ingress, per ingress kind."""
+class SyncWorkspaceSnapshotIdentity(_StrictContract):
+    """Provable project workspace identity captured when a run is triggered."""
 
+    schema_version: Literal["smr.intern-sync-workspace-snapshot.v1"] = (
+        "smr.intern-sync-workspace-snapshot.v1"
+    )
+    kind: SyncWorkspaceSnapshotKind
     commit_sha: str | None = None
-    archive_key: str | None = None
-    workspace_archive_id: str | None = None
-    push_confirmation_receipt_id: str | None = None
-    upload_batch_id: str | None = None
-    dataset_ref: str | None = None
-    stored_file_ids: tuple[str, ...] = ()
+    inventory_digest: str | None = Field(default=None, pattern=r"^sha256:[0-9a-f]{64}$")
+    file_count: int | None = Field(default=None, ge=1)
+    captured_at: datetime
 
+    @model_validator(mode="after")
+    def require_identity_per_kind(self) -> SyncWorkspaceSnapshotIdentity:
+        if self.kind == "internal_git_head" and not self.commit_sha:
+            raise ValueError("internal_git_head snapshot requires commit_sha")
+        if self.kind == "stored_file_digest_set" and (
+            not self.inventory_digest or not self.file_count
+        ):
+            raise ValueError(
+                "stored_file_digest_set snapshot requires the inventory digest and file count"
+            )
+        if self.kind == "internal_git_head_with_stored_files" and (
+            not self.commit_sha or not self.inventory_digest or not self.file_count
+        ):
+            raise ValueError(
+                "internal_git_head_with_stored_files snapshot requires commit_sha, "
+                "the inventory digest, and file count"
+            )
+        return self
 
-class SyncKitAssociationReceipt(_StrictContract):
-    """Durable record that a kit ingress landed while this session was open.
 
-    The backend mints this receipt as a server-side effect of observing an
-    upload, push, or file write on a project bound to an open Sync session.
-    Clients never mint it; they observe it on the session projection.
-    """
+class SyncWorkspaceRunReceipt(_StrictContract):
+    """Server-minted proof of the project workspace used to trigger one run."""
 
-    schema_version: Literal["smr.intern-sync-kit-association.v1"]
-    receipt_id: str
+    schema_version: Literal["smr.intern-sync-workspace-run.v1"] = "smr.intern-sync-workspace-run.v1"
+    run_id: str
     sync_session_id: str
     project_id: str
-    ingress_kind: SyncKitIngressKind
-    observed_via: SyncKitIngressObservation
-    files: tuple[SyncKitAssociatedFile, ...] = ()
-    source: SyncKitIngressSource
-    open_session_count: int = Field(ge=1)
-    associated_at: datetime
-
-
-class SyncKitReadiness(_StrictContract):
-    """Read-only kit completeness projection for a template-bound session."""
-
-    schema_version: Literal["smr.intern-sync-kit-readiness.v1"]
-    status: Literal["ready", "incomplete"]
-    task_template: str
-    kit_contract: str
-    required_files: tuple[str, ...]
-    present_files: tuple[str, ...] = ()
-    missing_files: tuple[str, ...] = ()
-    checked_at: datetime
+    experiment_id: str | None = None
+    workspace: SyncWorkspaceSnapshotIdentity
+    recorded_at: datetime
 
 
 class InternSyncSession(_StrictContract):
-    schema_version: Literal["smr.intern-sync-session.v1"]
+    schema_version: Literal["smr.intern-sync-session.v1"] = "smr.intern-sync-session.v1"
     sync_session_id: str
     research_intern_id: str
     org_id: str
@@ -333,18 +407,11 @@ class InternSyncSession(_StrictContract):
     outcome: InternRuntimeOutcome | None = None
     failure_code: str | None = None
     temporal_workflow_id: str
-    execution_mode: Literal["fast", "standard", "deep"] = "standard"
+    execution_mode: Literal["fast", "standard", "deep"]
     execution_profile_id: Literal["intern_sync"] = "intern_sync"
-    # Server-minted projection stamps. Old backends omit them entirely; new
-    # backends stamp them once the corresponding effect lands. The SDK only
-    # observes these receipts — the backend remains the minting authority.
-    task_template: str | None = None
-    provisioning: SyncTemplateProvisioningReceipt | None = None
     trace_publication: SyncTracePublicationReceipt | None = None
-    kit_associations: tuple[SyncKitAssociationReceipt, ...] = ()
-    kit_readiness: SyncKitReadiness | None = None
     visuals: tuple[dict[str, Any], ...] = ()
-    kit_state_receipts: tuple[dict[str, Any], ...] = ()
+    workspace_run_receipts: tuple[SyncWorkspaceRunReceipt, ...] = ()
     experiments: tuple[dict[str, Any], ...] = ()
     harness_bundle_available: bool = False
     created_at: datetime
@@ -406,13 +473,11 @@ class InternSyncDeployPacket(_StrictContract):
     schema_version: Literal["smr.intern-sync-deploy-packet.v1"]
     sync_session_id: str
     project_id: str
-    task_template: str | None = None
     auth_scheme: Literal["bearer"]
     auth_env_var: Literal["SYNTH_API_KEY"]
-    required_paths: tuple[str, ...] = ()
     endpoints: tuple[InternSyncDeployPacketEndpoint, ...]
     done_signal: Literal["workspace_confirm_push"]
-    image_kind: Literal["craftax_eval"]
+    image_kind: Literal["project_default"]
     instructions: str
 
 

{synth_ai-0.18.2.dev610 → synth_ai-0.18.2.dev612}/synth_ai/sdk/research/operations.py

@@ -97,6 +97,43 @@ RESEARCH_OPERATIONS = {
             mutation=True,
             idempotent=True,
         ),
+        _operation(
+            "list_intern_meta_threads",
+            HttpMethod.GET,
+            "/smr/research-intern/meta-threads",
+            idempotent=True,
+        ),
+        _operation(
+            "get_intern_meta_thread",
+            HttpMethod.GET,
+            "/smr/research-intern/meta-threads/{meta_thread_id}",
+            idempotent=True,
+        ),
+        _operation(
+            "list_intern_meta_thread_segments",
+            HttpMethod.GET,
+            "/smr/research-intern/meta-threads/{meta_thread_id}/segments",
+            idempotent=True,
+        ),
+        _operation(
+            "list_intern_meta_thread_handoffs",
+            HttpMethod.GET,
+            "/smr/research-intern/meta-threads/{meta_thread_id}/handoffs",
+            idempotent=True,
+        ),
+        _operation(
+            "list_intern_meta_thread_messages",
+            HttpMethod.GET,
+            "/smr/research-intern/meta-threads/{meta_thread_id}/messages",
+            idempotent=True,
+        ),
+        _operation(
+            "create_intern_meta_thread_message",
+            HttpMethod.POST,
+            "/smr/research-intern/meta-threads/messages",
+            mutation=True,
+            idempotent=True,
+        ),
         _operation(
             "list_intern_runtime_events",
             HttpMethod.GET,