Skip to content
Kindgi

Models: M

View as Markdown

MCPAuthHeader

Section titled “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

Section titled “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

Section titled “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 0x108274250>]] (optional)
  • secret_env: dict[Annotated[str, StringConstraints(strip_whitespace=None, to_upper=None, to_lower=None, strict=None, min_length=1, max_length=None, pattern='^[^=\\u0000]+$', ascii_only=None)], kindgi.client.MCPEndpointSecretRef] | None (secretEnv on the wire) (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 0x108274750>]]] | None (secretScopes on the wire) (optional)

MCPEndpointAuthUnrecognized

Section titled “MCPEndpointAuthUnrecognized”

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

  • scheme: str

MCPEndpointCollectionPage

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

MCPEndpointConfigHttpSse

Section titled “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

Section titled “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

Section titled “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

Section titled “MCPEndpointConfigUnrecognized”

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

  • transport: str

MCPEndpointSecretRef

Section titled “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; in secretEnv, a variable's value for a stdio server. The endpoint keeps only this reference.

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

MCPHeaderAuth

Section titled “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

Section titled “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 0x1073beed0>]] (clientAuth on the wire) (optional)

MCPPrompt

Section titled “MCPPrompt”
  • name: str
  • description: str | None (optional)
  • arguments: list[kindgi.client.MCPPromptArgument] | None (optional)

MCPPromptArgument

Section titled “MCPPromptArgument”
  • name: str
  • description: str | None (optional)
  • required: bool | None (optional)

MCPPromptCollection

Section titled “MCPPromptCollection”
  • data: list[kindgi.client.MCPPrompt]

MCPPromptMessage

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

MCPPromptMessageContentImage

Section titled “MCPPromptMessageContentImage”
  • type: Literal['image']
  • data: str
  • mime_type: str (mimeType on the wire)

MCPPromptMessageContentText

Section titled “MCPPromptMessageContentText”
  • type: Literal['text']
  • text: str

MCPPromptMessageContentUnrecognized

Section titled “MCPPromptMessageContentUnrecognized”

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

  • type: str

MCPResource

Section titled “MCPResource”
  • uri: str
  • name: str
  • description: str | None (optional)
  • mime_type: str | None (mimeType on the wire) (optional)

MCPResourceCollection

Section titled “MCPResourceCollection”
  • data: list[kindgi.client.MCPResource]

MCPResourceContent

Section titled “MCPResourceContent”
  • uri: str
  • mime_type: str | None (mimeType on the wire) (optional)
  • text: str | None (optional)
  • blob: str | None (optional)

MailFire

Section titled “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

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

MailTriggerCollectionPage

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

MailTriggerDefinition

Section titled “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

Section titled “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 connection of that app connectionId names; 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)
  • connection_id: uuid.UUID | None (connectionId on the wire) (optional)

MailTriggerRecord

Section titled “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

Section titled “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

Section titled “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

Section titled “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

Section titled “MemoryErasureConversationSelector”

One conversation.

  • conversation_id: str (conversationId on the wire)

MemoryErasureCreated

Section titled “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

Section titled “MemoryErasureFactSelector”

One fact.

  • fact_id: str (factId on the wire)

MemoryErasureLedger

Section titled “MemoryErasureLedger”
  • data: list[kindgi.client.MemoryErasureLedgerEntry]

MemoryErasureLedgerEntry

Section titled “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

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

MemoryErasureSubjectSelector

Section titled “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

Section titled “Metadatum”
  • root: str

Methods

Section titled “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 0x1073beed0>]] (sessionCookie on the wire) (optional)
  • email_link: kindgi.client.EmailLink | None (emailLink on the wire) (optional)

Metric

Section titled “Metric”
  • name: Union[Literal['passRate', 'caseCoverage', '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

Section titled “Metrics”
  • pass_rate: kindgi.client.ComparisonMetric (passRate on the wire)
  • case_coverage: kindgi.client.ComparisonMetric (caseCoverage on the wire)
  • weighted_precision_at_k: kindgi.client.ComparisonMetric (weightedPrecisionAtK on the wire)

MintPublicRunTokenBody

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

MintPublicRunTokenResult

Section titled “MintPublicRunTokenResult”
  • token: str
  • expires_at: AwareDatetime (expiresAt on the wire)
  • run_ids: list[str] (runIds on the wire)

MintSystemKeyBody

Section titled “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:env-refs', 'system:usage:read', 'system:license', 'kindgi:system']]
  • label: str | None (optional)
  • expires_at: AwareDatetime | None (expiresAt on the wire) (optional)

MintSystemKeyResult

Section titled “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:env-refs', 'system:usage:read', 'system:license', 'kindgi:system'], str], <kindgi.client._open.OpenEnum object at 0x1073beed0>]]
  • 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

Section titled “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

Section titled “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

ModelCallError

Section titled “ModelCallError”

Why a model call failed (status: failed).

  • message: str

ModelCallThinking

Section titled “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 0x1073beed0>]] (optional)
  • level: Optional[Annotated[Union[Literal['lowest', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'], str], <kindgi.client._open.OpenEnum object at 0x1073beed0>]] (optional)
  • sent: dict[str, str] | None (optional)

ModelCallTokens

Section titled “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

Section titled “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 0x1073beed0>]]
  • 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

Section titled “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 0x1073beed0>]] | None (optional)
  • default: Optional[Annotated[Union[Literal['lowest', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'], str], <kindgi.client._open.OpenEnum object at 0x1073beed0>]] (optional)

Month

Section titled “Month”

With an Improve schedule on the agent and project: this UTC month's spend on their Improve runs, started by hand or by the schedule, against the schedule's monthly cap (US dollars). Only the schedule stops at the cap; a run started by hand isn't refused.

  • spent_usd: str (spentUsd on the wire)
  • cap_usd: str (capUsd on the wire)

MustNotCallItem

Section titled “MustNotCallItem”
  • root: str

MyKeyLimits

Section titled “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 0x1073beed0>]] (optional)
  • project_id: str | None (projectId on the wire) (optional)

MyOrgAccess

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

MyPermissions

Section titled “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

Section titled “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 0x1080430d0>]]

MyReviewerAccess

Section titled “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 0x1073beed0>]]
  • can_decide: bool (canDecide on the wire)

MyTeamAccess

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

MyTenantAccess

Section titled “MyTenantAccess”
  • admin: bool
  • member: bool | None (optional)