Models: C

Call

• run_id: str (runId on the wire)
• node_id: str | None (nodeId on the wire) (optional)
• scope: str | None (optional)
• tool_id: str (toolId on the wire)
• arguments: Any | None (optional)
• result: Any | None (optional)
• from_event: Optional[Literal[True]] (fromEvent on the wire) (optional)

CallDifferenceCount

One way a run's calls differed from a correction's expected decisions; it can quote argument values.

• tool: str
• kind: Literal['count']
• expected: int
• actual: int
• refused: int | None (optional)

CallDifferenceFieldValue

One way a run's calls differed from a correction's expected decisions; it can quote argument values.

• tool: str
• kind: Literal['field-value']
• field: str
• expected: Any
• actual: Any
• refused: bool | None (optional)

CallDifferenceMissingField

One way a run's calls differed from a correction's expected decisions; it can quote argument values.

• tool: str
• kind: Literal['missing-field']
• field: str
• expected: Any
• refused: bool | None (optional)

CallDifferenceMustNotCall

One way a run's calls differed from a correction's expected decisions; it can quote argument values.

• tool: str
• kind: Literal['must-not-call']
• actual: int
• refused: int | None (optional)

CallUsage

• usage: kindgi.client.ModelCallTokens
• cost_usd: float | None (costUsd on the wire) (optional)
• duration_ms: int | None (durationMs on the wire) (optional)
• served_model: str | None (servedModel on the wire) (optional)

CandidateItem

An output's score: Σ yesWeight and Σ totalWeight over its corrected items, and over those among the first k ranked items.

• yes_weight: float (yesWeight on the wire)
• total_weight: float (totalWeight on the wire)
• items: int
• corrected_items: int (correctedItems on the wire)
• top_k: kindgi.client.TopK (topK on the wire)
• fresh: kindgi.client.Fresh | None (optional)

Capability

• root: str

Capability4

Capability declaration — see @kindgi/capabilities. Additional properties are permitted so new capability kinds do not require a wire change.

Capability5

• root: str

CapabilityCollectionPage

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

CapabilityDescriptor

• id: str
• feature: Union[str, 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>]]
• description: str
• kind: str | None (optional)
• params_schema: dict[str, Any] | None (paramsSchema on the wire) (optional)
• providers: list[kindgi.client.CapabilityProvider] | None (optional)

CapabilityProvider

A provider of the workspace with a model that has the feature.

• provider_id: str (providerId on the wire)
• models: list[str]

Cases

The cases the comparison graded: each correction it checked is a case, and it passes when every repetition did.

• min_passing: int | None (minPassing on the wire) (optional)
• no_new_failures: bool | None (noNewFailures on the wire) (optional)

ChangeCorrectionBody

A re-sort, a status, or both (the re-sort first). fixed is set only by a pin or a deploy, and removed by POST /v1/corrections/{correctionId}/remove.

• sorted_to: Optional[Literal['improve', 'developer', 'owner']] (sortedTo on the wire) (optional)
• status: Optional[Literal['open', 'being-fixed', 'wont-fix']] (optional)
• link: str | None (optional)
• reason: str | None (optional)

Changes

The first repetition's items against the corrected ones.

• kept: list[kindgi.client.KeptItem]
• dropped: list[kindgi.client.DroppedItem]
• new: list[kindgi.client.NewItem]

ClaimMappingScopesSpec

Claim path + optional delimiter for extracting Kindgi OAuth scopes from provider claims. When absent, scopes come from the token response scope field instead.

• claim: str
• delimiter: str | None (optional)

ClaimMappingSpec

Per-provider claim mapping. All fields optional; closer to OIDC defaults (sub/email/name) → fewer overrides needed.

• user_id: str | None (userId on the wire) (optional)
• email: str | None (optional)
• display_name: str | None (displayName on the wire) (optional)
• scopes: kindgi.client.ClaimMappingScopesSpec | None (optional)
• metadata: list[kindgi.client.Metadatum] | None (optional)

ClaimOrchestratorRoundBody

• claimant: str
• hold_seconds: int (holdSeconds on the wire)

CodeArtifactRefFilesystem

Handler-artifact pointer. Discriminated on kind: oci is the deploy-pipeline shape (image + module path + artifactVersion); filesystem is the local-development shape — absolute host path at the pack's on-disk handler file. Production servers SHOULD reject filesystem.

• kind: Literal['filesystem']
• module_path: str (modulePath on the wire)

CodeArtifactRefOci

Handler-artifact pointer. Discriminated on kind: oci is the deploy-pipeline shape (image + module path + artifactVersion); filesystem is the local-development shape — absolute host path at the pack's on-disk handler file. Production servers SHOULD reject filesystem.

• kind: Literal['oci']
• image_ref: str (imageRef on the wire)
• module_path: str (modulePath on the wire)
• artifact_version: str (artifactVersion on the wire)

CodeArtifactRefUnrecognized

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

• kind: str

Comparison

• max_age_hours: float | None (maxAgeHours on the wire) (optional)
• test_set: kindgi.client.ReleaseGateSpecComparisonTestSet | None (testSet on the wire) (optional)

Comparison1

• test_run_id: uuid.UUID | None (testRunId on the wire) (optional)
• role: Union[Literal['reference', 'candidate', 'proof'], str]
• part: Union[Literal['search', 'hold-out', 'all'], str]
• block_id: str | None (blockId on the wire) (optional)
• changed: dict[str, Any] | None (optional)
• score: float | None (optional)
• failed: str | None (optional)
• refused: list[kindgi.client.RefusedItem] | None (optional)
• why: str | None (optional)

ComparisonCandidateAgent

What ran on the cases: an agent version, or a flow version (with any versions it swapped in).

• kind: Literal['agent']
• agent_id: str (agentId on the wire)
• version: str
• pins_digest: str | None (pinsDigest on the wire) (optional)
• overrides: kindgi.client.Overrides | None (optional)

ComparisonCandidateFlow

