> ## Documentation Index > Fetch the complete documentation index at: https://docs.davinci-app.com/llms.txt > Use this file to discover all available pages before exploring further. # Send a prompt to the session's agent > Gives the agent something to do. Starts a run if none is going, and adds a turn to the conversation if one is. This returns as soon as the agent has accepted the prompt, not when it has finished — a run takes as long as the work takes. Follow it with `getSession` and read `agent.status`, or let the SDK's `waitUntilDone` do that for you. Acceptance is not the same as success. A `202` means the agent took the prompt; a `409` means it refused, which happens when the run it belonged to has ended. Recreate the session in that case rather than retrying the message. The agent can change anything in the project and spends credits doing it, which is why this needs the `agent:message` scope rather than a project write. ## OpenAPI ````yaml /openapi/davinci-public.v2.yaml post /api/v2/projects/{projectId}/sessions/{sessionId}/messages openapi: 3.1.0 info: title: Davinci Public API version: 2.0.0 description: > Public Routing Server API contract for Davinci integrations and official SDKs. Most operations live on the canonical `/api/v2/projects` mount and accept a personal access token (`dav_ak_live_…` / `dav_ak_test_…`) or browser access token. Evaluation-run creation is the deliberate exception: it accepts only a `purpose=automation` grant issued to a running Code execution. Project membership and role are checked on every user call, and an API key is additionally bounded by the permission ceiling derived from its scopes — a key can never exceed what its owner can do, and usually does less. Collaboration operations (invitations, membership changes, ownership transfer) are deliberately absent: they require a browser session and are not part of the programmatic surface. ## Two planes Most operations are **control plane**: they run on the Routing Server, take small requests, and answer quickly. A few are **data plane**, marked `x-plane: data`, and go straight to the machine holding your project — the only practical way to move multi-gigabyte files or hold a connection open for half an hour. Data-plane operations use a different host and a different credential. Create a session on a project and it returns both: a `dataPlane.url` to send to and a short-lived `dataPlane.token` (`dav_gr_…`, a *grant*) to send with. A grant reaches exactly one project, carries no more permission than the key that minted it, expires in minutes, and dies when its session closes. It is not interchangeable with an API key in either direction. The data-plane host never names a specific machine, so a project that moves between machines mid-session stays reachable at the same URL. servers: - url: https://davinci-app.com description: Production (control plane) - url: https://davinci-app.com/data description: >- Production (data plane). Serves the operations marked `x-plane: data`, using a session's grant rather than an API key. security: - ApiKeyBearer: [] tags: - name: Projects description: >- Create, inspect, open, close, and delete projects, and manage their attached files. - name: Content description: > Read and write the objects a project is made of. These reach the running project rather than storage, so they see uncommitted work — and so they open the project if it is not already open. - name: Branches description: > Branches, commits, and the history of a single object. A commit captures the running project's state, so these operations need the branch loaded, which they arrange for the caller. - name: Sessions description: > A session opens a project, holds it open, and issues the grant that reaches the data plane. It is the programmatic equivalent of having a project open in a browser tab: while it lives, the project stays loaded. It is also where the agent lives. Send it a prompt, read its status from the session, read the transcript back, and stop a run that is going the wrong way. - name: AgentModels description: > Chat models available to your account. The returned keys are the values accepted by the session message API; availability follows your subscription, tenant, and any profile assigned to your account. - name: Tools description: > Invoke one of the agent's tools yourself, without the agent. Useful when you already know the operation you want and do not need a model to choose it — and when you want a deterministic result rather than an interpreted one. A tool is still held to the permissions of the credential invoking it, so a key cannot reach through a tool to something its scopes exclude. - name: Files description: > Data-plane file transfer. These reach your project's machine directly using a session's grant, which is what allows request bodies far larger than the control plane accepts. - name: Usage description: > What your models cost, broken down by model, project, session, or day. These read the usage ledger, which records one event per completed provider call — not your credit balance, which is `/api/v2/billing`. Usage is reported on an interval rather than per call, so a run that is still going may not be fully counted yet. Every response carries `asOf`, the moment the newest counted event was recorded, so you can see how current a total is instead of guessing. This is separate from `projects:read` on purpose: a key that reads your project data is not thereby allowed to see what you spend. - name: Evaluations description: | Lifecycle for the ephemeral target sandbox an evaluation runs against. Creation is available only to a `purpose=automation` grant issued to a running Code execution, so a sandbox always belongs to code rather than to a person's key. It returns a second, `purpose=evaluation` grant bound to the new sandbox; it never upgrades or replaces the source credential. - name: Tests description: > Asynchronously run an authored Test. The Test executes its linked Code object and applies its native evaluation criteria to derive the verdict. This is one way to start Code, not a prerequisite for anything the Code can do: the same function called directly holds the same authority. - name: Organizations description: Discover organizations available as containers for team planning. - name: Cards description: > Project-scoped agile cards, their index hierarchy, comments, tags, assignees, card dependencies, and design-object references. Project access is checked on every call; an inaccessible project is reported as not found. - name: Teams description: > Organization-scoped team boards, linked projects, workflow columns, sprints, analytics, and card placements. Team visibility is privacy preserving: inaccessible organizations, private teams, and cross-organization ids are reported as not found rather than revealing that they exist. paths: /api/v2/projects/{projectId}/sessions/{sessionId}/messages: parameters: - $ref: '#/components/parameters/ProjectId' - $ref: '#/components/parameters/SessionId' post: tags: - Sessions summary: Send a prompt to the session's agent description: > Gives the agent something to do. Starts a run if none is going, and adds a turn to the conversation if one is. This returns as soon as the agent has accepted the prompt, not when it has finished — a run takes as long as the work takes. Follow it with `getSession` and read `agent.status`, or let the SDK's `waitUntilDone` do that for you. Acceptance is not the same as success. A `202` means the agent took the prompt; a `409` means it refused, which happens when the run it belonged to has ended. Recreate the session in that case rather than retrying the message. The agent can change anything in the project and spends credits doing it, which is why this needs the `agent:message` scope rather than a project write. operationId: sendAgentMessage requestBody: required: true content: application/json: schema: $ref: '#/components/schemas/SendAgentMessageRequest' responses: '202': description: The agent accepted the prompt. The run is now in progress. content: application/json: schema: $ref: '#/components/schemas/SendAgentMessageResponse' '400': description: > Invalid request. Error code is `MISSING_MESSAGE`, `MESSAGE_TOO_LARGE`, `INVALID_MESSAGE_ID`, `INVALID_CONTEXT`, `INVALID_PERSONA`, `UNKNOWN_PERSONA`, `INVALID_MODEL`, `UNKNOWN_MODEL`, `INVALID_MODEL_OPTIONS`, `INVALID_WEB_SEARCH`, `LLM_OPTION_UNKNOWN`, or `LLM_OPTION_VALUE_UNAVAILABLE`. `UNKNOWN_PERSONA` names a persona the project does not define, and carries `details.definedPersonas` — the ids that would have worked. The message is refused rather than run under a default persona you did not ask for. `UNKNOWN_MODEL` names a well-formed model key outside the calling account's effective profile and carries `details.availableModels`. An invalid model option identifies its model and option key in `details.model` and `details.option`. content: application/json: schema: $ref: '#/components/schemas/ErrorEnvelope' '401': $ref: '#/components/responses/Unauthorized' '403': $ref: '#/components/responses/Forbidden' '404': description: > No such session, it belongs to another user, or it belongs to a different project than the one in the path. Error code is `SESSION_NOT_FOUND`. content: application/json: schema: $ref: '#/components/schemas/ErrorEnvelope' '409': description: > The agent refused the message (`MESSAGE_REFUSED`), or the project the session opened is no longer running (`PROJECT_NOT_RUNNING`). content: application/json: schema: $ref: '#/components/schemas/ErrorEnvelope' '429': $ref: '#/components/responses/RateLimited' '500': $ref: '#/components/responses/InternalError' security: - ApiKeyBearer: [] x-codeSamples: - lang: typescript label: TypeScript SDK source: | import { DavinciClient } from '@celedon/davinci-sdk'; const client = new DavinciClient({ apiKey: process.env.DAVINCI_API_KEY!, }); await client.sessions.with(projectId, async (session) => { await session.sendMessage('Add a 10mm M3 standoff under each corner of the base plate'); const final = await session.waitUntilDone(); console.log(final.status); }); - lang: python label: Python SDK source: | import os from davinci_sdk import DavinciClient with DavinciClient(api_key=os.environ["DAVINCI_API_KEY"]) as client: with client.sessions.create(project_id) as session: session.send_message( "Add a 10mm M3 standoff under each corner of the base plate" ) final = session.wait_until_done() print(final.status) components: parameters: ProjectId: name: projectId in: path required: true schema: type: string minLength: 1 description: Project id. May be compound in the form `{projectId}--{branchName}`. SessionId: name: sessionId in: path required: true schema: type: string format: uuid description: Session id from `createSession`. schemas: SendAgentMessageRequest: type: object required: - message properties: message: type: string minLength: 1 maxLength: 100000 description: What you want the agent to do. messageId: type: string description: > Your own id for this prompt, echoed back and recorded in the transcript. Generated for you if omitted. context: type: object description: > Opaque data kept with the session and returned to your webhook alongside the agent's replies. Davinci does not interpret it. additionalProperties: true model: type: string minLength: 1 maxLength: 200 pattern: ^[a-z0-9][a-z0-9._:-]*$ description: > A model key returned by `listAgentModels`. Omit it to use the calling account's default model. The choice applies to this prompt; every prompt that omits it uses the account default. modelOptions: type: object maxProperties: 32 description: > Model configuration keyed by the option keys returned for the selected model by `listAgentModels`. Values may be strings, numbers, or booleans. Omitted options use that model's effective account defaults. additionalProperties: $ref: '#/components/schemas/AgentModelOptionValue' webSearch: type: boolean default: false description: Whether the agent may use web search for this prompt. persona: type: string maxLength: 200 description: > The id of a persona the project defines, which sets who the agent is for this prompt and every one after it in the session. Omit to keep whichever persona the session is already running under; omitting it on the first prompt uses the project's default. This is an id, not a persona. An object is refused with `INVALID_PERSONA`, because a persona's name, purpose and approach are written into the system prompt — accepting one here would let a caller rewrite the instructions that decide what the agent will refuse to do. Define personas in the project, then name one. An id the project does not define is refused with `UNKNOWN_PERSONA` rather than quietly falling back to a default. additionalProperties: false SendAgentMessageResponse: type: object required: - sessionId - taskId - messageId - status properties: sessionId: type: string format: uuid taskId: type: string description: The run the prompt joined. messageId: type: string status: type: string description: >- Always `message_delivered` — a refusal is a `409`, not a status here. additionalProperties: true ErrorEnvelope: description: > The error shape for every failure on this API, whether it was refused by the credential layer before reaching a domain or by the domain itself. Branch on `code`, which is stable. `message` is for a person reading a log or a dialog and may be reworded. `details` carries fields specific to one failure — a project-limit refusal reports its numbers there — and is absent when there are none. type: object required: - success - error properties: success: type: boolean const: false error: type: object required: - code - message properties: code: type: string message: type: string details: type: object additionalProperties: true additionalProperties: true additionalProperties: true AgentModelOptionValue: description: A typed model option value. oneOf: - type: string - type: number - type: boolean responses: Unauthorized: description: > No credential was supplied, or the supplied credential is malformed, expired, or revoked. A credential that is present but unusable is never downgraded to an anonymous request. content: application/json: schema: $ref: '#/components/schemas/ErrorEnvelope' Forbidden: description: > Authenticated but not authorized. Either the acting user lacks the required resource permission, the key's scope ceiling excludes it, or the endpoint rejects this credential type (`CREDENTIAL_NOT_PERMITTED`). content: application/json: schema: $ref: '#/components/schemas/ErrorEnvelope' RateLimited: description: Request rate exceeded, either globally or for this key. headers: Retry-After: schema: type: integer minimum: 1 description: Seconds to wait before retrying. content: application/json: schema: $ref: '#/components/schemas/ErrorEnvelope' InternalError: description: Unexpected server error. content: application/json: schema: $ref: '#/components/schemas/ErrorEnvelope' securitySchemes: ApiKeyBearer: type: http scheme: bearer bearerFormat: dav_ak_live_... or dav_ak_test_... x-default: dav_ak_live_your_token description: > Personal access token. The scopes granted at issuance determine both which operations the key may call and the ceiling on the resource permissions it can exercise. Each scope family is a ladder: `projects:manage` implies `projects:write` and `projects:read`; `cards:manage` implies `cards:write` and `cards:read`; and `teams:manage` implies `teams:write` and `teams:read`. These are named API capability bundles, not blanket domain roles: `manage` exposes only the permissions enumerated for that scope and never bypasses the acting user's current role-based access. ````