> ## Documentation Index > Fetch the complete documentation index at: https://docs.lerian.studio/llms.txt > Use this file to discover all available pages before exploring further. # Send a message to a session's inbox > Delivers a message from one session to another on the same machine. Delivery is guaranteed: a message to a busy session is queued and delivered when it becomes free, never lost, and delivery survives the recipient restarting. kind message is fire-and-forget with a delivery receipt; kind ask returns an askId whose answer is polled at GET /v1/asks/{askId} and also arrives on the event stream as an intercom-message event; kind answer resolves an earlier ask (askId required) and is posted to the ASKING session's inbox, which is the session that reads it. An ask carries a deadline it is refused at rather than waiting forever — the answerer is a program, and a blocking question between two programs with no deadline is a deadlock rather than somebody taking their time. An ask that would close a loop of sessions waiting on each other is refused at send (NRY-0025), naming both parties. ## OpenAPI ````yaml /en/openapi/v3-current/narya.yaml post /v1/sessions/{sessionId}/inbox openapi: 3.1.0 info: title: Narya Host API version: 1.0.0 description: >- The contract between the Narya host and every client. One long-lived host runs on your machine and serves this API over a Unix socket in your Narya home. Narya creates the socket owner-only, and file permissions are the whole authorization. There is no password, no token and no TLS. The terminal client and the one-shot command that Lerian ships drive this API, and a client you write drives the same one. Results never arrive on the response of the request that caused them. Submitting a message returns 202 with a turn id. Everything the turn produces streams over GET /v1/events as server-sent events with a typed envelope, and a stream resumes from a Last-Event-ID header. One error envelope: code, title, message, and fields on 422. Codes are NRY- followed by four digits. A paged list answers items, limit and a nextCursor when more remains. Cursors are opaque. servers: [] security: [] tags: - name: host description: The host process itself — version, uptime, mode, store. - name: sessions description: Durable conversation containers. Archive, never destroy. - name: messages description: Submitting work into a session and interrupting it. - name: events description: The server-sent event stream every client consumes. - name: lanes description: Parallel tracks inside a session — main, subagent, side. - name: agents description: Named recipes — instructions, tools, model, policy. Read-only in v1. - name: ladder description: >- What a person can type: the skills and command files in force for one repository, and expanding one into text. Five origins merged, nearest winning a name, the repository's own rungs gated on trust. - name: permissions description: Pending permission asks, decisions, and the decision audit. - name: intercom description: Sessions on one machine finding and messaging each other. - name: packages description: The one thing a user installs — resources, Go code, or both. - name: workflows description: Deterministic multi-agent orchestration runs. - name: providers description: Model suppliers, their auth state, and the model catalogue. - name: monitors description: >- Long-running watchers a session keeps beside its conversation — a test runner in watch mode, a build, a log being followed. Started by the model or by the person, always listed, always killable. - name: records description: The queryable local record of everything that happened. - name: schedules description: >- Work the host's own clock starts with nobody present — a repository, a prompt, a rule and what one fire may spend. Cancel, never destroy. paths: /v1/sessions/{sessionId}/inbox: parameters: - $ref: '#/components/parameters/SessionIdParam' post: tags: - intercom summary: Send a message to a session's inbox description: >- Delivers a message from one session to another on the same machine. Delivery is guaranteed: a message to a busy session is queued and delivered when it becomes free, never lost, and delivery survives the recipient restarting. kind message is fire-and-forget with a delivery receipt; kind ask returns an askId whose answer is polled at GET /v1/asks/{askId} and also arrives on the event stream as an intercom-message event; kind answer resolves an earlier ask (askId required) and is posted to the ASKING session's inbox, which is the session that reads it. An ask carries a deadline it is refused at rather than waiting forever — the answerer is a program, and a blocking question between two programs with no deadline is a deadlock rather than somebody taking their time. An ask that would close a loop of sessions waiting on each other is refused at send (NRY-0025), naming both parties. operationId: sendInboxMessage requestBody: required: true content: application/json: schema: $ref: '#/components/schemas/InboxMessageCreate' responses: '202': description: >- Accepted for delivery — delivered now, or durably queued until the recipient is free. content: application/json: schema: $ref: '#/components/schemas/InboxReceipt' '400': $ref: '#/components/responses/BadRequest' '404': $ref: '#/components/responses/NotFound' '409': $ref: '#/components/responses/Conflict' '422': $ref: '#/components/responses/UnprocessableEntity' '500': $ref: '#/components/responses/InternalServerError' components: parameters: SessionIdParam: name: sessionId in: path required: true description: The session's id. schema: type: string format: uuid schemas: InboxMessageCreate: type: object description: >- A message from one session to another. kind ask expects an answer and returns an askId; kind message is one-way. Delivery is durable: a busy recipient gets it when free, and it survives a restart. required: - from - content properties: from: type: string maxLength: 256 description: >- The sending session's id. It is a SELECTION among the sessions the caller can already reach, never a claim the host takes on trust: an id outside the caller's reach is refused with the same "no such session" an id that never existed gets. Where the request already carries a sender of its own — the session a tool call runs under — that session is the sender and this field is not consulted at all. content: type: string minLength: 1 description: The message text. kind: type: string enum: - message - ask - answer default: message askId: type: string format: uuid description: >- Required when kind is answer, ignored otherwise: the ask being resolved. The answer is posted to the ASKING session's inbox, so this id and the path's sessionId must describe the same ask — answering a question nobody asked you is refused rather than recorded. examples: - from: midaz-research content: The fee calculation you need is in components/fees/engine.go. kind: message InboxReceipt: type: object description: >- Delivery acknowledgement. queued means the recipient is busy and the message is durably held — it is delivered when the recipient next goes idle, and survives a restart of the host in between. "Held" is bounded by the retention window configured for intercom_messages, not by forever: with no window configured nothing sweeps it, and with one configured `narya retention status` says how long it has and `narya doctor` reports the oldest message still waiting. required: - status properties: status: type: string enum: - delivered - queued deliveryId: type: string format: uuid description: >- This delivery's identity, stable across every redelivery attempt. Transport is at-least-once with an idempotent append: a host that dies between landing a message and recording that it landed offers the message again, and this id is what makes the second attempt recognise the first rather than saying it twice. Content is never an identity — the same sentence said twice is two messages. askId: type: string format: uuid description: >- Present when kind was ask; poll GET /v1/asks/{askId} or watch events for the answer. examples: - status: queued deliveryId: 4d2b6f8a-1c3e-4a5b-9d7f-2e4a6c8b0d1f askId: 8a6b4c2d-0e1f-4a3b-9c5d-7e9f1a3b5c7d Error: type: object description: >- The single error envelope every operation returns. Codes are NRY- followed by four digits and are catalogued in the top-level x-error-catalog extension. fields appears only on 422 validation errors, mapping each offending property to its problem. required: - code - title - message properties: code: type: string pattern: ^NRY-[0-9]{4}$ description: Machine-readable error code from the NRY catalogue. title: type: string maxLength: 256 description: Short human-readable summary of the error class. message: type: string maxLength: 4096 description: Specific, actionable description of what went wrong. fields: type: object description: Per-field validation problems. Present on 422 only. additionalProperties: type: string examples: - code: NRY-0002 title: Session not found message: >- No session with id 6b9f6d2e-1c3a-4f5b-9d7e-2a8c4e6f0b1d exists on this host. responses: BadRequest: description: Malformed request — invalid parameter, cursor, or JSON body. content: application/json: schema: $ref: '#/components/schemas/Error' NotFound: description: The addressed resource does not exist on this host. content: application/json: schema: $ref: '#/components/schemas/Error' Conflict: description: >- The resource's current state rejects the request — archived session, busy lane, slot conflict, failed build, already-final state. content: application/json: schema: $ref: '#/components/schemas/Error' UnprocessableEntity: description: >- The request was well-formed but failed validation. The error's fields map names each offending property. content: application/json: schema: $ref: '#/components/schemas/Error' InternalServerError: description: The host failed — including a store that refuses writes (NRY-0012). content: application/json: schema: $ref: '#/components/schemas/Error' ````