What ran on the cases: an agent version, or a flow version (with any versions it swapped in).

• kind: Literal['flow']
• flow_id: str (flowId on the wire)
• version: str
• versions: kindgi.client.FlowVersionOverrides | None (optional)

ComparisonCaseResult

One case of a comparison: its replay runs, the scores, the items kept, dropped and new, the tool calls, and why it didn't run when it didn't.

• case_id: str (caseId on the wire)
• run_ids: list[str] (runIds on the wire)
• baseline: kindgi.client.ComparisonCaseResultBaseline
• candidate: list[kindgi.client.CandidateItem]
• changes: kindgi.client.Changes | None (optional)
• tools: list[kindgi.client.ComparisonCaseResultTool] | None (optional)
• corrections: list[kindgi.client.ComparisonCaseResultCorrection] | None (optional)
• correction_differences: list[kindgi.client.CorrectionDifference] | None (correctionDifferences on the wire) (optional)
• cost_usd: list[kindgi.client.CostUsdItem] | None (costUsd on the wire) (optional)
• unchecked: str | None (optional)
• diverged: bool
• refused_writes: int (refusedWrites on the wire)
• no_context: bool (noContext on the wire)
• approval_skipped: bool (approvalSkipped on the wire)
• error: str | None (optional)
• stopped: kindgi.client.Stopped | None (optional)
• rescored: Optional[Literal[False]] (optional)

ComparisonCaseResultBaseline

An output's score: Σ yesWeight and Σ totalWeight over its corrected items, and over those among the first k ranked items.

• yes_weight: float (yesWeight on the wire)
• total_weight: float (totalWeight on the wire)
• items: int
• corrected_items: int (correctedItems on the wire)
• top_k: kindgi.client.TopK (topK on the wire)
• fresh: kindgi.client.Fresh | None (optional)

ComparisonCaseResultCorrection

• correction_id: str (correctionId on the wire)
• pass_: bool (pass on the wire)
• repetitions_passed: int (repetitionsPassed on the wire)
• repetitions: int
• why: str | None (optional)
• parts: kindgi.client.Parts | None (optional)

ComparisonCaseResultTool

• step: int
• call_id: str (callId on the wire)
• tool_id: str (toolId on the wire)
• tool_version: str (toolVersion on the wire)
• arguments: Any
• source: Literal['live', 'recorded', 'refused']
• recomputed: bool | None (optional)
• reason: str | None (optional)

ComparisonMetric

One metric, the recorded runs beside the candidate. null where a side had no evidence from corrections: no corrected items, and for passRate no graded expect either. n / weight are the candidate's evidence, the cases it rests on and the weight behind them. For passRate, those are the cases with corrected items or a graded expect, and each graded part of an expect, its decisions and its answer, is one check of weight 1 beside the items' correction weight. For caseCoverage and weightedPrecisionAtK, they're the cases with corrected items only. baselineN / baselineWeight are the recorded side's.

• baseline: float | None
• candidate: float | None
• delta: float | None
• n: int
• weight: float
• baseline_n: int (baselineN on the wire)
• baseline_weight: float (baselineWeight on the wire)
• direction: Literal['higher']
• k: int | None (optional)
• spread: float | None (optional)
• fresh_weight: float | None (freshWeight on the wire) (optional)

CompleteApprovalBody

• decision: Literal['approve', 'reject', 'escalate', 'withdraw']
• rationale: str | None (optional)
• value: Any | None (optional)
• fact_text: str | None (factText on the wire) (optional)

CompleteApprovalResult

A recorded decision, and what it did to the run waiting on the approval. runStatus is the run's status when the decision couldn't resolve its waitpoint because the run had already ended (e.g. cancelled after the decision was recorded); the decision stands.

• kind: Union[Literal['terminal', 'escalated'], str]
• approval: kindgi.client.Approval
• decision: kindgi.client.ReviewDecision
• next_approval: kindgi.client.Approval | None (nextApproval on the wire) (optional)
• waitpoint_resolved: bool (waitpointResolved on the wire)
• run_status: Optional[Annotated[Union[Literal['pending', 'running', 'suspended', 'completed', 'failed', 'cancelled'], str], <kindgi.client._open.OpenEnum object at 0x1073beed0>]] (runStatus on the wire) (optional)
• resume: Optional[Annotated[kindgi.client.CompleteApprovalResultResumeOk | kindgi.client.CompleteApprovalResultResumeFailed | kindgi.client.CompleteApprovalResultResumeUnrecognized, <kindgi.client._open.OpenUnion object at 0x107f4ec10>]] (optional)

CompleteApprovalResultResumeFailed

How the run went on, when this call resumed it (the runtime resumes inline): ok, or failed with the run's error, e.g. tool-version-unresolvable when a tool version the turn started with is gone, or rate-limit-exceeded when a budget kept per workspace refused work the turn needed. The decision stands either way.

• kind: Literal['failed']
• code: str
• message: str

CompleteApprovalResultResumeOk

How the run went on, when this call resumed it (the runtime resumes inline): ok, or failed with the run's error, e.g. tool-version-unresolvable when a tool version the turn started with is gone, or rate-limit-exceeded when a budget kept per workspace refused work the turn needed. The decision stands either way.

• kind: Literal['ok']

CompleteApprovalResultResumeUnrecognized

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

• kind: str

ComplianceEvidence

One evidence record — matches @kindgi/specs/compliance-evidence.schema.json (payload is a versioned document opaque to the wire schema).

• id: str
• tenant_id: uuid.UUID (tenantId on the wire)
• project_id: uuid.UUID | None (projectId on the wire) (optional)
• kind: str
• timestamp: AwareDatetime
• actor: kindgi.client.Actor | None (optional)
• subject: kindgi.client.Subject1 | None (optional)
• outcome: Optional[Annotated[Union[Literal['allowed', 'denied', 'succeeded', 'failed', 'escalated'], str], <kindgi.client._open.OpenEnum object at 0x1073beed0>]] (optional)
• payload: dict[str, Any]
• provenance_ref: kindgi.client.ProvenanceRef2 | None (provenanceRef on the wire) (optional)
• signature: kindgi.client.Signature1 | None (optional)

