Models: M

MCPAuthHeader

One header a header auth sends: <name>: <prefix><secret>.

• name: str
• secret_ref: kindgi.client.MCPEndpointSecretRef (secretRef on the wire)
• prefix: str | None (optional)

MCPBasicAuth

HTTP Basic: the runtime sends Authorization: Basic base64(<username>:<secret>), with the secret secretRef names (a WordPress Application Password, for one).

• scheme: Literal['basic']
• username: str
• secret_ref: kindgi.client.MCPEndpointSecretRef (secretRef on the wire)

MCPEndpoint

• endpoint_id: str (endpointId on the wire)
• name: str
• transport: Union[Literal['stdio', 'http-sse', 'streamable-http'], str]
• config: kindgi.client.MCPEndpointConfigStdio | kindgi.client.MCPEndpointConfigHttpSse | kindgi.client.MCPEndpointConfigStreamableHttp | kindgi.client.MCPEndpointConfigUnrecognized
• secret_ref: kindgi.client.MCPEndpointSecretRef | None (secretRef on the wire) (optional)
• auth: Optional[Annotated[kindgi.client.MCPBasicAuth | kindgi.client.MCPOAuth2ClientCredentialsAuth | kindgi.client.MCPHeaderAuth | kindgi.client.MCPEndpointAuthUnrecognized, <kindgi.client._open.OpenUnion object at 0x10c403fd0>]] (optional)
• instructions: str | None (optional)
• metadata: dict[str, Any] | None (optional)
• send_traceparent: bool | None (sendTraceparent on the wire) (optional)
• secret_scopes: dict[str, Optional[Annotated[kindgi.client.RecordedSecretScopeTenant | kindgi.client.RecordedSecretScopeOrg | kindgi.client.RecordedSecretScopeProject | kindgi.client.RecordedSecretScopeUnrecognized, <kindgi.client._open.OpenUnion object at 0x10c408390>]]] | None (secretScopes on the wire) (optional)

MCPEndpointAuthUnrecognized

A scheme this client doesn't know yet, from a newer runtime: the object as it came, every field kept.

• scheme: str

MCPEndpointCollectionPage

• data: list[kindgi.client.MCPEndpoint]
• next_cursor: str | None (nextCursor on the wire) (optional)
• has_more: bool (hasMore on the wire)

MCPEndpointConfigHttpSse

Transport-tagged config union. Server enforces config.transport === transport at registration.

• transport: Literal['http-sse']
• url: AnyUrl
• sse_url: AnyUrl | None (sseUrl on the wire) (optional)
• headers: dict[str, str] | None (optional)

MCPEndpointConfigStdio

Transport-tagged config union. Server enforces config.transport === transport at registration.

• transport: Literal['stdio']
• command: str
• args: list[str] | None (optional)
• env: dict[str, str] | None (optional)

MCPEndpointConfigStreamableHttp

Transport-tagged config union. Server enforces config.transport === transport at registration.

• transport: Literal['streamable-http']
• url: AnyUrl
• headers: dict[str, str] | None (optional)

MCPEndpointConfigUnrecognized

A transport this client doesn't know yet, from a newer runtime: the object as it came, every field kept.

• transport: str

MCPEndpointSecretRef

The secret an MCP endpoint authenticates with: a name in the deployment's secrets store, resolved at the endpoint's tenant scope by the runtime (the shape webhooks and providers use). As the endpoint's own secretRef, it is sent as its bearer; inside auth, it is the scheme's password, client secret or header value. The endpoint keeps only this reference.

• env_name: str (envName on the wire)
• name: str

MCPHeaderAuth

Headers of the server's own, each with a secret: an API key in X-Api-Key, a key and a secret in two headers, or Authorization with a prefix other than Bearer (Token …). The runtime resolves each secretRef when it connects, and refuses to follow a redirect with them, as it does for every auth.

• scheme: Literal['header']
• headers: list[kindgi.client.MCPAuthHeader]

MCPOAuth2ClientCredentialsAuth

OAuth 2 client credentials: the runtime asks tokenUrl for an access token (grant_type=client_credentials) as clientId, with the client secret secretRef names, sends it as the endpoint's bearer, and asks for a new one before it expires (Drupal's Simple OAuth, for one). The token is never stored.

• scheme: Literal['oauth2-client-credentials']
• token_url: AnyUrl (tokenUrl on the wire)
• client_id: str (clientId on the wire)
• secret_ref: kindgi.client.MCPEndpointSecretRef (secretRef on the wire)
• scope: str | None (optional)
• audience: str | None (optional)
• client_auth: Optional[Annotated[Union[Literal['client_secret_basic', 'client_secret_post'], str], <kindgi.client._open.OpenEnum object at 0x10b6b7e10>]] (clientAuth on the wire) (optional)

MCPPrompt

• name: str
• description: str | None (optional)
• arguments: list[kindgi.client.MCPPromptArgument] | None (optional)

MCPPromptArgument

• name: str
• description: str | None (optional)
• required: bool | None (optional)

MCPPromptCollection

• data: list[kindgi.client.MCPPrompt]

MCPPromptMessage

• role: Union[Literal['user', 'assistant'], str]
• content: kindgi.client.MCPPromptMessageContentText | kindgi.client.MCPPromptMessageContentImage | kindgi.client.MCPPromptMessageContentUnrecognized

MCPPromptMessageContentImage

• type: Literal['image']
• data: str
• mime_type: str (mimeType on the wire)

MCPPromptMessageContentText

• type: Literal['text']
• text: str

MCPPromptMessageContentUnrecognized

A type this client doesn't know yet, from a newer runtime: the object as it came, every field kept.

• type: str

MCPResource

• uri: str
• name: str
• description: str | None (optional)
• mime_type: str | None (mimeType on the wire) (optional)

MCPResourceCollection

• data: list[kindgi.client.MCPResource]

MCPResourceContent

• uri: str
• mime_type: str | None (mimeType on the wire) (optional)
• text: str | None (optional)
• blob: str | None (optional)

MailFire

One mail a mail trigger found and what came of it. A thread's mail runs one at a time, oldest first.

• fire_id: str (fireId on the wire)
• trigger_id: str (triggerId on the wire)
• fired_at: AwareDatetime (firedAt on the wire)
• outcome: Union[Literal['pending', 'started', 'skipped', 'refused', 'failed'], str]
• run_id: uuid.UUID | None (runId on the wire) (optional)
• version: int | None (optional)
• detail: str | None (optional)
• counts_toward_pause: bool | None (countsTowardPause on the wire) (optional)

MailFirePage

• data: list[kindgi.client.MailFire]
• has_more: bool (hasMore on the wire)
• next_cursor: str | None (nextCursor on the wire) (optional)

MailTriggerCollectionPage

• data: list[kindgi.client.MailTriggerRecord]
• next_cursor: str | None (nextCursor on the wire) (optional)
• has_more: bool (hasMore on the wire)

MailTriggerDefinition

What a mail trigger's version runs, as whom, and which mailbox it reads at what pace, as its record names them, and never its state (status, next or last fire).

• flow_id: str | None (flowId on the wire) (optional)
• flow_version: str | None (flowVersion on the wire) (optional)
• agent_id: str | None (agentId on the wire) (optional)
• agent_version: str | None (agentVersion on the wire) (optional)
• project_id: uuid.UUID (projectId on the wire)
• owner: kindgi.client.TriggerOwner
• mailbox: kindgi.client.MailTriggerMailbox
• folder: str | None (optional)
• poll_seconds: int (pollSeconds on the wire)
• runs_per_hour: int (runsPerHour on the wire)
• label: str | None
• tools_allowed_unattended: list[kindgi.client.ToolsAllowedUnattendedItem] | None (toolsAllowedUnattended on the wire) (optional)

MailTriggerMailbox