ComplianceEvidenceCollectionPage

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

ConnectFinish

• kind: Union[Literal['connected', 'declined', 'pick-installation'], str]
• request: kindgi.client.ConnectRequest
• connection: kindgi.client.Connection | None (optional)
• reconnected: bool | None (optional)
• label_taken: str | None (labelTaken on the wire) (optional)
• reviewer_seat: bool | None (reviewerSeat on the wire) (optional)
• main: kindgi.client.ConnectFinishMain | None (optional)

ConnectFinishMain

set: the one they had, connectionId, is now their main, and this one is added. kept: their main, connectionId, stays. missing: they have several and none is their main, so their agents use none until they make one main, or a choice names one.

• state: Union[Literal['set', 'kept', 'missing'], str]
• connection_id: uuid.UUID | None (connectionId on the wire) (optional)

ConnectRequest

A connect: the owner goes to connectUrl, consents at the app, and comes back. A run that needs a connection it lacks waits on one.

• request_id: uuid.UUID (requestId on the wire)
• env_name: str (envName on the wire)
• app_id: uuid.UUID (appId on the wire)
• app: str
• owner: kindgi.client.ConnectionOwner
• permissions: list[str]
• says: list[str]
• reconnects: uuid.UUID | None (optional)
• label: str | None (optional)
• run_id: str | None (runId on the wire) (optional)
• name: str | None (optional)
• started_by: str | None (startedBy on the wire) (optional)
• state: Union[Literal['pending', 'connected', 'declined', 'expired', 'failed'], str]
• failure: str | None (optional)
• missing: list[str] | None (optional)
• installations: list[kindgi.client.ConnectRequestInstallation] | None (optional)
• connection_id: uuid.UUID | None (connectionId on the wire) (optional)
• connect_url: AnyUrl (connectUrl on the wire)
• expires_at: AwareDatetime (expiresAt on the wire)
• created_at: AwareDatetime (createdAt on the wire)
• created_by: str (createdBy on the wire)

ConnectRequestInstallation

A GitHub App installation the person can reach.

• installation_id: str (installationId on the wire)
• account: kindgi.client.ConnectionAccount

ConnectStart

• authorize_url: AnyUrl (authorizeUrl on the wire)

Connection

One owner's account at an app, through a registration, in one env. Never its token.

• connection_id: uuid.UUID (connectionId on the wire)
• env_name: str (envName on the wire)
• app_id: uuid.UUID (appId on the wire)
• app: str
• owner: kindgi.client.ConnectionOwner
• account: kindgi.client.ConnectionAccount
• label: str | None (optional)
• main: bool | None (optional)
• permissions: list[str]
• state: Union[Literal['working', 'needs-reconnecting', 'removing', 'removed'], str]
• state_reason: str | None (stateReason on the wire) (optional)
• installation_id: str | None (installationId on the wire) (optional)
• access_ends_at: AwareDatetime | None (accessEndsAt on the wire) (optional)
• connected_at: AwareDatetime (connectedAt on the wire)
• last_used_at: AwareDatetime | None (lastUsedAt on the wire) (optional)
• created_at: AwareDatetime (createdAt on the wire)
• created_by: str (createdBy on the wire)
• updated_at: AwareDatetime (updatedAt on the wire)
• removed_at: AwareDatetime | None (removedAt on the wire) (optional)
• removed_by: str | None (removedBy on the wire) (optional)
• removed_reason: Optional[Annotated[Union[Literal['disconnected', 'revoked-at-app', 'uninstalled', 'registration-removed', 'replaced'], str], <kindgi.client._open.OpenEnum object at 0x1073beed0>]] (removedReason on the wire) (optional)
• withdrawn: Optional[Annotated[Union[Literal['at-app', 'app-failed', 'kept-for-other-connection', 'not-supported'], str], <kindgi.client._open.OpenEnum object at 0x1073beed0>]] (optional)

ConnectionAccount

Whose account a connection is at the app.

• id: str
• label: str

ConnectionApp

A workspace's registration of its own client at an app. Secrets are references, never values.

• app_id: uuid.UUID (appId on the wire)
• app: str
• label: str | None (optional)
• oauth2: kindgi.client.ConnectionOAuth2App | None (optional)
• github_app: kindgi.client.ConnectionGitHubApp | None (githubApp on the wire) (optional)
• projects: list[str] | None (optional)
• redirect_url: AnyUrl (redirectUrl on the wire)
• notices_url: AnyUrl (noticesUrl on the wire)
• created_at: AwareDatetime (createdAt on the wire)
• updated_at: AwareDatetime (updatedAt on the wire)
• removed_at: AwareDatetime | None (removedAt on the wire) (optional)

ConnectionAppPage

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

ConnectionAppRemoved

• connections_removed: int (connectionsRemoved on the wire)

ConnectionCandidate

A connection a choice in the project may name: the company's, or with owner=me, your own. Its state is working or needs-reconnecting: one that needs reconnecting may be chosen, and works again once it's reconnected. A project admin reads all of a company one; a project member, only connectionId and name. You read all of your own.

• connection_id: uuid.UUID (connectionId on the wire)
• name: str
• app: str | None (optional)
• account_label: str | None (accountLabel on the wire) (optional)
• state: Optional[Annotated[Union[Literal['working', 'needs-reconnecting', 'removing', 'removed'], str], <kindgi.client._open.OpenEnum object at 0x1073beed0>]] (optional)
• main: bool | None (optional)

ConnectionCandidatePage

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

ConnectionChoice

Which connection an agent or a flow uses for an app in a project, in one env: agentId or flowId, one of them. The company's, or a person's own (person), for their runs. With toolId, it's that tool's, which comes before the agent's or flow's. A choice is never changed: changing it removes it and makes a new one at the next version.

• choice_id: uuid.UUID (choiceId on the wire)
• project_id: uuid.UUID (projectId on the wire)
• env_name: str (envName on the wire)
• agent_id: str | None (agentId on the wire) (optional)
• flow_id: str | None (flowId on the wire) (optional)
• app: str
• tool_id: str | None (toolId on the wire) (optional)
• need: str | None (optional)
• connection_id: uuid.UUID (connectionId on the wire)
• connection_ids: list[uuid.UUID] | None (connectionIds on the wire) (optional)
• person: kindgi.client.ConnectionChoicePerson | None (optional)
• version: int
• created_at: AwareDatetime (createdAt on the wire)
• created_by: str (createdBy on the wire)
• removed_at: AwareDatetime | None (removedAt on the wire) (optional)
• removed_by: str | None (removedBy on the wire) (optional)

ConnectionChoiceDeleteResult

• deleted: bool

ConnectionChoiceNeed

One of a tool's connections, and whether a choice for it may be a set.

• tool_id: str (toolId on the wire)
• need: str
• app: str
• as_: Union[Literal['person', 'company'], str] (as on the wire)
• set: kindgi.client.ConnectionChoiceNeedSet

ConnectionChoiceNeedSet

Whether a choice for the tool's connection may be a set, and if not, why not.

• allowed: bool
• reason: Optional[Annotated[Union[Literal['changes', 'sensitive-data-egress', 'accounts-input'], str], <kindgi.client._open.OpenEnum object at 0x1073beed0>]] (optional)

ConnectionChoiceNeeds

• data: list[kindgi.client.ConnectionChoiceNeed]
• unread: list[str] | None (optional)

ConnectionChoicePage

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

ConnectionChoicePerson

The person whose own connection a choice names.

• user_id: str (userId on the wire)

ConnectionEntry

An app this server can connect to.

• id: str
• name: str
• owners: list[Annotated[Union[Literal['member', 'company'], str], <kindgi.client._open.OpenEnum object at 0x1073beed0>]]
• sign_in: kindgi.client.SignIn (signIn on the wire)
• permissions: dict[str, kindgi.client.ConnectionEntryPermission]
• removal: kindgi.client.Removal | None (optional)
• setup_guide: str (setupGuide on the wire)

ConnectionEntryList

• data: list[kindgi.client.ConnectionEntry]

ConnectionEntryPermission

• says: str
• changes: bool

ConnectionEntrySignInTenant

Present when the sign-in happens in a directory of the app's own (Microsoft's tenant, not a Kindgi workspace). A registration's oauth2.tenant names it; without default, each registration must give its own.

• default: str | None (optional)

ConnectionGitHubApp

• app_number: int (appNumber on the wire)
• slug: str
• client_id: str (clientId on the wire)
• client_secret: kindgi.client.ConnectionSecretRef (clientSecret on the wire)
• private_key: kindgi.client.ConnectionSecretRef (privateKey on the wire)
• webhook_secret: kindgi.client.ConnectionSecretRef (webhookSecret on the wire)

ConnectionNeed

• app: str
• permissions: list[kindgi.client.Permission]
• as_: Union[Literal['person', 'company'], str] (as on the wire)

ConnectionOAuth2App

• client_id: str (clientId on the wire)
• client_secret: kindgi.client.ConnectionSecretRef (clientSecret on the wire)
• tenant: str | None (optional)

ConnectionOwner

Who owns a connection: one member (kind: member, with their userId), or the company (kind: company, the workspace's own account).

• kind: Union[Literal['member', 'company'], str]
• user_id: str | None (userId on the wire) (optional)

ConnectionPage

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

ConnectionSecretRef

A secret by name in the deployment's secrets store, resolved at tenant scope. The registration keeps only this reference, never the value.

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

ConsoleLink

One of the deployment's own links, which the console shows on every page.

• label: str
• url: AnyUrl

Conversation

• id: uuid.UUID
• tenant_id: uuid.UUID (tenantId on the wire)
• agent_id: str (agentId on the wire)
• agent_version: str (agentVersion on the wire)
• title: str
• participant_id: str | None (participantId on the wire) (optional)
• project_id: uuid.UUID | None (projectId on the wire) (optional)
• opened_by: str | None (openedBy on the wire) (optional)
• scope: dict[str, Any]
• status: Union[Literal['open', 'closed'], str]
• opened_at: AwareDatetime (openedAt on the wire)
• closed_at: AwareDatetime | None (closedAt on the wire) (optional)
• unregistered_at: AwareDatetime | None (unregisteredAt on the wire) (optional)
• turn_count: int (turnCount on the wire)
• last_message_at: AwareDatetime | None (lastMessageAt on the wire) (optional)
• metadata: dict[str, Any] | None (optional)

ConversationCollectionPage

• data: list[kindgi.client.Conversation]
• next_cursor: str | None (nextCursor on the wire) (optional)
• has_more: bool (hasMore on the wire)
• opened_by: Optional[Annotated[Union[Literal['me'], str], <kindgi.client._open.OpenEnum object at 0x1073beed0>]] (openedBy on the wire) (optional)

ConversationMessage

• sequence: int
• role: Union[Literal['user', 'agent', 'tool', 'system'], str]
• content: Any
• files: list[kindgi.client.FileValue] | None (optional)
• tool_call: kindgi.client.ToolCall | None (toolCall on the wire) (optional)
• actor: str | None (optional)
• created_at: AwareDatetime (createdAt on the wire)

ConversationMessageCollectionPage

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

ConversationPolicy

• history_limit: int | None (historyLimit on the wire) (optional)
• hitl_after_turns: int | None (hitlAfterTurns on the wire) (optional)

ConversationStatus

• root: Literal['open', 'closed']

Corrected

What people said about this item on the replay itself, once they corrected it there.

• yes_weight: float (yesWeight on the wire)
• total_weight: float (totalWeight on the wire)

CorrectedAnswerItem

• key: str
• pointer: str | None (optional)
• rank: int | None (optional)
• verdict: Union[Literal['right', 'wrong'], str]

CorrectedAnswerItemInput

• key: str
• pointer: str | None (optional)
• rank: int | None (optional)
• verdict: Literal['right', 'wrong']

CorrectedComparisonCost

What the candidate's replays cost in model calls, as the runtime reported it. Absent from a summary when no case's replays reported a cost.

• candidate: float
• spread: float | None (optional)
• cases: int

CorrectedComparisonResult

A comparison's result (a corrections test run's): the summary and each case. TestRun.result stays an open object, since each kind has its own; the clients read it as this (TS comparisonOf(run), Python comparison_of(run)).