The mailbox a mail trigger reads: its app (google: Gmail; microsoft: Outlook) and whose it is (company: the company's mailbox, through the company's connection of that app; person: the trigger owner's own, through their connection).

• app: Union[Literal['google', 'microsoft'], str]
• as_: Union[Literal['person', 'company'], str] (as on the wire)

MailTriggerRecord

A mail trigger: each new mail in its mailbox's folder starts a run of its agent or flow, with the mail as the run's input, as its owner. In such a run, every call that changes something, or uses the run's own mailbox, waits for a person's yes unless the trigger lists it (toolsAllowedUnattended).

• trigger_id: str (triggerId on the wire)
• flow_id: str | None (flowId on the wire) (optional)
• flow_version: str | None (flowVersion on the wire) (optional)
• agent_id: str | None (agentId on the wire) (optional)
• agent_version: str | None (agentVersion on the wire) (optional)
• project_id: uuid.UUID (projectId on the wire)
• owner: kindgi.client.TriggerOwner
• mailbox: kindgi.client.MailTriggerMailbox
• folder: str | None (optional)
• poll_seconds: int (pollSeconds on the wire)
• runs_per_hour: int (runsPerHour on the wire)
• label: str | None
• status: Union[Literal['active', 'paused'], str]
• status_reason: str | None (statusReason on the wire) (optional)
• version: int | None (optional)
• account: kindgi.client.Account | None (optional)
• last_polled_at: AwareDatetime | None (lastPolledAt on the wire) (optional)
• tools_allowed_unattended: list[kindgi.client.ToolsAllowedUnattendedItem] | None (toolsAllowedUnattended on the wire) (optional)
• last_fired_at: AwareDatetime | None (lastFiredAt on the wire)
• created_at: AwareDatetime (createdAt on the wire)
• updated_at: AwareDatetime (updatedAt on the wire)

MailTriggerVersion

One version of a mail trigger: what it was from createdAt until the next. A new mail's run uses the newest when it starts, and keeps it.

• trigger_id: str (triggerId on the wire)
• version: int
• created_at: AwareDatetime (createdAt on the wire)
• created_by: str | None (createdBy on the wire) (optional)
• cause: Union[Literal['register', 'edit', 'owner', 'first-fire', 'unversioned-edit', 'pin'], str]
• definition: kindgi.client.MailTriggerDefinition

MailTriggerVersionPage

Newest first.

• data: list[kindgi.client.MailTriggerVersion]
• has_more: bool (hasMore on the wire)
• next_cursor: str | None (nextCursor on the wire) (optional)

MemoryErasure

• id: uuid.UUID
• selector_kind: Union[Literal['fact', 'participant', 'external', 'conversation'], str] (selectorKind on the wire)
• selector: kindgi.client.MemoryErasureFactSelector | kindgi.client.MemoryErasureSubjectSelector | kindgi.client.MemoryErasureConversationSelector | None (optional)
• status: Union[Literal['pending', 'running', 'waiting-on-run', 'completed', 'failed'], str]
• phase: Union[Literal['seed', 'expand', 'settle', 'erase', 'done'], str]
• requested_by: str (requestedBy on the wire)
• matchable: bool
• counts: dict[str, CountsAdditionalProperty]
• attempts: int
• last_error: str | None (lastError on the wire) (optional)
• waiting_on: kindgi.client.WaitingOn | None (waitingOn on the wire) (optional)
• forced: Optional[Literal[True]] (optional)
• settle_rounds_capped: Optional[Literal[True]] (settleRoundsCapped on the wire) (optional)
• created_at: AwareDatetime (createdAt on the wire)
• started_at: AwareDatetime | None (startedAt on the wire) (optional)
• completed_at: AwareDatetime | None (completedAt on the wire) (optional)
• replayed_at: AwareDatetime | None (replayedAt on the wire) (optional)

MemoryErasureConversationSelector

One conversation.

• conversation_id: str (conversationId on the wire)

MemoryErasureCreated

• id: uuid.UUID
• selector_kind: Union[Literal['fact', 'participant', 'external', 'conversation'], str] (selectorKind on the wire)
• selector: kindgi.client.MemoryErasureFactSelector | kindgi.client.MemoryErasureSubjectSelector | kindgi.client.MemoryErasureConversationSelector | None (optional)
• status: Union[Literal['pending', 'running', 'waiting-on-run', 'completed', 'failed'], str]
• phase: Union[Literal['seed', 'expand', 'settle', 'erase', 'done'], str]
• requested_by: str (requestedBy on the wire)
• matchable: bool
• counts: dict[str, CountsAdditionalProperty]
• attempts: int
• last_error: str | None (lastError on the wire) (optional)
• waiting_on: kindgi.client.WaitingOn | None (waitingOn on the wire) (optional)
• forced: Optional[Literal[True]] (optional)
• settle_rounds_capped: Optional[Literal[True]] (settleRoundsCapped on the wire) (optional)
• created_at: AwareDatetime (createdAt on the wire)
• started_at: AwareDatetime | None (startedAt on the wire) (optional)
• completed_at: AwareDatetime | None (completedAt on the wire) (optional)
• replayed_at: AwareDatetime | None (replayedAt on the wire) (optional)
• warnings: list[kindgi.client.Warning1] | None (optional)

MemoryErasureFactSelector

One fact.

• fact_id: str (factId on the wire)

MemoryErasureLedger

• data: list[kindgi.client.MemoryErasureLedgerEntry]

MemoryErasureLedgerEntry

• id: uuid.UUID
• selector_kind: Union[Literal['fact', 'participant', 'external', 'conversation'], str] (selectorKind on the wire)
• selector_hmac: str | None (selectorHmac on the wire) (optional)
• key_id: str | None (keyId on the wire) (optional)
• requested_by: str (requestedBy on the wire)
• status: Union[Literal['pending', 'running', 'waiting-on-run', 'completed', 'failed'], str]
• created_at: AwareDatetime (createdAt on the wire)
• completed_at: AwareDatetime | None (completedAt on the wire) (optional)

MemoryErasurePage

• data: list[kindgi.client.MemoryErasure]
• has_more: bool (hasMore on the wire)
• next_cursor: str | None (nextCursor on the wire) (optional)

MemoryErasureSubjectSelector

A person: an app's end user (participant), or an external subject facts name. Erasing a Kindgi user isn't offered.

• subject: kindgi.client.Subject

Metadatum

• root: str

Methods

The ways in this deployment allows, for a sign-in page to show. Absent from older servers.

• identity_providers: bool (identityProviders on the wire)
• api_token: bool (apiToken on the wire)
• session_cookie: Optional[Annotated[Union[Literal['secure', 'plain'], str], <kindgi.client._open.OpenEnum object at 0x10b6b7e10>]] (sessionCookie on the wire) (optional)
• email_link: kindgi.client.EmailLink | None (emailLink on the wire) (optional)

Metric

• name: Union[Literal['weightedYesShare', 'judgedCoverage', 'weightedPrecisionAtK'], str]
• k: int | None (optional)
• min_candidate: float | None (minCandidate on the wire) (optional)
• max_drop: float | None (maxDrop on the wire) (optional)

Metrics

• weighted_yes_share: kindgi.client.ComparisonMetric (weightedYesShare on the wire)
• judged_coverage: kindgi.client.ComparisonMetric (judgedCoverage on the wire)
• weighted_precision_at_k: kindgi.client.ComparisonMetric (weightedPrecisionAtK on the wire)

MintPublicRunTokenBody

• run_ids: list[kindgi.client.RunId] (runIds on the wire)
• expires_in_seconds: int | None (expiresInSeconds on the wire) (optional)

MintPublicRunTokenResult

• token: str
• expires_at: AwareDatetime (expiresAt on the wire)
• run_ids: list[str] (runIds on the wire)

MintSystemKeyBody

• scopes: list[Literal['system:tenants', 'system:tenants:create', 'system:tenants:image-prefix', 'system:tenants:production', 'system:tenants:limits', 'system:tenants:contacts', 'system:tenants:purge', 'system:suspend', 'system:deployments', 'system:pack-env', 'system:usage:read', 'system:license', 'kindgi:system']]
• label: str | None (optional)
• expires_at: AwareDatetime | None (expiresAt on the wire) (optional)

MintSystemKeyResult

The new system key, plus its secret.

• id: str
• label: str | None (optional)
• scopes: list[Annotated[Union[Literal['system:tenants', 'system:tenants:create', 'system:tenants:image-prefix', 'system:tenants:production', 'system:tenants:limits', 'system:tenants:contacts', 'system:tenants:purge', 'system:suspend', 'system:deployments', 'system:pack-env', 'system:usage:read', 'system:license', 'kindgi:system'], str], <kindgi.client._open.OpenEnum object at 0x10b6b7e10>]]
• created_at: AwareDatetime (createdAt on the wire)
• expires_at: AwareDatetime | None (expiresAt on the wire) (optional)
• revoked_at: AwareDatetime | None (revokedAt on the wire) (optional)
• minted_by: str (mintedBy on the wire)
• token: str

MintTokenBody

A new API key. for is whom it acts for: the caller by default; only a tenant admin mints for someone else.

• for_: kindgi.client.ApiKeyPrincipal | None (for on the wire) (optional)
• role: Optional[Literal['admin', 'member']] (optional)
• capabilities: list[kindgi.client.Capability] | None (optional)
• label: str | None (optional)
• expires_at: AwareDatetime | None (expiresAt on the wire) (optional)
• project_id: uuid.UUID | None (projectId on the wire) (optional)

MintTokenResult

The new key, plus its secret.

• token_id: uuid.UUID (tokenId on the wire)
• principal: kindgi.client.ApiKeyPrincipal | None (optional)
• role: Union[Literal['admin', 'member'], str]
• capabilities: list[kindgi.client.Capability]
• label: str | None (optional)
• project_id: uuid.UUID | None (projectId on the wire) (optional)
• created_by: str | None (createdBy on the wire) (optional)
• created_at: AwareDatetime (createdAt on the wire)
• expires_at: AwareDatetime | None (expiresAt on the wire) (optional)
• revoked_at: AwareDatetime | None (revokedAt on the wire) (optional)
• last_used_at: AwareDatetime | None (lastUsedAt on the wire) (optional)
• token: str

Model

For a drafter that used a model: which.

• provider_id: str (providerId on the wire)
• model: str

Model1

For a prompt pass: the provider and model that drafts the templates.

• provider_id: str (providerId on the wire)
• model: str

Model2

For a prompt pass: the tenant's provider and model that drafts the templates.

• provider_id: str (providerId on the wire)
• model: str

Model3

• provider_id: str (providerId on the wire)
• model: str
• runs: int

Model4

• provider_id: str (providerId on the wire)
• model: str

ModelCallError

Why a model call failed (status: failed).

• message: str

ModelCallThinking

The call's thinking. asked without level: nothing was sent (the model doesn't think, or its adapter doesn't say). level without asked: the model's thinking.default. asked and level differ: the level was rounded to one the model takes, and the call warned thinking-level-adjusted.

• asked: Optional[Annotated[Union[Literal['lowest', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'], str], <kindgi.client._open.OpenEnum object at 0x10b6b7e10>]] (optional)
• level: Optional[Annotated[Union[Literal['lowest', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'], str], <kindgi.client._open.OpenEnum object at 0x10b6b7e10>]] (optional)
• sent: dict[str, str] | None (optional)

ModelCallTokens

The call's tokens. promptTokens / completionTokens are the totals; cacheReadTokens / cacheWriteTokens are parts of promptTokens, reasoningTokens of completionTokens, present when the provider reports them.

• prompt_tokens: int (promptTokens on the wire)
• completion_tokens: int (completionTokens on the wire)
• cache_read_tokens: int | None (cacheReadTokens on the wire) (optional)
• cache_write_tokens: int | None (cacheWriteTokens on the wire) (optional)
• reasoning_tokens: int | None (reasoningTokens on the wire) (optional)

ModelInfo

• name: str
• context_window: int (contextWindow on the wire)
• features: list[Annotated[Union[Literal['structured-output', 'vision', 'audio-input', 'audio-output', 'tool-use', 'parallel-tool-use', 'thinking', 'long-context', 'code-execution', 'web-search', 'file-search', 'streaming', 'batch'], str], <kindgi.client._open.OpenEnum object at 0x10b6b7e10>]]
• cost: kindgi.client.ProviderCost
• p95_latency_ms: float | None (p95LatencyMs on the wire) (optional)
• max_output_tokens: int | None (maxOutputTokens on the wire) (optional)
• sampling: bool | None (optional)
• thinking: kindgi.client.ModelThinking | None (optional)
• description: str | None (optional)

ModelThinking

How the model thinks before it answers, and the levels it takes, so a call's level (an agent's model settings, or a judge's lowest) is sent as one it takes: any other is rounded to the next one it takes, or its highest, with a thinking-level-adjusted warning. Absent: it doesn't think, or nothing is known, and nothing is sent for it.

• mode: Union[Literal['adaptive', 'always'], str]
• lowest: str
• levels: list[Annotated[Union[Literal['minimal', 'low', 'medium', 'high', 'xhigh', 'max'], str], <kindgi.client._open.OpenEnum object at 0x10b6b7e10>]] | None (optional)
• default: Optional[Annotated[Union[Literal['lowest', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'], str], <kindgi.client._open.OpenEnum object at 0x10b6b7e10>]] (optional)

MyKeyLimits

The caller's API key, when it is one, and what it limits.

• token_id: str (tokenId on the wire)
• role: Optional[Annotated[Union[Literal['admin', 'member'], str], <kindgi.client._open.OpenEnum object at 0x10b6b7e10>]] (optional)
• project_id: str | None (projectId on the wire) (optional)

MyOrgAccess

• org_id: str (orgId on the wire)
• name: str
• role: Union[Literal['admin', 'member'], str]

MyPermissions

What the caller may do, with its API key's limits applied: tenant admin and member, its reviewer role, its key's limits and capabilities, the projects it may read with its role in each and how it holds it, its orgs and teams, and what each project role allows. Only what the caller may see: nothing names a project it can't read, or anyone else's role.

• tenant_id: uuid.UUID (tenantId on the wire)
• tenant: kindgi.client.MyTenantAccess
• reviewer: kindgi.client.MyReviewerAccess | None (optional)
• key: kindgi.client.MyKeyLimits | None (optional)
• token_capabilities: list[str] (tokenCapabilities on the wire)
• projects: list[kindgi.client.MyProjectAccess]
• orgs: list[kindgi.client.MyOrgAccess]
• teams: list[kindgi.client.MyTeamAccess]
• capabilities: kindgi.client.RoleCapabilities
• read_only_notice: str | None (readOnlyNotice on the wire) (optional)
• license_operator_only: bool | None (licenseOperatorOnly on the wire) (optional)

MyProjectAccess

• project_id: str (projectId on the wire)
• name: str
• role: Union[Literal['owner', 'admin', 'editor', 'viewer'], str]
• via: list[Annotated[kindgi.client.AccessPathDirect | kindgi.client.AccessPathTeam | kindgi.client.AccessPathOrgAdmin | kindgi.client.AccessPathTenantAdmin | kindgi.client.AccessPathUnrecognized, <kindgi.client._open.OpenUnion object at 0x10c286410>]]

MyReviewerAccess

• role: Union[Literal['standard', 'senior', 'admin'], str]
• id: str | None (optional)
• decides: list[Annotated[Union[Literal['standard', 'senior', 'admin'], str], <kindgi.client._open.OpenEnum object at 0x10b6b7e10>]]
• can_decide: bool (canDecide on the wire)

MyTeamAccess

• team_id: str (teamId on the wire)
• name: str
• role: Union[Literal['admin', 'member'], str]

MyTenantAccess

• admin: bool
• member: bool | None (optional)