• summary: kindgi.client.CorrectedComparisonSummary
• per_case: list[kindgi.client.ComparisonCaseResult] (perCase on the wire)

CorrectedComparisonSummary

What a comparison concluded: the candidate beside the recorded runs, the case counts, and the metrics. What a release gate reads.

• test_run_id: str (testRunId on the wire)
• status: Literal['completed', 'partial', 'failed']
• completed_at: AwareDatetime (completedAt on the wire)
• test_set: kindgi.client.CorrectedComparisonSummaryTestSet (testSet on the wire)
• candidate: kindgi.client.ComparisonCandidateAgent | kindgi.client.ComparisonCandidateFlow
• baseline: kindgi.client.CorrectedComparisonSummaryBaselineRecorded | kindgi.client.CorrectedComparisonSummaryBaselineVersion
• scope: kindgi.client.CorrectedComparisonSummaryScope
• cases: int
• diverged: int
• refused_writes: int (refusedWrites on the wire)
• errors: int
• erased: int | None (optional)
• rescore_of: str | None (rescoreOf on the wire) (optional)
• not_rescored: int | None (notRescored on the wire) (optional)
• stopped: int
• reads: Literal['recorded', 'live']
• group_weights: Optional[Literal['as-recorded', 'experts-only']] (groupWeights on the wire) (optional)
• sample: kindgi.client.TestRunSample | None (optional)
• sampling: kindgi.client.Sampling
• repetitions: int
• metrics: kindgi.client.Metrics
• corrections: kindgi.client.Corrections | None (optional)
• cost_usd: kindgi.client.CorrectedComparisonCost | None (costUsd on the wire) (optional)
• unchecked: kindgi.client.CorrectedComparisonUnchecked | None (optional)

CorrectedComparisonSummaryBaselineRecorded

What the candidate was compared with: recorded (the test set's recorded runs, with the versions that served them), or another version.

• kind: Literal['recorded']
• versions: list[kindgi.client.Version]

CorrectedComparisonSummaryBaselineVersion

What the candidate was compared with: recorded (the test set's recorded runs, with the versions that served them), or another version.

• kind: Literal['version']
• agent_id: str (agentId on the wire)
• version: str
• via: Literal['explicit', 'pinned']
• pinned_scope: dict[str, Any] | None (pinnedScope on the wire) (optional)

CorrectedComparisonSummarySamplingModel

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

CorrectedComparisonSummaryScope

Where the test set's corrections came from.

• project_id: str | None (projectId on the wire) (optional)

CorrectedComparisonSummaryTestSet

• id: str
• version: str

CorrectedComparisonUnchecked

The cases whose expect couldn't be graded, so they add no check to passRate: when passRate has no value, this says why. Absent from a summary when every case's was graded, and from older servers.

• cases: int
• reasons: list[str]

CorrectedItem

The corrected item of a run's output.

• key: str
• pointer: str | None (optional)
• rank: int | None (optional)

CorrectedItemSummary

The corrections of one item of a case's output, summed up.

• key: str
• pointer: str | None (optional)
• rank: int | None (optional)
• yes: int
• no: int
• yes_weight: float (yesWeight on the wire)
• total_weight: float (totalWeight on the wire)
• expert: kindgi.client.Expert | None (optional)
• correction_ids: list[str] | None (correctionIds on the wire) (optional)
• reasons: list[kindgi.client.Reason]

CorrectedRunContext

What a corrected run needs besides its input to be replayed, captured when it was first corrected. For an agent turn: the conversation before it, what its retrievals returned, and the decision at its session approval gate. For a flow run: its tool calls with their results. For both: the env values its tools were sent.

• history: list[Any] | None (optional)
• history_truncated: bool | None (historyTruncated on the wire) (optional)
• retrieved: Any | None (optional)
• recalled: Any | None (optional)
• session_approval: kindgi.client.SessionApproval | None (sessionApproval on the wire) (optional)
• flow: kindgi.client.CorrectedRunContextFlow | None (optional)
• tool_env: dict[str, dict[str, str]] | None (toolEnv on the wire) (optional)
• replay_of: str | None (replayOf on the wire) (optional)

CorrectedRunContextFlow

For a flow run: what it did, kept at its first correction so it can be replayed. Every tool call it made with its result (at its tool nodes, in its agent steps' turns and in its sub-flows), at most 500, and its agent steps.

• calls: list[kindgi.client.Call]
• steps: list[kindgi.client.Step]
• truncated: bool | None (optional)

CorrectedRunCopy

The stored copy of a corrected run's input and output, taken when it was first corrected.

• run_id: str (runId on the wire)
• subject: kindgi.client.CorrectedSubject
• input: Any
• context: kindgi.client.CorrectedRunContext | None (optional)
• output: Any
• segments: list[kindgi.client.ScopeSegment] | None (optional)
• captured_at: AwareDatetime (capturedAt on the wire)

CorrectedSubject

What a corrected run ran: an agent at a version, or a flow at a version.

• kind: Union[Literal['agent', 'flow'], str]
• id: str
• version: str

CorrectedTestCase

One case of a corrections test set: a copy of a corrected run with its items' corrections summed up.

• case_id: str (caseId on the wire)
• run_id: str | None (runId on the wire) (optional)
• subject: kindgi.client.CorrectedSubject
• input: Any
• context: kindgi.client.CorrectedRunContext | None (optional)
• output: Any
• segments: list[kindgi.client.ScopeSegment] | None (optional)
• items: list[kindgi.client.CorrectedItemSummary]
• corrections: list[kindgi.client.CorrectedTestCaseCorrection] | None (optional)
• expect: kindgi.client.TestCaseExpect | None (optional)
• expert: Optional[Literal[True]] (optional)
• erased: Optional[Literal[True]] (optional)

CorrectedTestCaseCollectionPage

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

CorrectedTestCaseCorrection

• correction_id: str (correctionId on the wire)
• corrector_group_id: str | None (correctorGroupId on the wire) (optional)
• expert: Optional[Literal[True]] (optional)
• calls: list[kindgi.client.ExpectedCall]
• not_called: list[kindgi.client.NotCalledItem] (notCalled on the wire)

Correction

A person's correction of one run: whether its decisions (the tool calls) and its answer were right, and what was right instead. It says at least one of decisions, answer and items.

• id: str
• tenant_id: str (tenantId on the wire)
• project_id: str (projectId on the wire)
• run_id: str (runId on the wire)
• subject: kindgi.client.CorrectedSubject
• decisions: Optional[Annotated[Union[Literal['right', 'wrong'], str], <kindgi.client._open.OpenEnum object at 0x1073beed0>]] (optional)
• should_call: list[kindgi.client.ExpectedCall] | None (shouldCall on the wire) (optional)
• must_not_call: list[str] | None (mustNotCall on the wire) (optional)
• answer: Optional[Annotated[Union[Literal['right', 'wrong'], str], <kindgi.client._open.OpenEnum object at 0x1073beed0>]] (optional)
• should_say: str | None (shouldSay on the wire) (optional)
• why: str | None (optional)
• items: list[kindgi.client.CorrectedAnswerItem] | None (optional)
• corrector_group_id: str | None (correctorGroupId on the wire) (optional)
• expert: Optional[Literal[True]] (optional)
• made_by: kindgi.client.CorrectionMadeBy (madeBy on the wire)
• participant_id: str | None (participantId on the wire) (optional)
• status: Union[Literal['open', 'being-fixed', 'with-owner', 'fixed', 'wont-fix', 'removed'], str]
• sorted_to: Optional[Annotated[Union[Literal['improve', 'developer', 'owner'], str], <kindgi.client._open.OpenEnum object at 0x1073beed0>]] (sortedTo on the wire) (optional)
• sorted: kindgi.client.CorrectionSorted | None (optional)
• link: Optional[Annotated[kindgi.client.CorrectionLink1 | kindgi.client.CorrectionLink2 | kindgi.client.CorrectionLinkUnrecognized, <kindgi.client._open.OpenUnion object at 0x1081f3410>]] (optional)
• fixed_in: kindgi.client.CorrectionFixedIn | None (fixedIn on the wire) (optional)
• reopened_in: kindgi.client.CorrectionReopenedIn | None (reopenedIn on the wire) (optional)
• status_note: kindgi.client.CorrectionStatusNote | None (statusNote on the wire) (optional)
• created_at: AwareDatetime (createdAt on the wire)
• updated_at: AwareDatetime (updatedAt on the wire)
• unregistered_at: AwareDatetime | None (unregisteredAt on the wire) (optional)
• superseded_by: str | None (supersededBy on the wire) (optional)

CorrectionCollectionPage

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

CorrectionCounts

How many of a project's (or an agent's) live corrections are in each status.

• open: int
• being_fixed: int (beingFixed on the wire)
• with_owner: int (withOwner on the wire)
• fixed: int
• wont_fix: int (wontFix on the wire)
• removed: int

CorrectionDifference

• correction_id: str (correctionId on the wire)
• repetition: int
• differences: list[kindgi.client.CallDifferenceCount | kindgi.client.CallDifferenceMustNotCall | kindgi.client.CallDifferenceMissingField | kindgi.client.CallDifferenceFieldValue]

CorrectionFixedIn

• version: str | None (optional)
• how: Union[Literal['pin', 'latest', 'recorded-right'], str]
• by: kindgi.client.CorrectionMadeBy | None (optional)
• at: AwareDatetime

CorrectionLink1

• kind: Literal['improve-run', 'suggested-change']
• id: str

CorrectionLink2

• kind: Literal['pull-request']
• url: AnyUrl

CorrectionLinkUnrecognized

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

• kind: str

CorrectionMadeBy

Who asserted a correction: the authenticated caller, never a typed name.

• kind: Union[Literal['user', 'service'], str]
• id: str

CorrectionReopenedIn

The version whose test run got a fixed correction wrong again. It holds no words: a client builds the sentence from the project's and the person's current names.

• version: str
• how: Union[Literal['pin', 'went-back', 'unpin', 'latest'], str]
• by: kindgi.client.CorrectionMadeBy | None (optional)
• at: AwareDatetime

CorrectionSorted

• by: kindgi.client.By | kindgi.client.By1 | kindgi.client.CorrectionSortedByUnrecognized
• reason: str | None (optional)
• at: AwareDatetime

CorrectionSortedByUnrecognized

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

• kind: str

CorrectionStatusNote

• text: str
• by: kindgi.client.CorrectionMadeBy
• at: AwareDatetime

CorrectionWithCopies

A correction with the stored copies of what was corrected.

• id: str
• tenant_id: str (tenantId on the wire)
• project_id: str (projectId on the wire)
• run_id: str (runId on the wire)
• subject: kindgi.client.CorrectedSubject
• decisions: Optional[Annotated[Union[Literal['right', 'wrong'], str], <kindgi.client._open.OpenEnum object at 0x1073beed0>]] (optional)
• should_call: list[kindgi.client.ExpectedCall] | None (shouldCall on the wire) (optional)
• must_not_call: list[str] | None (mustNotCall on the wire) (optional)
• answer: Optional[Annotated[Union[Literal['right', 'wrong'], str], <kindgi.client._open.OpenEnum object at 0x1073beed0>]] (optional)
• should_say: str | None (shouldSay on the wire) (optional)
• why: str | None (optional)
• items: list[kindgi.client.CorrectedAnswerItem] | None (optional)
• corrector_group_id: str | None (correctorGroupId on the wire) (optional)
• expert: Optional[Literal[True]] (optional)
• made_by: kindgi.client.CorrectionMadeBy (madeBy on the wire)
• participant_id: str | None (participantId on the wire) (optional)
• status: Union[Literal['open', 'being-fixed', 'with-owner', 'fixed', 'wont-fix', 'removed'], str]
• sorted_to: Optional[Annotated[Union[Literal['improve', 'developer', 'owner'], str], <kindgi.client._open.OpenEnum object at 0x1073beed0>]] (sortedTo on the wire) (optional)
• sorted: kindgi.client.CorrectionSorted | None (optional)
• link: Optional[Annotated[kindgi.client.CorrectionLink1 | kindgi.client.CorrectionLink2 | kindgi.client.CorrectionLinkUnrecognized, <kindgi.client._open.OpenUnion object at 0x1081f3410>]] (optional)
• fixed_in: kindgi.client.CorrectionFixedIn | None (fixedIn on the wire) (optional)
• reopened_in: kindgi.client.CorrectionReopenedIn | None (reopenedIn on the wire) (optional)
• status_note: kindgi.client.CorrectionStatusNote | None (statusNote on the wire) (optional)
• created_at: AwareDatetime (createdAt on the wire)
• updated_at: AwareDatetime (updatedAt on the wire)
• unregistered_at: AwareDatetime | None (unregisteredAt on the wire) (optional)
• superseded_by: str | None (supersededBy on the wire) (optional)
• run: kindgi.client.CorrectedRunCopy

Corrections

Corrections graded across the cases: shown for a release gate, not enforced. Absent when the test set carries no corrections.

• checked: int
• passed: int
• results: list[kindgi.client.Result] | None (optional)

CorrectorGroup

• id: str
• tenant_id: str (tenantId on the wire)
• scope: kindgi.client.CorrectorGroupScopeTenant | kindgi.client.CorrectorGroupScopeProject | kindgi.client.CorrectorGroupScopeAgent | kindgi.client.CorrectorGroupScopeUnrecognized
• name: str
• weight: float
• description: str | None (optional)
• assertable_by: kindgi.client.CorrectorGroupAssertableByView | None (assertableBy on the wire) (optional)
• created_at: AwareDatetime (createdAt on the wire)
• updated_at: AwareDatetime (updatedAt on the wire)
• unregistered_at: AwareDatetime | None (unregisteredAt on the wire) (optional)

CorrectorGroupAssertableBy

Who may assert the group: every part that is set must hold. A group with one is expert: a correction recorded while it is carries expert, and a comparison weighted experts-only counts only those.

• min_reviewer_role: Optional[Literal['standard', 'senior', 'admin']] (minReviewerRole on the wire) (optional)
• principal_kinds: list[Literal['user', 'service']] | None (principalKinds on the wire) (optional)
• principal_ids: list[kindgi.client.PrincipalId] | None (principalIds on the wire) (optional)

CorrectorGroupAssertableByView

Who may assert the group, as the caller sees it: every part that is set must hold. principalIds is sent only to an admin on the group's scope; principalCount to everyone who reads it.

• min_reviewer_role: Optional[Annotated[Union[Literal['standard', 'senior', 'admin'], str], <kindgi.client._open.OpenEnum object at 0x1073beed0>]] (minReviewerRole on the wire) (optional)
• principal_kinds: list[Annotated[Union[Literal['user', 'service'], str], <kindgi.client._open.OpenEnum object at 0x1073beed0>]] | None (principalKinds on the wire) (optional)
• principal_ids: list[kindgi.client.PrincipalId] | None (principalIds on the wire) (optional)
• principal_count: int | None (principalCount on the wire) (optional)

CorrectorGroupCollectionPage

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

CorrectorGroupScopeAgent

Where a corrector group applies: the whole workspace, one project, or one agent in a project.

• kind: Literal['agent']
• project_id: str (projectId on the wire)
• agent_id: str (agentId on the wire)

CorrectorGroupScopeProject

Where a corrector group applies: the whole workspace, one project, or one agent in a project.

• kind: Literal['project']
• project_id: str (projectId on the wire)

CorrectorGroupScopeTenant

Where a corrector group applies: the whole workspace, one project, or one agent in a project.

• kind: Literal['tenant']

CorrectorGroupScopeUnrecognized

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

• kind: str

CostAggregateGroup

• key: dict[str, str | None]
• count: int
• total_usd: float (totalUsd on the wire)
• tokens: kindgi.client.CostTokenTotals

CostAggregateResult

• groups: list[kindgi.client.CostAggregateGroup]
• total_groups: int | None (totalGroups on the wire) (optional)
• truncated: bool | None (optional)
• total_usd: float (totalUsd on the wire)
• total_records: int (totalRecords on the wire)
• tokens: kindgi.client.CostTokenTotals
• time_range: kindgi.client.TimeRange (timeRange on the wire)
• group_by: list[Annotated[Union[Literal['agentId', 'runId', 'category', 'providerId', 'day', 'month', 'tenant', 'conversationId', 'model', 'servedModel', 'projectId', 'orgId', 'rootRunId', 'flowId'], str], <kindgi.client._open.OpenEnum object at 0x1073beed0>]] (groupBy on the wire)

CostRecord

• id: str
• tenant_id: uuid.UUID (tenantId on the wire)
• category: str
• provider_id: str | None (providerId on the wire) (optional)
• run_id: uuid.UUID | None (runId on the wire) (optional)
• agent_id: str | None (agentId on the wire) (optional)
• conversation_id: uuid.UUID | None (conversationId on the wire) (optional)
• quantity: float
• unit: str
• cost_usd: float | None (costUsd on the wire) (optional)
• occurred_at: AwareDatetime (occurredAt on the wire)
• metrics: dict[str, Any] | None (optional)
• attributes: dict[str, Any] | None (optional)
• call_id: str | None (callId on the wire) (optional)
• project_id: uuid.UUID | None (projectId on the wire) (optional)
• root_run_id: uuid.UUID | None (rootRunId on the wire) (optional)
• parent_run_id: uuid.UUID | None (parentRunId on the wire) (optional)
• agent_version: str | None (agentVersion on the wire) (optional)
• flow_id: str | None (flowId on the wire) (optional)
• node_id: str | None (nodeId on the wire) (optional)
• step: int | None (optional)
• purpose: str | None (optional)
• model: str | None (optional)
• served_model: str | None (servedModel on the wire) (optional)
• fallback: bool | None (optional)
• status: Optional[Annotated[Union[Literal['ok', 'failed'], str], <kindgi.client._open.OpenEnum object at 0x1073beed0>]] (optional)
• usage: kindgi.client.ModelCallTokens | None (optional)
• thinking: kindgi.client.ModelCallThinking | None (optional)
• duration_ms: int | None (durationMs on the wire) (optional)
• finish_reason: str | None (finishReason on the wire) (optional)
• provider_request_id: str | None (providerRequestId on the wire) (optional)
• attempts: int | None (optional)
• error: kindgi.client.ModelCallError | None (optional)
• raw_usage: kindgi.client.RawUsage | None (rawUsage on the wire) (optional)

CostRecordCollectionPage

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

CostTokenTotals

• prompt: int
• completion: int
• cache_read: int (cacheRead on the wire)
• cache_write: int (cacheWrite on the wire)
• reasoning: int

CostUsdItem

• root: float

CreateConnectRequestBody

• app: str
• app_id: uuid.UUID | None (appId on the wire) (optional)
• project_id: str | None (projectId on the wire) (optional)
• permissions: list[str]
• for_: Optional[Literal['me', 'company']] (for on the wire) (optional)
• label: str | None (optional)
• reconnects: uuid.UUID | None (optional)

CreateConnectionAppBody

Give oauth2 for an app that signs in with OAuth, githubApp for a GitHub App.

• app: str
• label: str | None (optional)
• oauth2: kindgi.client.ConnectionOAuth2App | None (optional)
• github_app: kindgi.client.ConnectionGitHubApp | None (githubApp on the wire) (optional)
• projects: list[str] | None (optional)

CreateCorrectionBody

At least one of decisions, answer and items. decisions: "wrong" needs an entry in shouldCall or mustNotCall; answer: "wrong" needs shouldSay or why.

• run_id: str (runId on the wire)
• decisions: Optional[Literal['right', 'wrong']] (optional)
• should_call: list[kindgi.client.ShouldCallItem] | None (shouldCall on the wire) (optional)
• must_not_call: list[kindgi.client.MustNotCallItem] | None (mustNotCall on the wire) (optional)
• answer: Optional[Literal['right', 'wrong']] (optional)
• should_say: str | None (shouldSay on the wire) (optional)
• why: str | None (optional)
• items: list[kindgi.client.CorrectedAnswerItemInput] | None (optional)
• corrector_group_id: str | None (correctorGroupId on the wire) (optional)
• participant_id: str | None (participantId on the wire) (optional)

CreateCorrectorGroupBody

• scope: kindgi.client.CorrectorGroupScopeTenant | kindgi.client.CorrectorGroupScopeProject | kindgi.client.CorrectorGroupScopeAgent | kindgi.client.CorrectorGroupScopeUnrecognized
• name: str
• weight: float
• description: str | None (optional)
• assertable_by: kindgi.client.CorrectorGroupAssertableBy | None (assertableBy on the wire) (optional)

CreateMemoryErasureBody

• root: kindgi.client.MemoryErasureFactSelector | kindgi.client.MemoryErasureSubjectSelector | kindgi.client.MemoryErasureConversationSelector

CreateResourceResult

Shared 201 response body for platform-hierarchy create endpoints — the freshly-assigned id of the created row.

• id: str

CreateServiceAccountBody

• name: str
• description: str | None (optional)
• grants: list[Annotated[kindgi.client.ServiceAccountGrantTenantAdmin | kindgi.client.ServiceAccountGrantTenantMember | kindgi.client.ServiceAccountGrantProjectBody, FieldInfo(annotation=NoneType, required=True, discriminator='kind')]] | None (optional)

CreateSuggestedChangeBody

A suggested change by hand: new settings values (values) or a new prompt template (template) for one block, in what the project runs (its pin, or Latest). The same change on the same version for the same project is one suggested change (answered with X-Suggested-Change-Deduped: true).

• agent_id: str (agentId on the wire)
• project_id: uuid.UUID (projectId on the wire)
• block: str
• values: dict[str, Any] | None (optional)
• template: str | None (optional)
• why: str
• fixes: list[str] | None (optional)

CreateSystemTenantBody

• name: str
• slug: str | None (optional)
• production_allowed: bool | None (productionAllowed on the wire) (optional)
• test: bool | None (optional)
• image_prefix: str | None (imagePrefix on the wire) (optional)
• first_admin: kindgi.client.FirstAdmin | None (firstAdmin on the wire) (optional)

CreateSystemTenantResult

• tenant: kindgi.client.SystemTenant
• first_admin: kindgi.client.FirstAdmin1 | None (firstAdmin on the wire) (optional)
• admin_key: kindgi.client.AdminKey | None (adminKey on the wire) (optional)

CreateUserBody

• display_name: str (displayName on the wire)
• primary_email: str | None (primaryEmail on the wire) (optional)
• send_invite: bool | None (sendInvite on the wire) (optional)

CreateWebhookEndpointBody

• url: AnyUrl
• events: list[Annotated[Union[Literal['run.finished', 'improve-run.finished', 'approval.requested'], str], <kindgi.client._open.OpenEnum object at 0x1073beed0>]]
• filter: kindgi.client.WebhookEndpointFilter | None (optional)
• secret_ref: kindgi.client.WebhookSecretRef (secretRef on the wire)
• description: str | None (optional)