API Reference

A complete index of every resource method, generated from the SDK. Each line shows the call signature; see the linked resource page for full descriptions.

Authentication

client.auth.create_key(*, name: str, scopes: Sequence[str], expires_in_days: int | None = None) -> ApiKeyCreateResponse
client.auth.list_keys(*, status: str | None = None, sort: str | None = None, limit: int | None = None) -> SyncPaginator[ApiKey]
client.auth.retrieve_key(key_id: str) -> ApiKey
client.auth.revoke_key(key_id: str) -> None
client.auth.rotate_key(key_id: str) -> ApiKeyRotateResponse

Apps

client.apps.add_member(resource_id: str, *, user_id: str, role: str) -> Permissions
client.apps.analytics(app_id: str, *, range: str | None = None) -> dict[str, Any]
client.apps.analytics_users(app_id: str, *, range: str | None = None, q: str | None = None, sort: str | None = None) -> SyncPaginator[AppUsageUser]
client.apps.build_logs(app_id: str, *, limit: int | None = None, level: str | None = None) -> dict[str, Any]
client.apps.build_status(app_id: str) -> dict[str, Any]
client.apps.create(*, name: str, description: str | None = None, display_name: str | None = None, source_volume_id: str | None = None, source_folder: str | None = None, github_repo_url: str | None = None, github_branch: str | None = None, github_ssh_key_id: str | None = None, github_subdirectory: str | None = None, instances: int | None = None, cpu: str | None = None, memory: str | None = None, disk: str | None = None, gpu: str | None = None, gpu_type: str | None = None, use_spot: bool | None = None, spot_fallback: bool | None = None, environment_id: str | None = None, environment_variables: Mapping[str, str] | None = None, addons: Sequence[str] | None = None, data_sources: Sequence[str] | None = None, ai_models: Sequence[str] | None = None, ml_models: Sequence[str] | None = None, workflows: Sequence[str] | None = None, feature_stores: Sequence[str] | None = None, agents: Sequence[str] | None = None, volumes: Sequence[str] | None = None, tags: Sequence[str] | None = None) -> App
client.apps.create_with_upload(file: str | Path | BinaryIO, *, name: str | None = None, description: str | None = None, framework: str | None = None, runtime: str | None = None, **kwargs) -> App
client.apps.delete(app_id: str) -> None
client.apps.delete_plan(app_id: str, plan_id: str) -> dict[str, Any]
client.apps.deploy(app_id: str, **kwargs) -> App
client.apps.deploy_upload(app_id: str, file: str | Path | BinaryIO, **kwargs) -> App
client.apps.get_user(app_id: str, user_id: str) -> AppUser
client.apps.list(*, status: str | None = None, environment_id: str | None = None, search: str | None = None, limit: int | None = None) -> SyncPaginator[App]
client.apps.list_users(app_id: str, *, status: str | None = None, q: str | None = None, sort: str | None = None) -> SyncPaginator[AppUser]
client.apps.logs(app_id: str, *, lines: int | None = None, since: str | None = None, container: str | None = None) -> Any
client.apps.metrics(app_id: str) -> dict[str, Any]
client.apps.paid_access(app_id: str) -> dict[str, Any]
client.apps.permissions(resource_id: str) -> Permissions
client.apps.rebuild(app_id: str, *, bundle_source_type: str | None = None, bundle_source: Mapping[str, Any] | None = None) -> App
client.apps.remove_member(resource_id: str, user_id: str) -> None
client.apps.remove_user(app_id: str, user_id: str) -> None
client.apps.reset_user_password(app_id: str, user_id: str) -> AppUser
client.apps.restart(app_id: str) -> App
client.apps.retrieve(app_id: str) -> App
client.apps.set_env(app_id: str, environment_variables: Mapping[str, str]) -> App
client.apps.set_plan(app_id: str, plan_id: str, **plan) -> dict[str, Any]
client.apps.set_visibility(resource_id: str, visibility: str) -> Permissions
client.apps.start(app_id: str) -> App
client.apps.status(app_id: str) -> AppStatus
client.apps.stop(app_id: str) -> App
client.apps.subscriptions(app_id: str, *, status: str | None = None, q: str | None = None, sort: str | None = None) -> SyncPaginator[AppSubscription]
client.apps.update(app_id: str, *, name: str | None = None, description: str | None = None, display_name: str | None = None, instances: int | None = None, cpu: str | None = None, memory: str | None = None, disk: str | None = None, use_spot: bool | None = None, spot_fallback: bool | None = None, environment_id: str | None = None, environment_variables: Mapping[str, str] | None = None, addons: Sequence[str] | None = None, data_sources: Sequence[str] | None = None, ai_models: Sequence[str] | None = None, ml_models: Sequence[str] | None = None, workflows: Sequence[str] | None = None, feature_stores: Sequence[str] | None = None, agents: Sequence[str] | None = None, volumes: Sequence[str] | None = None, tags: Sequence[str] | None = None, port: int | None = None) -> App
client.apps.update_auth(app_id: str, **settings) -> dict[str, Any]
client.apps.update_paid_access(app_id: str, *, stripe_secret_key: str | None = None, stripe_webhook_secret: str | None = None, enabled: bool | None = None, grace_days: int | None = None) -> dict[str, Any]
client.apps.update_user(app_id: str, user_id: str, *, active: bool | None = None, free_access: bool | None = None) -> AppUser

Add-ons

client.addons.add_member(resource_id: str, *, user_id: str, role: str) -> Permissions
client.addons.backup(addon_id: str) -> AddonBackup
client.addons.connect_app(addon_id: str, app_id: str) -> Addon
client.addons.create(*, label: str, type: str, cpu: str, memory: str, disk: str, description: str | None = None, version: str | None = None, gpu: str | None = None, gpu_type: str | None = None, deployment_mode: str | None = None, cluster_config: Mapping[str, Any] | None = None, backup_config: Mapping[str, Any] | None = None) -> Addon
client.addons.credentials(addon_id: str) -> AddonCredentials
client.addons.delete(addon_id: str) -> None
client.addons.disconnect_app(addon_id: str, app_id: str) -> dict[str, Any]
client.addons.list(*, search: str | None = None, type: str | None = None, status: str | None = None, limit: int | None = None) -> SyncPaginator[Addon]
client.addons.list_backups(addon_id: str) -> AddonBackups
client.addons.list_types() -> list[AddonType]
client.addons.logs(addon_id: str, *, lines: int | None = None, since: str | None = None, container: str | None = None) -> list[AddonLogEntry]
client.addons.metrics(addon_id: str) -> AddonMetrics
client.addons.permissions(resource_id: str) -> Permissions
client.addons.recover(addon_id: str) -> Addon
client.addons.remove_member(resource_id: str, user_id: str) -> None
client.addons.restart(addon_id: str) -> Addon
client.addons.restore(addon_id: str, backup_id: str) -> AddonRestore
client.addons.retrieve(addon_id: str) -> Addon
client.addons.schedule(addon_id: str) -> dict[str, Any]
client.addons.set_visibility(resource_id: str, visibility: str) -> Permissions
client.addons.sizing() -> list[AddonNodeSize]
client.addons.start(addon_id: str) -> Addon
client.addons.status(addon_id: str) -> dict[str, Any]
client.addons.stop(addon_id: str) -> Addon
client.addons.update(addon_id: str, *, label: str | None = None, description: str | None = None, cpu: str | None = None, memory: str | None = None, disk: str | None = None) -> Addon
client.addons.update_backup_config(addon_id: str, *, enabled: bool, schedule: str, retention: int) -> Addon
client.addons.update_schedule(addon_id: str, *, enabled: bool, timezone: str, start_time: str, stop_time: str, days_of_week: Sequence[int], skip_holidays: bool | None = None, holiday_calendar: str | None = None) -> dict[str, Any]

Data Sources

client.datasources.add_member(resource_id: str, *, user_id: str, role: str) -> Permissions
client.datasources.create(*, name: str, label: str, type: str, credentials: Mapping[str, Any], description: str | None = None, category: str | None = None, metadata: Mapping[str, Any] | None = None) -> DataSource
client.datasources.credentials(datasource_id: str) -> dict[str, Any]
client.datasources.delete(datasource_id: str) -> None
client.datasources.list(*, search: str | None = None, type: str | None = None, category: str | None = None, status: str | None = None, limit: int | None = None) -> SyncPaginator[DataSource]
client.datasources.list_objects(datasource_id: str, *, bucket: str | None = None, prefix: str | None = None) -> dict[str, Any]
client.datasources.metadata(datasource_id: str) -> dict[str, Any]
client.datasources.permissions(resource_id: str) -> Permissions
client.datasources.remove_member(resource_id: str, user_id: str) -> None
client.datasources.retrieve(datasource_id: str) -> DataSource
client.datasources.set_visibility(resource_id: str, visibility: str) -> Permissions
client.datasources.status(datasource_id: str) -> dict[str, Any]
client.datasources.table_columns(datasource_id: str, table: str, *, schema: str | None = None) -> dict[str, Any]
client.datasources.test_connection(datasource_id: str) -> dict[str, Any]
client.datasources.update(datasource_id: str, *, name: str | None = None, label: str | None = None, description: str | None = None, credentials: Mapping[str, Any] | None = None, metadata: Mapping[str, Any] | None = None) -> DataSource

Projects

client.projects.add_collaborator(project_id: str, *, email: str, role: str, user_id: str | None = None) -> AddedCollaborator
client.projects.archive(project_id: str) -> Project
client.projects.collaborator_removal_impact(project_id: str, user_id: str) -> dict[str, Any]
client.projects.counts(*, status: str | None = None, category: str | None = None, search: str | None = None) -> dict[str, Any]
client.projects.create(*, name: str, description: str, filesystem_type: str | None = None, github_config: Mapping[str, str] | None = None, tags: Sequence[str] | None = None) -> Project
client.projects.delete(project_id: str, *, volume: Literal['delete', 'keep']) -> None
client.projects.deletion_impact(project_id: str) -> dict[str, Any]
client.projects.list(*, search: str | None = None, status: str | None = None, category: str | None = None, tag: str | None = None, sort: str | None = None, limit: int | None = None) -> SyncPaginator[Project]
client.projects.list_activity(project_id: str, *, sort: str | None = None, limit: int | None = None) -> SyncPaginator[ProjectActivity]
client.projects.list_collaborators(project_id: str) -> list[ProjectCollaborator]
client.projects.list_volumes(project_id: str) -> list[Volume]
client.projects.list_workspaces(project_id: str, *, sort: str | None = None, limit: int | None = None) -> SyncPaginator[Workspace]
client.projects.remove_collaborator(project_id: str, user_id: str) -> None
client.projects.restore(project_id: str) -> Project
client.projects.retrieve(project_id: str) -> Project
client.projects.set_visibility(project_id: str, *, is_public: bool) -> Project
client.projects.stats(project_id: str) -> ProjectStats
client.projects.transfer_ownership(project_id: str, *, new_owner_id: str) -> Project
client.projects.update(project_id: str, *, name: str | None = None, description: str | None = None, icon: str | None = None, category: str | None = None, tags: Sequence[str] | None = None, readme: str | None = None) -> Project
client.projects.update_collaborator(project_id: str, user_id: str, *, role: str) -> ProjectCollaborator

Project Boards

client.project_boards.add_card(project_id: str, *, column_id: str, title: str, description: str | None = None) -> BoardCard
client.project_boards.add_column(project_id: str, *, name: str) -> BoardColumnEntry
client.project_boards.archive_card(card_id: str) -> BoardCard
client.project_boards.delete_column(project_id: str, column_id: str) -> BoardColumnRemoval
client.project_boards.delete_label(project_id: str, label_id: str) -> None
client.project_boards.list_archived_cards(project_id: str, *, search: str | None = None, limit: int | None = None) -> SyncPaginator[ArchivedCard]
client.project_boards.list_members(project_id: str) -> list[BoardMember]
client.project_boards.move_card(card_id: str, *, to_column_id: str, prev_card_id: str | None = None, next_card_id: str | None = None) -> BoardCard
client.project_boards.reorder_columns(project_id: str, *, column_ids: Sequence[str]) -> list[BoardColumnEntry]
client.project_boards.restore_card(card_id: str, *, to_column_id: str) -> BoardCard
client.project_boards.retrieve(project_id: str) -> Board
client.project_boards.update_card(card_id: str, *, title: str | None = None, description: str | None = None, label_ids: Sequence[str] | None = None, assignee_ids: Sequence[str] | None = None, due_date: datetime | str | None = None, clear_due_date: bool | None = None, due_complete: bool | None = None) -> BoardCard
client.project_boards.update_column(project_id: str, column_id: str, *, name: str) -> BoardColumnEntry
client.project_boards.upsert_label(project_id: str, *, name: str, color: str, label_id: str | None = None) -> BoardLabel

Jobs

client.jobs.cancel_execution(job_id: str, execution_id: str) -> JobExecution
client.jobs.create(*, project_id: str, name: str, command: str, workspace_volume_size: str, use_spot: bool | None = None, spot_fallback: bool | None = None, addons: Sequence[str], data_sources: Sequence[str], ai_models: Sequence[str], workflows: Sequence[str], ml_models: Sequence[str], feature_stores: Sequence[str], agents: Sequence[str], description: str | None = None, environment_id: str | None = None, environment_version: int | None = None, resources: Mapping[str, Any] | None = None, env_vars: Mapping[str, str] | None = None, schedule: Mapping[str, Any] | None = None, shared_volume_ids: Sequence[str] | None = None) -> Job
client.jobs.delete(job_id: str) -> None
client.jobs.execution_log_url(job_id: str, execution_id: str, *, download: bool | None = None) -> str
client.jobs.list(*, project_id: str | None = None, status: str | None = None, search: str | None = None, sort: str | None = None, limit: int | None = None) -> SyncPaginator[Job]
client.jobs.list_executions(job_id: str, *, limit: int | None = None) -> SyncPaginator[JobExecution]
client.jobs.pause(job_id: str) -> Job
client.jobs.resume(job_id: str) -> Job
client.jobs.retrieve(job_id: str) -> Job
client.jobs.retrieve_execution(job_id: str, execution_id: str) -> JobExecution
client.jobs.run(job_id: str) -> JobExecution
client.jobs.update(job_id: str, *, name: str | None = None, description: str | None = None, command: str | None = None, environment_id: str | None = None, environment_version: int | None = None, resources: Mapping[str, Any] | None = None, workspace_volume_size: str | None = None, use_spot: bool | None = None, spot_fallback: bool | None = None, env_vars: Mapping[str, str] | None = None, schedule: Mapping[str, Any] | None = None, addons: Sequence[str] | None = None, data_sources: Sequence[str] | None = None, ai_models: Sequence[str] | None = None, workflows: Sequence[str] | None = None, shared_volume_ids: Sequence[str] | None = None) -> None

Workspaces

client.workspaces.abort_sync(workspace_id: str, *, volume_id: str) -> dict[str, Any]
client.workspaces.add_port(workspace_id: str, port: int, *, label: str | None = None) -> dict[str, Any]
client.workspaces.create(*, name: str, description: str, environment_type: str, environment_id: str | None = None, environment_version: int | None = None, custom_resources: Mapping[str, Any] | None = None, workspace_volume_size: str | None = None, project_id: str | None = None, use_spot: bool | None = None, spot_fallback: bool | None = None, environment_variables: Mapping[str, str] | None = None, addons: Sequence[str] | None = None, data_sources: Sequence[str] | None = None, ai_gateways: Sequence[str] | None = None, workflows: Sequence[str] | None = None, skill_ids: Sequence[str] | None = None, shared_volume_ids: Sequence[str] | None = None, coding_assistants: Sequence[str] | None = None, code_session_enabled: bool | None = None, custom_port: int | None = None, proxy_headers: Sequence[Mapping[str, str]] | None = None, cluster: Mapping[str, Any] | None = None) -> Workspace
client.workspaces.delete(workspace_id: str) -> None
client.workspaces.deletion_impact(workspace_id: str) -> dict[str, Any]
client.workspaces.execute(workspace_id: str, command: str, *, cwd: str | None = None) -> dict[str, Any]
client.workspaces.list(*, search: str | None = None, status: str | None = None, project_id: str | None = None, sort: str | None = None, limit: int | None = None) -> SyncPaginator[Workspace]
client.workspaces.logs(workspace_id: str, *, type: str | None = None) -> list[WorkspaceLogEntry]
client.workspaces.metrics(workspace_id: str) -> WorkspaceMetrics
client.workspaces.minimum_size() -> dict[str, Any]
client.workspaces.planned_volumes(*, project_id: str, shared_volume_ids: Sequence[str] | None = None) -> dict[str, Any]
client.workspaces.remove_port(workspace_id: str, port: int) -> None
client.workspaces.resolve_sync_conflict(workspace_id: str, *, volume_id: str, path: str, take: str) -> dict[str, Any]
client.workspaces.restart(workspace_id: str) -> Workspace
client.workspaces.retrieve(workspace_id: str) -> Workspace
client.workspaces.start(workspace_id: str) -> Workspace
client.workspaces.status(workspace_id: str) -> WorkspaceStatus
client.workspaces.stop(workspace_id: str) -> Workspace
client.workspaces.sync(workspace_id: str) -> WorkspaceSync
client.workspaces.sync_conflicts(workspace_id: str) -> dict[str, Any]
client.workspaces.update(workspace_id: str, *, name: str | None = None, description: str | None = None, environment_variables: Mapping[str, str] | None = None, addons: Sequence[str] | None = None, data_sources: Sequence[str] | None = None, ai_gateways: Sequence[str] | None = None, workflows: Sequence[str] | None = None, shared_volume_ids: Sequence[str] | None = None) -> Workspace
client.workspaces.volumes(workspace_id: str, *, group: str, q: str | None = None, sort: str | None = None) -> SyncPaginator[WorkspaceMount]

Volumes

client.volumes.code_diff(volume_id: str, *, head: str, base: str | None = None, path: str | None = None) -> dict[str, Any]
client.volumes.code_history(volume_id: str, *, ref: str, path: str | None = None, count: int | None = None) -> dict[str, Any]
client.volumes.create(*, name: str, filesystem_type: str | None = None, repo_url: str | None = None, branch: str | None = None, ssh_key_id: str | None = None, scope: str | None = None, project_id: str | None = None, description: str | None = None) -> CreatedVolume
client.volumes.create_code_branch(volume_id: str, name: str, *, from_ref: str | None = None) -> dict[str, Any]
client.volumes.delete(volume_id: str) -> None
client.volumes.delete_code_file(volume_id: str, path: str, *, branch: str | None = None, message: str | None = None) -> dict[str, Any]
client.volumes.delete_data_file(volume_id: str, path: str, *, message: str | None = None) -> DataFileWrite
client.volumes.deletion_impact(volume_id: str) -> dict[str, Any]
client.volumes.download_data(volume_id: str, dest: str) -> int
client.volumes.list(*, scope: str | None = None, project_id: str | None = None, sort: str | None = None, limit: int | None = None) -> SyncPaginator[Volume]
client.volumes.list_available_shared(*, project_id: str | None = None, search: str | None = None, sort: str | None = None, limit: int | None = None) -> SyncPaginator[AvailableSharedVolume]
client.volumes.list_code_branches(volume_id: str) -> dict[str, Any]
client.volumes.list_code_files(volume_id: str, *, ref: str | None = None, path: str | None = None) -> dict[str, Any]
client.volumes.list_data_file_versions(volume_id: str, path: str) -> list[DataFileVersion]
client.volumes.list_data_files(volume_id: str) -> list[DataFile]
client.volumes.read_code_file(volume_id: str, path: str, *, ref: str) -> dict[str, Any]
client.volumes.read_data_file(volume_id: str, path: str, *, version: int | None = None) -> bytes
client.volumes.read_data_text(volume_id: str, path: str, *, version: int | None = None, encoding: str = "utf-8") -> str
client.volumes.retrieve(volume_id: str) -> Volume
client.volumes.upload_data(volume_id: str, src: str, *, message: str | None = None) -> int
client.volumes.write_code_file(volume_id: str, path: str, *, content: str, branch: str | None = None, message: str | None = None) -> dict[str, Any]
client.volumes.write_data_file(volume_id: str, path: str, data: str | bytes, *, message: str | None = None) -> DataFileWrite

Compute

client.compute.delete_pre_warmed(workload_type: str) -> None
client.compute.list_pre_warmed() -> dict[str, PreWarmedPool]
client.compute.set_pre_warmed(workload_type: str, *, enabled: bool, count: int, instance_category: str, instance_size: str) -> PreWarmedPool

Environments

client.environments.base_image_status() -> BaseImageStatuses
client.environments.create(*, name: str, description: str | None = None, cpu: float | None = None, memory_gb: float | None = None, storage_gb: float | None = None, gpu_count: int | None = None, gpu_type: str | None = None, is_public: bool | None = None, base_image: str | None = None, dockerfile: str | None = None) -> Environment
client.environments.delete(environment_id: str) -> None
client.environments.list(*, enabled_only: bool | None = None, include_usage: bool | None = None) -> SyncPaginator[Environment]
client.environments.rebuild(environment_id: str) -> EnvironmentRebuild
client.environments.retrieve(environment_id: str) -> Environment
client.environments.update(environment_id: str, *, name: str | None = None, description: str | None = None, cpu: float | None = None, memory_gb: float | None = None, storage_gb: float | None = None, gpu_count: int | None = None, gpu_type: str | None = None, is_public: bool | None = None, base_image: str | None = None, dockerfile: str | None = None, enabled: bool | None = None) -> Environment

Workflows

client.workflows.add_connection(workflow_id: str, *, source_node_id: str, target_node_id: str, source_port: str | None = None, target_port: str | None = None, feedback: bool | None = None, max_iterations: int | None = None) -> dict[str, Any]
client.workflows.add_member(resource_id: str, *, user_id: str, role: str) -> Permissions
client.workflows.add_node(workflow_id: str, *, node_id: str, label: str | None = None, version: str | None = None, config: Mapping[str, Any] | None = None, position: Mapping[str, Any] | None = None) -> dict[str, Any]
client.workflows.build(*, name: str, nodes: Sequence[Mapping[str, Any]], connections: Sequence[Mapping[str, Any]] | None = None, workflow_type: str | None = None, **extra) -> Workflow
client.workflows.create(*, name: str, description: str | None = None, status: str | None = None, workflow_type: str | None = None, tags: Sequence[str] | None = None, nodes: Sequence[Mapping[str, Any]] | None = None, connections: Sequence[Mapping[str, Any]] | None = None, settings: Mapping[str, Any] | None = None) -> Workflow
client.workflows.create_alert_rule(*, name: str, condition: str, channels: Sequence[Mapping[str, Any]], workflow_id: str | None = None, condition_config: Mapping[str, Any] | None = None, throttle: Mapping[str, Any] | None = None, is_enabled: bool | None = None, description: str | None = None) -> dict[str, Any]
client.workflows.create_from_template(template_id: str, *, name: str | None = None, description: str | None = None, tags: Sequence[str] | None = None) -> Workflow
client.workflows.create_version(workflow_id: str, *, version_tag: str, description: str | None = None) -> dict[str, Any]
client.workflows.delete(workflow_id: str) -> None
client.workflows.delete_alert_rule(rule_id: str) -> None
client.workflows.delete_connection(workflow_id: str, connection_id: str) -> None
client.workflows.delete_node(workflow_id: str, node_id: str) -> None
client.workflows.dependency_access(workflow_id: str, *, for_: str | None = None) -> dict[str, Any]
client.workflows.deploy(workflow_id: str, **kwargs) -> Workflow
client.workflows.deploy_version(workflow_id: str, version_id: str, **resources) -> Workflow
client.workflows.discover(**params) -> dict[str, Any]
client.workflows.duplicate(workflow_id: str) -> Workflow
client.workflows.emit_event(*, event_type: str, event_data: Mapping[str, Any] | None = None, source: str | None = None) -> dict[str, Any]
client.workflows.execute(workflow_id: str, *, definition: Mapping[str, Any] | None = None, trigger_inputs: Mapping[str, Any] | None = None) -> dict[str, Any]
client.workflows.export(workflow_id: str) -> dict[str, Any]
client.workflows.import_bundle(*, export_data: Mapping[str, Any], resolved_deps: Mapping[str, Any] | None = None) -> dict[str, Any]
client.workflows.layout(workflow_id: str) -> dict[str, Any]
client.workflows.lifecycle(workflow_id: str) -> dict[str, Any]
client.workflows.list(*, status: str | None = None, search: str | None = None, tag: str | None = None, limit: int | None = None) -> SyncPaginator[Workflow]
client.workflows.list_alert_rules(*, workflow_id: str | None = None, limit: int | None = None) -> SyncPaginator[WorkflowAlertRule]
client.workflows.list_alerts(*, workflow_id: str | None = None, rule_id: str | None = None, limit: int | None = None) -> SyncPaginator[WorkflowAlert]
client.workflows.list_nodes(workflow_id: str) -> dict[str, Any]
client.workflows.logs(workflow_id: str, *, lines: int | None = None, container: str | None = None) -> dict[str, Any]
client.workflows.metrics(workflow_id: str, *, window: str | None = None) -> dict[str, Any]
client.workflows.permissions(resource_id: str) -> Permissions
client.workflows.remove_member(resource_id: str, user_id: str) -> None
client.workflows.retrieve(workflow_id: str) -> Workflow
client.workflows.retrieve_version(workflow_id: str, version_id: str) -> dict[str, Any]
client.workflows.save_as_template(workflow_id: str) -> Workflow
client.workflows.set_visibility(resource_id: str, visibility: str) -> Permissions
client.workflows.start(workflow_id: str) -> Workflow
client.workflows.stats() -> WorkflowStats
client.workflows.status(workflow_id: str) -> dict[str, Any]
client.workflows.stop(workflow_id: str) -> Workflow
client.workflows.structure_check(workflow_id: str) -> dict[str, Any]
client.workflows.templates() -> list[Workflow]
client.workflows.undeploy(workflow_id: str) -> Workflow
client.workflows.update(workflow_id: str, *, name: str | None = None, description: str | None = None, status: str | None = None, tags: Sequence[str] | None = None, nodes: Sequence[Mapping[str, Any]] | None = None, connections: Sequence[Mapping[str, Any]] | None = None, config: Mapping[str, Any] | None = None, settings: Mapping[str, Any] | None = None, max_concurrent_runs: int | None = None) -> Workflow
client.workflows.update_alert_rule(rule_id: str, *, name: str | None = None, condition: str | None = None, channels: Sequence[Mapping[str, Any]] | None = None, workflow_id: str | None = None, condition_config: Mapping[str, Any] | None = None, throttle: Mapping[str, Any] | None = None, is_enabled: bool | None = None, description: str | None = None) -> dict[str, Any]
client.workflows.update_lifecycle(workflow_id: str, *, type: str, idle_timeout_minutes: int | None = None, schedule: Mapping[str, Any] | None = None) -> dict[str, Any]
client.workflows.update_node(workflow_id: str, node_id: str, *, config: Mapping[str, Any] | None = None, label: str | None = None) -> dict[str, Any]
client.workflows.update_node_input_mappings(workflow_id: str, node_id: str, *, mappings: Mapping[str, Any]) -> dict[str, Any]
client.workflows.update_node_passthrough_values(workflow_id: str, node_id: str, *, values: Mapping[str, Any]) -> dict[str, Any]
client.workflows.update_status(workflow_id: str, *, status: str) -> dict[str, Any]
client.workflows.validate(workflow_id: str) -> dict[str, Any]
client.workflows.versions(workflow_id: str) -> WorkflowVersionInfo

Executions

client.executions.cancel(execution_id: str) -> Execution
client.executions.discard_dead_letter(dead_letter_id: str, *, notes: str | None = None) -> DeadLetter
client.executions.list(*, workflow_id: str | None = None, status: str | None = None, since: str | None = None, until: str | None = None, trigger_type: str | None = None, limit: int | None = None) -> SyncPaginator[Execution]
client.executions.list_dead_letters(*, workflow_id: str | None = None, status: str | None = None) -> SyncPaginator[DeadLetter]
client.executions.logs(execution_id: str, *, level: str | None = None, limit: int | None = None) -> list[ExecutionLog]
client.executions.notify_input_request(execution_id: str, request_id: str) -> dict[str, Any]
client.executions.pending_inputs(execution_id: str) -> list[dict[str, Any]]
client.executions.progress(execution_id: str) -> ExecutionProgress
client.executions.resume(execution_id: str, *, trigger_data: Mapping[str, Any] | None = None) -> Execution
client.executions.retrieve(execution_id: str) -> Execution
client.executions.retrieve_dead_letter(dead_letter_id: str) -> DeadLetter
client.executions.retry_dead_letter(dead_letter_id: str) -> dict[str, Any]
client.executions.spans(execution_id: str, *, node_id: str | None = None) -> list[ExecutionSpan]
client.executions.stop(execution_id: str) -> dict[str, Any]
client.executions.submit_input(execution_id: str, *, request_id: str, data: Any) -> dict[str, Any]

Workflow Nodes

client.workflow_nodes.activate_tool(node_id: str, *, config: Mapping[str, Any] | None = None) -> dict[str, Any]
client.workflow_nodes.add_member(resource_id: str, *, user_id: str, role: str) -> Permissions
client.workflow_nodes.create(*, label: str, category: str, type: str, function_definition: Mapping[str, Any], description: str | None = None, is_active: bool | None = None, input_definition: Mapping[str, Any] | None = None, output_definition: Mapping[str, Any] | None = None, editor_config: Mapping[str, Any] | None = None, default_data: Mapping[str, Any] | None = None) -> WorkflowNode
client.workflow_nodes.datasource_fields(datasource_id: str) -> dict[str, Any]
client.workflow_nodes.deactivate_tool(node_id: str) -> dict[str, Any]
client.workflow_nodes.delete(node_id: str) -> None
client.workflow_nodes.duplicate(node_id: str) -> WorkflowNode
client.workflow_nodes.list(*, search: str | None = None, category: str | None = None, type: str | None = None, workflow_type: str | None = None, is_system: bool | None = None, limit: int | None = None) -> SyncPaginator[WorkflowNode]
client.workflow_nodes.permissions(resource_id: str) -> Permissions
client.workflow_nodes.remove_member(resource_id: str, user_id: str) -> None
client.workflow_nodes.retrieve(node_id: str) -> WorkflowNode
client.workflow_nodes.schema(node_id: str) -> dict[str, Any]
client.workflow_nodes.services_addons(*, type: str | None = None) -> ServiceAddonsResponse
client.workflow_nodes.services_datasources(*, type: str | None = None, category: str | None = None) -> ServiceDataSourcesResponse
client.workflow_nodes.services_models(*, provider: str | None = None, type: str | None = None) -> ServiceModelsResponse
client.workflow_nodes.set_tool_enabled(node_id: str, *, enabled: bool) -> dict[str, Any]
client.workflow_nodes.set_visibility(resource_id: str, visibility: str) -> Permissions
client.workflow_nodes.suggest_mappings(*, source_node_id: str, target_node_id: str, **params) -> dict[str, Any]
client.workflow_nodes.sync_from_s3() -> dict[str, Any]
client.workflow_nodes.update(node_id: str, *, label: str | None = None, category: str | None = None, type: str | None = None, description: str | None = None, is_active: bool | None = None, input_definition: Mapping[str, Any] | None = None, output_definition: Mapping[str, Any] | None = None, editor_config: Mapping[str, Any] | None = None, default_data: Mapping[str, Any] | None = None) -> WorkflowNode

AI Inference

client.ai.inference.cancel_generation(*, job_id: str) -> GenerationJob
client.ai.inference.chat_completion(*, model: str, messages: Sequence[dict[str, Any] | ChatMessage], stream: bool = False, max_tokens: int | None = None, temperature: float = 0.7, top_p: float = 1.0, stop: str | list[str] | None = None, **kwargs) -> ChatCompletion | Iterator[StreamChunk]
client.ai.inference.completion(*, model: str, prompt: str, stream: bool = False, max_tokens: int | None = None, temperature: float = 0.7, **kwargs) -> Completion | Iterator[StreamChunk]
client.ai.inference.count_tokens(*, model: str, prompt: str) -> dict[str, Any]
client.ai.inference.embedding(*, model: str, input: str | list[str], **kwargs) -> EmbeddingResponse
client.ai.inference.generate(*, model: str, prompt: str, type: str | None = None, **kwargs) -> dict[str, Any]
client.ai.inference.generation_status(*, job_id: str) -> GenerationJob
client.ai.inference.image_generation(*, model: str, prompt: str, n: int = 1, size: str = "1024x1024", quality: str = "standard", response_format: str = "url", **kwargs) -> ImageGenerationResponse
client.ai.inference.list_speech_voices() -> dict[str, Any]
client.ai.inference.moderation(*, model: str, input: str | list[str], **kwargs) -> ModerationResponse
client.ai.inference.music_generation(*, model: str, prompt: str, duration: int = 30, **kwargs) -> GenerationJob
client.ai.inference.rerank(*, model: str, query: str, documents: list[str | dict[str, Any]], top_n: int | None = None, return_documents: bool = True, **kwargs) -> RerankResponse
client.ai.inference.speech(*, model: str, input: str, voice: str = "alloy", response_format: str = "mp3", speed: float = 1.0, **kwargs) -> SpeechResponse
client.ai.inference.transcription(*, model: str, file: Any, filename: str = "audio.mp3", language: str | None = None, prompt: str | None = None, response_format: str = "json", temperature: float = 0.0, **kwargs) -> TranscriptionResponse
client.ai.inference.translation(*, model: str, file: Any, filename: str = "audio.mp3", **kwargs) -> TranscriptionResponse
client.ai.inference.video_generation(*, model: str, prompt: str, duration: int = 5, resolution: str = "1080p", **kwargs) -> GenerationJob

AI Models

client.ai.models.add_member(resource_id: str, *, user_id: str, role: str) -> Permissions
client.ai.models.clear_cache(model_id: str) -> None
client.ai.models.create(*, name: str, type: str, provider: str, vendor_model_id: str, model_type: str | None = None, description: str | None = None, capabilities: Sequence[str] | None = None, max_tokens: int | None = None, context_window: int | None = None, config: Mapping[str, Any] | None = None, **extra) -> AIModel
client.ai.models.delete(model_id: str) -> None
client.ai.models.deploy(model_id: str, *, instance_type: str | None = None, replicas: int | None = None, auto_shutdown_minutes: int | None = None, schedule_rules: Sequence[Mapping[str, Any]] | None = None, scaling_mode: ScalingMode | None = None, min_replicas: int | None = None, max_replicas: int | None = None, target_concurrency: int | None = None, env_vars: Mapping[str, str] | None = None, use_spot: bool | None = None, spot_fallback: bool | None = None, **extra) -> AIModel
client.ai.models.list(*, search: str | None = None, type: str | None = None, status: str | None = None, provider: str | None = None, model_type: str | None = None, limit: int | None = None) -> SyncPaginator[AIModel]
client.ai.models.list_certified(*, provider: str | None = None, model_type: str | None = None, capability: str | None = None) -> list[CertifiedModel]
client.ai.models.list_prebuilt(*, category: str | None = None, provider: str | None = None) -> list[PrebuiltTemplate]
client.ai.models.list_providers() -> list[ModelProvider]
client.ai.models.logs(model_id: str, *, lines: int | None = None, since: str | None = None, container: str | None = None) -> dict[str, Any]
client.ai.models.metrics(model_id: str) -> dict[str, Any]
client.ai.models.options(model_id: str) -> dict[str, Any]
client.ai.models.overview() -> AIModelOverview
client.ai.models.permissions(resource_id: str) -> Permissions
client.ai.models.remove_member(resource_id: str, user_id: str) -> None
client.ai.models.resize(model_id: str, *, cpu: str | None = None, memory: str | None = None, disk: str | None = None, gpu: int | None = None, use_spot: bool | None = None, spot_fallback: bool | None = None) -> AIModel
client.ai.models.retrieve(model_id: str) -> AIModel
client.ai.models.set_visibility(resource_id: str, visibility: str) -> Permissions
client.ai.models.start(model_id: str) -> AIModel
client.ai.models.status(model_id: str) -> AIModelStatus
client.ai.models.stop(model_id: str) -> AIModel
client.ai.models.update(model_id: str, *, name: str | None = None, type: str | None = None, provider: str | None = None, vendor_model_id: str | None = None, model_type: str | None = None, description: str | None = None, capabilities: Sequence[str] | None = None, max_tokens: int | None = None, context_window: int | None = None, config: Mapping[str, Any] | None = None, replicas: int | None = None, scheduling_mode: SchedulingMode | None = None, auto_shutdown_minutes: int | None = None, schedule_rules: Sequence[Mapping[str, Any]] | None = None, scaling_mode: ScalingMode | None = None, min_replicas: int | None = None, max_replicas: int | None = None, target_concurrency: int | None = None, **extra) -> AIModel

AI Provider Keys

client.ai.provider_keys.create(*, name: str, provider: str, api_key: str, description: str | None = None, provider_organization: str | None = None) -> ProviderKey
client.ai.provider_keys.delete(key_id: str) -> None
client.ai.provider_keys.list(*, provider: str | None = None, status: str | None = None, search: str | None = None, limit: int | None = None) -> SyncPaginator[ProviderKey]
client.ai.provider_keys.retrieve(key_id: str) -> ProviderKey
client.ai.provider_keys.test(key_id: str) -> ProviderKeyTestResult
client.ai.provider_keys.update(key_id: str, *, name: str | None = None, description: str | None = None, api_key: str | None = None, provider_organization: str | None = None) -> ProviderKey

AI Analytics

client.ai.analytics.performance(*, date_range: DateRange, model_id: str | None = None) -> list[ModelPerformance]
client.ai.analytics.providers(*, date_range: DateRange) -> list[ProviderStats]
client.ai.analytics.time_series(*, date_range: DateRange, granularity: Granularity, provider: str | None = None) -> list[TimeSeriesPoint]
client.ai.analytics.usage(*, date_range: DateRange, model_id: str | None = None) -> UsageStats

Guardrails

client.ai.guardrails.logs(model_id: str) -> SyncPaginator[GuardrailLog]
client.ai.guardrails.overview() -> GuardrailOverview
client.ai.guardrails.replace(model_id: str, *, enabled: bool, rules: Sequence[Mapping[str, Any]]) -> ModelGuardrails
client.ai.guardrails.retrieve(model_id: str) -> ModelGuardrails
client.ai.guardrails.set_enabled(model_id: str, enabled: bool) -> ModelGuardrails
client.ai.guardrails.statistics() -> GuardrailTotals
client.ai.guardrails.templates() -> list[GuardrailTemplate]
client.ai.guardrails.test(model_id: str, *, input: str, direction: str, rules: Sequence[Mapping[str, Any]]) -> GuardrailTestResult

Agents

client.agents.analytics(agent_id: str, *, days: int = 30) -> AgentAnalytics
client.agents.attach_skill(agent_id: str, *, skill_id: str, editable: bool | None = None, auto_connected: bool | None = None, connected_by: str | None = None) -> dict[str, Any]
client.agents.chat(agent_id: str, thread_id: str, message: str) -> Iterator[dict[str, Any]]
client.agents.config(agent_id: str) -> dict[str, Any]
client.agents.create(*, name: str, description: str | None = None, nodes: Sequence[Mapping[str, Any]] | None = None, connections: Sequence[Mapping[str, Any]] | None = None) -> Agent
client.agents.create_thread(agent_id: str, *, title: str | None = None) -> AgentThread
client.agents.delete(agent_id: str) -> None
client.agents.delete_thread(agent_id: str, thread_id: str) -> None
client.agents.demote(agent_id: str) -> Workflow
client.agents.detach_skill(agent_id: str, skill_id: str) -> dict[str, Any]
client.agents.get_template(key: str) -> dict[str, Any]
client.agents.list(*, status: str | None = None, search: str | None = None, limit: int | None = None) -> SyncPaginator[Agent]
client.agents.list_skills(agent_id: str) -> dict[str, Any]
client.agents.list_templates() -> list[dict[str, Any]]
client.agents.list_threads(agent_id: str) -> list[AgentThread]
client.agents.logs(agent_id: str, *, lines: int | None = None, container: str | None = None) -> dict[str, Any]
client.agents.name_available(name: str, *, ignore_agent_id: str | None = None) -> bool
client.agents.promote(workflow_id: str) -> Agent
client.agents.redeploy(agent_id: str) -> Agent
client.agents.remove_addon(agent_id: str, addon_id: str) -> Agent
client.agents.remove_tool_workflow(agent_id: str, workflow_id: str) -> Agent
client.agents.retrieve(agent_id: str) -> Agent
client.agents.start(agent_id: str) -> Agent
client.agents.status(agent_id: str) -> AgentStatus
client.agents.stop(agent_id: str) -> Agent
client.agents.update(agent_id: str, *, name: str | None = None, description: str | None = None, nodes: Sequence[Mapping[str, Any]] | None = None, connections: Sequence[Mapping[str, Any]] | None = None) -> dict[str, Any]
client.agents.update_context_policy(agent_id: str, *, kind: str, token_budget: int, keep_recent: int) -> dict[str, Any]
client.agents.update_model(agent_id: str, model_id: str, fallback_model_ids: list[str] | None = None) -> dict[str, Any]
client.agents.update_operating_prompt(agent_id: str, operating_prompt_id: str | None) -> dict[str, Any]
client.agents.update_personality(agent_id: str, personality: str) -> dict[str, Any]
client.agents.update_skill(agent_id: str, skill_id: str, *, editable: bool) -> dict[str, Any]

Agent Messages

client.agent_messages.delete(agent_id: str, message_id: str) -> None
client.agent_messages.list(*, agent_id: str | None = None, type: str | None = None, category: str | None = None, since: str | None = None, limit: int | None = None) -> SyncPaginator[AgentMessage]
client.agent_messages.mark_read(agent_id: str, message_id: str) -> dict[str, Any]
client.agent_messages.send(agent_id: str, *, content: str, to_agent_id: str | None = None, category: str | None = None, metadata: Mapping[str, Any] | None = None, expires_at: str | None = None) -> AgentMessage

Agent Router

client.agent_router.add_member(router_id: str, *, model_id: str, weight: float | None = None, priority: int | None = None, enabled: bool | None = None, capabilities: Sequence[str] | None = None) -> AgentRouter
client.agent_router.create(*, name: str, strategy: str, description: str | None = None, members: Sequence[Mapping[str, Any]] | None = None, fallback_behavior: str | None = None, sticky_routing: bool | None = None, health_check: Mapping[str, Any] | None = None, bandit_config: Mapping[str, Any] | None = None, canary_config: Mapping[str, Any] | None = None, semantic_config: Mapping[str, Any] | None = None, complexity_config: Mapping[str, Any] | None = None, content_type_config: Mapping[str, Any] | None = None, token_budget_config: Mapping[str, Any] | None = None, routellm_config: Mapping[str, Any] | None = None, custom_strategy: Mapping[str, Any] | None = None) -> AgentRouter
client.agent_router.decisions(router_id: str, *, limit: int | None = None) -> SyncPaginator[RouterDecision]
client.agent_router.delete(router_id: str) -> None
client.agent_router.feedback(router_id: str, *, decision_id: str, reward: float, label: str | None = None) -> RouterFeedbackResult
client.agent_router.list(*, limit: int | None = None) -> SyncPaginator[AgentRouter]
client.agent_router.remove_member(router_id: str, member_id: str) -> None
client.agent_router.retrieve(router_id: str) -> AgentRouter
client.agent_router.stats(router_id: str, *, period_hours: int = 24) -> RouterStats
client.agent_router.update(router_id: str, *, name: str | None = None, strategy: str | None = None, description: str | None = None, members: Sequence[Mapping[str, Any]] | None = None, fallback_behavior: str | None = None, sticky_routing: bool | None = None, health_check: Mapping[str, Any] | None = None, bandit_config: Mapping[str, Any] | None = None, canary_config: Mapping[str, Any] | None = None, semantic_config: Mapping[str, Any] | None = None, complexity_config: Mapping[str, Any] | None = None, content_type_config: Mapping[str, Any] | None = None, token_budget_config: Mapping[str, Any] | None = None, routellm_config: Mapping[str, Any] | None = None, custom_strategy: Mapping[str, Any] | None = None) -> AgentRouter

Agent Sessions

client.sessions.end(agent_id: str, session_id: str) -> AgentSession
client.sessions.list(agent_id: str, *, state: str | None = None, limit: int | None = None) -> SyncPaginator[AgentSession]
client.sessions.pause(agent_id: str, session_id: str) -> AgentSession
client.sessions.resume(agent_id: str, session_id: str) -> AgentSession
client.sessions.retrieve(agent_id: str, session_id: str) -> AgentSession
client.sessions.transfer(agent_id: str, session_id: str, target_agent_id: str) -> AgentSession
client.sessions.update_session_policy(agent_id: str, *, idle_timeout_seconds: int, max_session_duration_seconds: int, auto_archive_after_days: int, max_concurrent_sessions_per_user: int | None = None, allow_per_session_model_override: bool = False) -> dict[str, Any]
client.sessions.upsert_from_activity(agent_id: str, thread_id: str, *, transport: str = "text", model_override: str | None = None, streaming_session_id: str | None = None) -> AgentSession

Avatars

client.avatars.create(*, name: str, description: str | None = None, type: str | None = None, image_url: str | None = None, config: Mapping[str, Any] | None = None) -> Avatar
client.avatars.delete(avatar_id: str) -> None
client.avatars.list(*, name: str | None = None) -> SyncPaginator[Avatar]
client.avatars.preview(avatar_id: str, *, options: Mapping[str, Any] | None = None) -> dict[str, Any]
client.avatars.retrieve(avatar_id: str) -> Avatar
client.avatars.update(avatar_id: str, *, name: str | None = None, description: str | None = None, image_url: str | None = None, config: Mapping[str, Any] | None = None) -> Avatar
client.avatars.upload_source(avatar_id: str, file: str | Path | BinaryIO) -> dict[str, Any]

Code Sessions

client.code_sessions.create(*, project_name: str, project_description: str, project_id: str | None = None, workspace_id: str | None = None) -> CodeSession
client.code_sessions.delete(session_id: str) -> None
client.code_sessions.deploy(session_id: str) -> App
client.code_sessions.output(session_id: str, **params) -> CodeSessionOutput
client.code_sessions.retrieve(session_id: str) -> CodeSession
client.code_sessions.send_input(session_id: str, *, text: str) -> CodeSession
client.code_sessions.start_login(session_id: str) -> dict[str, Any]
client.code_sessions.status(session_id: str) -> dict[str, Any]
client.code_sessions.submit_login_code(session_id: str, *, code: str) -> CodeSession

Memory

client.memory.add_link(memory_id: str, *, target_id: str, relation: str, weight: float | None = None) -> MemoryLink
client.memory.add_member(resource_id: str, *, user_id: str, role: str) -> Permissions
client.memory.assess(memory_id: str) -> dict[str, Any]
client.memory.consolidate(*, config: Mapping[str, Any] | None = None, dry_run: bool | None = None) -> dict[str, Any]
client.memory.create(*, kind: str, content: str, summary: str | None = None, tags: Sequence[str] | None = None, category: str | None = None, source: str | None = None, event_time: str | None = None, valid_from: str | None = None, valid_until: str | None = None, source_thread_id: str | None = None, source_message_id: str | None = None, source_tool_name: str | None = None, importance: float | None = None, decay_half_life_days: float | None = None, confidence: float | None = None, links: Sequence[Mapping[str, Any]] | None = None, linked_ids: Sequence[str] | None = None) -> Memory
client.memory.delete(memory_id: str) -> None
client.memory.delete_link(memory_id: str, target_id: str) -> None
client.memory.demote(memory_id: str) -> Memory
client.memory.export(**params) -> dict[str, Any]
client.memory.import_memories(*, memories: Sequence[Mapping[str, Any]]) -> dict[str, Any]
client.memory.ingest(*, content: str, kind: str, tags: Sequence[str] | None = None, linked_ids: Sequence[str] | None = None, model: str | None = None, candidate_k: int | None = None) -> dict[str, Any]
client.memory.invalidate(memory_id: str, *, superseded_by: str | None = None) -> Memory
client.memory.linked_to(memory_id: str, **params) -> list[Memory]
client.memory.list(*, kind: str | None = None, tags: list[str] | None = None, search: str | None = None, linked_ids: Sequence[str] | None = None, as_of: str | None = None, limit: int | None = None) -> SyncPaginator[Memory]
client.memory.permissions(resource_id: str) -> Permissions
client.memory.promote(memory_id: str) -> Memory
client.memory.record_access(memory_id: str) -> dict[str, Any]
client.memory.remove_member(resource_id: str, user_id: str) -> None
client.memory.restore_version(memory_id: str, version: int) -> Memory
client.memory.retrieve(memory_id: str) -> Memory
client.memory.retrieve_version(memory_id: str, version: int) -> MemoryVersion
client.memory.search(*, query: str, k: int | None = None, kind: str | None = None, tags: Sequence[str] | None = None, linked_ids: Sequence[str] | None = None, rrf_k: int | None = None, weights: Mapping[str, Any] | None = None, decay_half_life_days_override: float | None = None, as_of: str | None = None, include_invalidated: bool | None = None, rerank: bool | None = None, rerank_model: str | None = None) -> dict[str, Any]
client.memory.set_visibility(resource_id: str, visibility: str) -> Permissions
client.memory.update(memory_id: str, *, kind: str | None = None, content: str | None = None, summary: str | None = None, tags: Sequence[str] | None = None, category: str | None = None, event_time: str | None = None, valid_from: str | None = None, valid_until: str | None = None, source_thread_id: str | None = None, source_message_id: str | None = None, source_tool_name: str | None = None, importance: float | None = None, decay_half_life_days: float | None = None, confidence: float | None = None, links: Sequence[Mapping[str, Any]] | None = None, linked_ids: Sequence[str] | None = None, change_note: str | None = None) -> Memory
client.memory.versions(memory_id: str) -> list[MemoryVersion]

Rules

client.rules.add_member(resource_id: str, *, user_id: str, role: str) -> Permissions
client.rules.applicable(*, user_turn: str | None = None, tool_name: str | None = None, linked_ids: Sequence[str] | None = None) -> dict[str, Any]
client.rules.assess(rule_id: str) -> dict[str, Any]
client.rules.check(tool_name: str, *, args: Mapping[str, Any] | None = None, user_turn: str | None = None, linked_ids: Sequence[str] | None = None) -> dict[str, Any]
client.rules.create(*, description: str, content: str, category: str, severity: str | None = None, hierarchy_scope: str | None = None, enforcement_mode: str | None = None, triggers: Mapping[str, Any] | None = None, tags: Sequence[str] | None = None, enabled: bool | None = None, source: str | None = None, linked_ids: Sequence[str] | None = None) -> Rule
client.rules.delete(rule_id: str) -> None
client.rules.export(**params) -> dict[str, Any]
client.rules.import_rules(*, rules: Sequence[Mapping[str, Any]] | None = None, github_url: str | None = None) -> dict[str, Any]
client.rules.list(*, category: str | None = None, severity: str | None = None, hierarchy_scope: str | None = None, enabled: bool | None = None, tags: list[str] | None = None, search: str | None = None, linked_ids: Sequence[str] | None = None, limit: int | None = None) -> SyncPaginator[Rule]
client.rules.list_violations(rule_id: str, *, limit: int | None = None) -> SyncPaginator[RuleViolation]
client.rules.permissions(resource_id: str) -> Permissions
client.rules.record_violation(rule_id: str, *, attempted_action: str, detected_by: str | None = None, agent_id: str | None = None, thread_id: str | None = None, run_id: str | None = None, evidence: Mapping[str, Any] | None = None) -> RuleViolation
client.rules.remove_member(resource_id: str, user_id: str) -> None
client.rules.restore_version(rule_id: str, version: int) -> Rule
client.rules.retrieve(rule_id: str) -> Rule
client.rules.retrieve_version(rule_id: str, version: int) -> RuleVersion
client.rules.set_visibility(resource_id: str, visibility: str) -> Permissions
client.rules.update(rule_id: str, *, description: str | None = None, content: str | None = None, category: str | None = None, severity: str | None = None, hierarchy_scope: str | None = None, enforcement_mode: str | None = None, triggers: Mapping[str, Any] | None = None, tags: Sequence[str] | None = None, enabled: bool | None = None, linked_ids: Sequence[str] | None = None, change_note: str | None = None) -> Rule
client.rules.versions(rule_id: str) -> list[RuleVersion]
client.rules.violations_aggregate(**params) -> dict[str, Any]

Tasks

client.tasks.add_member(resource_id: str, *, user_id: str, role: str) -> Permissions
client.tasks.cancel(task_id: str, *, reason: str | None = None) -> Task
client.tasks.claim(task_id: str, *, claimant_id: str) -> Task
client.tasks.complete(task_id: str, *, notes: str | None = None, execution_id: str | None = None) -> Task
client.tasks.create(*, description: str, subject_ref: Mapping[str, Any] | None = None, due_at: str | None = None, notes: str | None = None, recurrence: Mapping[str, Any] | None = None, tags: Sequence[str] | None = None, trigger_type: str | None = None, linked_ids: Sequence[str] | None = None, created_by_agent: str | None = None, assigned_to_agent: str | None = None, shared_with: Sequence[str] | None = None, is_public: bool | None = None) -> Task
client.tasks.delete(task_id: str) -> None
client.tasks.end_recurrence(task_id: str) -> Task
client.tasks.list(*, kind: str | None = None, status: str | None = None, include_completed: bool | None = None, search_text: str | None = None, tags: Sequence[str] | None = None, trigger_type: str | None = None, due_only: bool | None = None, linked_ids: Sequence[str] | None = None, limit: int | None = None) -> SyncPaginator[Task]
client.tasks.permissions(resource_id: str) -> Permissions
client.tasks.remove_member(resource_id: str, user_id: str) -> None
client.tasks.retrieve(task_id: str) -> Task
client.tasks.set_visibility(resource_id: str, visibility: str) -> Permissions
client.tasks.skip_next(task_id: str) -> Task
client.tasks.update(task_id: str, *, description: str | None = None, subject_ref: Mapping[str, Any] | None = None, due_at: str | None = None, notes: str | None = None, recurrence: Mapping[str, Any] | None = None, tags: Sequence[str] | None = None, trigger_type: str | None = None, assigned_to_agent: str | None = None, linked_ids: Sequence[str] | None = None, clear_due_at: bool | None = None, clear_assigned_to_agent: bool | None = None, clear_subject_ref: bool | None = None) -> Task

Prompts

client.prompts.create(*, name: <class 'str'>, content: <class 'str'>, type: <class 'str'> = "system-prompt", description: str | None = None, variables: collections.abc.Sequence[collections.abc.Mapping[str, Any]] | None = None, tags: collections.abc.Sequence[str] | None = None, source: str | None = None, files: collections.abc.Sequence[collections.abc.Mapping[str, Any]] | None = None, github_url: str | None = None, linked_ids: collections.abc.Sequence[str] | None = None) -> <class 'Prompt'>
client.prompts.delete(prompt_id: <class 'str'>)
client.prompts.duplicate(prompt_id: <class 'str'>) -> dict[str, Any]
client.prompts.list(*, type: str | None = None, search: str | None = None, tags: str | None = None, limit: int | None = None) -> SyncPaginator[Prompt]
client.prompts.list_versions(prompt_id: <class 'str'>) -> list[PromptVersion]
client.prompts.record_usage(prompt_id: <class 'str'>) -> <class 'int'>
client.prompts.render(prompt_id: <class 'str'>, variables: collections.abc.Mapping[str, str]) -> <class 'PromptRenderResult'>
client.prompts.restore_version(prompt_id: <class 'str'>, version_number: <class 'int'>) -> <class 'Prompt'>
client.prompts.retrieve(prompt_id: <class 'str'>) -> <class 'Prompt'>
client.prompts.search(*, q: <class 'str'>, type: str | None = None, tags: str | None = None, limit: int | None = None) -> dict[str, Any]
client.prompts.update(prompt_id: <class 'str'>, *, name: str | None = None, description: str | None = None, content: str | None = None, variables: collections.abc.Sequence[collections.abc.Mapping[str, Any]] | None = None, tags: collections.abc.Sequence[str] | None = None, linked_ids: collections.abc.Sequence[str] | None = None, change_note: str | None = None) -> dict[str, Any]

Skills

client.skills.assess(skill_id: <class 'str'>) -> dict[str, Any]
client.skills.create(*, name: <class 'str'>, content: <class 'str'>, description: str | None = None, variables: collections.abc.Sequence[collections.abc.Mapping[str, Any]] | None = None, tags: collections.abc.Sequence[str] | None = None, category: str | None = None, source: str | None = None, files: collections.abc.Sequence[collections.abc.Mapping[str, Any]] | None = None, github_url: str | None = None, mcp_tools: collections.abc.Sequence[str] | None = None, linked_ids: collections.abc.Sequence[str] | None = None) -> <class 'Skill'>
client.skills.delete(skill_id: <class 'str'>)
client.skills.duplicate(skill_id: <class 'str'>) -> dict[str, Any]
client.skills.get_file(skill_id: <class 'str'>, path: <class 'str'>) -> dict[str, Any]
client.skills.import_from_github(github_url: <class 'str'>) -> dict[str, Any]
client.skills.list(*, category: str | None = None, search: str | None = None, tags: str | None = None, limit: int | None = None) -> SyncPaginator[Skill]
client.skills.list_files(skill_id: <class 'str'>) -> dict[str, Any]
client.skills.list_versions(skill_id: <class 'str'>) -> list[SkillVersion]
client.skills.record_usage(skill_id: <class 'str'>) -> <class 'int'>
client.skills.render(skill_id: <class 'str'>, variables: collections.abc.Mapping[str, str]) -> <class 'SkillRenderResult'>
client.skills.restore_version(skill_id: <class 'str'>, version_number: <class 'int'>) -> <class 'Skill'>
client.skills.retrieve(skill_id: <class 'str'>) -> <class 'Skill'>
client.skills.search(*, user_turn: <class 'str'>, limit: int | None = None, tags: collections.abc.Sequence[str] | None = None, linked_ids: collections.abc.Sequence[str] | None = None) -> dict[str, Any]
client.skills.update(skill_id: <class 'str'>, *, name: str | None = None, description: str | None = None, content: str | None = None, variables: collections.abc.Sequence[collections.abc.Mapping[str, Any]] | None = None, tags: collections.abc.Sequence[str] | None = None, category: str | None = None, linked_ids: collections.abc.Sequence[str] | None = None, change_note: str | None = None, files: collections.abc.Sequence[collections.abc.Mapping[str, Any]] | None = None, mcp_tools: collections.abc.Sequence[str] | None = None) -> dict[str, Any]

Artifacts

client.artifacts.add_member(resource_id: str, *, user_id: str, role: str) -> Permissions
client.artifacts.create(*, title: str, artifact_type: str, content_type: str, content: str, summary: str | None = None, tags: Sequence[str] | None = None) -> Artifact
client.artifacts.delete(artifact_id: str) -> None
client.artifacts.download_url(artifact_id: str, *, ttl_seconds: int | None = None) -> ArtifactDownloadUrl
client.artifacts.list(*, search: str | None = None, artifact_type: str | None = None, tags: list[str] | None = None, producer_agent_id: str | None = None, producer_skill_id: str | None = None, limit: int | None = None) -> SyncPaginator[Artifact]
client.artifacts.list_versions(artifact_id: str) -> list[ArtifactVersion]
client.artifacts.permissions(resource_id: str) -> Permissions
client.artifacts.refresh_size(artifact_id: str) -> Artifact
client.artifacts.remove_member(resource_id: str, user_id: str) -> None
client.artifacts.restore_version(artifact_id: str, version_number: int) -> Artifact
client.artifacts.retrieve(artifact_id: str) -> Artifact
client.artifacts.set_visibility(resource_id: str, visibility: str) -> Permissions
client.artifacts.update(artifact_id: str, *, title: str | None = None, summary: str | None = None, tags: Sequence[str] | None = None) -> Artifact

Knowledge Bases

client.knowledge.add_document(knowledge_base_id: str, *, filename: str | None = None, content: str | None = None, file: str | Path | BinaryIO | None = None, content_type: str | None = None) -> KnowledgeDocument
client.knowledge.add_member(resource_id: str, *, user_id: str, role: str) -> Permissions
client.knowledge.agent_catalog(agent_id: str) -> dict[str, Any]
client.knowledge.agent_outline(agent_id: str, document_id: str) -> dict[str, Any]
client.knowledge.agent_search(agent_id: str, q: str) -> dict[str, Any]
client.knowledge.agent_section(agent_id: str, document_id: str, section_id: str) -> dict[str, Any]
client.knowledge.create(*, name: str, index_model_id: str, description: str | None = None) -> KnowledgeBase
client.knowledge.delete(knowledge_base_id: str) -> None
client.knowledge.import_artifacts(knowledge_base_id: str, *, artifact_ids: Sequence[str]) -> list[KnowledgeDocument]
client.knowledge.list(*, limit: int | None = None) -> SyncPaginator[KnowledgeBase]
client.knowledge.permissions(resource_id: str) -> Permissions
client.knowledge.reindex_document(knowledge_base_id: str, document_id: str) -> KnowledgeDocument
client.knowledge.remove_document(knowledge_base_id: str, document_id: str) -> None
client.knowledge.remove_member(resource_id: str, user_id: str) -> None
client.knowledge.retrieve(knowledge_base_id: str) -> KnowledgeBase
client.knowledge.set_visibility(resource_id: str, visibility: str) -> Permissions
client.knowledge.update(knowledge_base_id: str, *, name: str | None = None, description: str | None = None, index_model_id: str | None = None) -> KnowledgeBase
client.knowledge.update_agent_knowledge_bases(agent_id: str, *, knowledge_base_ids: Sequence[str]) -> dict[str, Any]

Preferences

client.preferences.add_member(resource_id: str, *, user_id: str, role: str) -> Permissions
client.preferences.by_key(key: str) -> Preference
client.preferences.create(*, key: str, value: Any, category: str | None = None, preference_source: str | None = None, confidence: float | None = None, evidence: str | None = None, tags: Sequence[str] | None = None, linked_ids: Sequence[str] | None = None) -> Preference
client.preferences.delete(preference_id: str) -> None
client.preferences.forget(key: str) -> dict[str, Any]
client.preferences.list(*, search: str | None = None, category: str | None = None, preference_source: str | None = None, tags: list[str] | None = None, include_superseded: bool | None = None, limit: int | None = None) -> SyncPaginator[Preference]
client.preferences.permissions(resource_id: str) -> Permissions
client.preferences.remove_member(resource_id: str, user_id: str) -> None
client.preferences.retrieve(preference_id: str) -> Preference
client.preferences.search(*, user_turn: str, category: str | None = None, limit: int | None = None, tags: str | None = None, linked_ids: Sequence[str] | None = None) -> dict[str, Any]
client.preferences.set(key: str, value: Any, *, category: str | None = None, preference_source: str | None = None, confidence: float | None = None, evidence: str | None = None, tags: Sequence[str] | None = None, linked_ids: Sequence[str] | None = None) -> Preference
client.preferences.set_visibility(resource_id: str, visibility: str) -> Permissions
client.preferences.update(preference_id: str, *, value: Any = None, category: str | None = None, preference_source: str | None = None, confidence: float | None = None, evidence: str | None = None, tags: Sequence[str] | None = None, linked_ids: Sequence[str] | None = None) -> Preference

Pools

client.pools.add_member(resource_id: str, *, user_id: str, role: str) -> Permissions
client.pools.create(*, name: str, description: str | None = None, scope: str | None = None) -> Pool
client.pools.delete(pool_id: str) -> None
client.pools.list(*, scope: str | None = None, counts: bool | None = None) -> SyncPaginator[Pool]
client.pools.permissions(resource_id: str) -> Permissions
client.pools.remove_member(resource_id: str, user_id: str) -> None
client.pools.retrieve(pool_id: str) -> Pool
client.pools.set_visibility(resource_id: str, visibility: str) -> Permissions
client.pools.update(pool_id: str, *, name: str | None = None, description: str | None = None) -> Pool

Imprints

client.imprints.add_item(imprint_id: str, *, resource_type: str, resource_id: str) -> PoolItem
client.imprints.add_member(resource_id: str, *, user_id: str, role: str) -> Permissions
client.imprints.create(*, name: str, description: str | None = None) -> Pool
client.imprints.delete(imprint_id: str) -> None
client.imprints.install(agent_id: str, imprint_id: str) -> Pool
client.imprints.list() -> SyncPaginator[Pool]
client.imprints.permissions(resource_id: str) -> Permissions
client.imprints.remove_item(imprint_id: str, *, resource_type: str, resource_id: str) -> None
client.imprints.remove_member(resource_id: str, user_id: str) -> None
client.imprints.retrieve(imprint_id: str) -> Pool
client.imprints.set_visibility(resource_id: str, visibility: str) -> Permissions
client.imprints.uninstall(agent_id: str, imprint_id: str) -> None

STAN

client.stan.cancel_run(run_id: str) -> dict[str, Any]
client.stan.cancel_session(session_id: str) -> dict[str, Any]
client.stan.create_session(*, model_id: str, active_workflow_id: str | None = None, active_workflow_name: str | None = None) -> dict[str, Any]
client.stan.end_session(session_id: str) -> None
client.stan.history(*, session_id: str | None = None, turns: int | None = None) -> dict[str, Any]
client.stan.list_checkpoints(session_id: str) -> dict[str, Any]
client.stan.list_tool_executions(*, run_id: str | None = None, limit: int | None = None) -> SyncPaginator[StanToolExecution]
client.stan.retrieve_run(run_id: str) -> dict[str, Any]
client.stan.retrieve_session(session_id: str) -> dict[str, Any]
client.stan.revert(session_id: str, *, resource_ids: Sequence[str]) -> dict[str, Any]
client.stan.revert_plan(session_id: str) -> dict[str, Any]
client.stan.send_message(session_id: str, *, message: str, attachments: Sequence[str | os.PathLike[str]] | None = None) -> dict[str, Any]
client.stan.submit_credentials(run_id: str, *, values: Mapping[str, str]) -> dict[str, Any]

STAN Settings

client.stan_settings.compact() -> dict[str, Any]
client.stan_settings.context() -> dict[str, Any]
client.stan_settings.list_conversations(*, limit: int | None = None) -> SyncPaginator[StanConversation]
client.stan_settings.list_skills() -> dict[str, Any]
client.stan_settings.message(*, message: str, source: str | None = None) -> dict[str, Any]
client.stan_settings.personality() -> dict[str, Any]
client.stan_settings.resume_conversation(conversation_id: str) -> StanConversation
client.stan_settings.retrieve_conversation(conversation_id: str) -> dict[str, Any]
client.stan_settings.update_personality(*, personality: str) -> dict[str, Any]

STAN Memories

client.stan_memories.create(*, content: str, type: str, importance: float | None = None) -> dict[str, Any]
client.stan_memories.delete(memory_id: str) -> None
client.stan_memories.delete_all() -> None
client.stan_memories.list(*, type: str | None = None, limit: int | None = None) -> SyncPaginator[StanMemory]
client.stan_memories.stats() -> dict[str, Any]

STAN Tasks

client.stan_tasks.add_monitor(*, instruction: str) -> dict[str, Any]
client.stan_tasks.create(*, name: str, action: str, model_id: str, schedule_type: str, run_at: str | None = None, cron: str | None = None, timezone: str | None = None, description: str | None = None, execution_mode: str | None = None, tool_name: str | None = None, tool_params: Mapping[str, Any] | None = None, model_name: str | None = None) -> dict[str, Any]
client.stan_tasks.delete(task_id: str) -> None
client.stan_tasks.heartbeat() -> dict[str, Any]
client.stan_tasks.list(*, limit: int | None = None) -> SyncPaginator[StanScheduledTask]
client.stan_tasks.pause(task_id: str) -> StanScheduledTask
client.stan_tasks.remove_monitor(monitor_id: str) -> None
client.stan_tasks.resume(task_id: str) -> StanScheduledTask
client.stan_tasks.retrieve(task_id: str) -> StanScheduledTask
client.stan_tasks.run_heartbeat() -> dict[str, Any]
client.stan_tasks.update(task_id: str, *, name: str | None = None, description: str | None = None, execution_mode: str | None = None, action: str | None = None, tool_name: str | None = None, tool_params: Mapping[str, Any] | None = None, schedule_type: str | None = None, run_at: str | None = None, cron: str | None = None, timezone: str | None = None, model_id: str | None = None, model_name: str | None = None, status: str | None = None) -> dict[str, Any]
client.stan_tasks.update_heartbeat(*, enabled: bool | None = None, checks: Sequence[str] | None = None, interval_minutes: int | None = None) -> dict[str, Any]
client.stan_tasks.update_monitor(monitor_id: str, *, instruction: str | None = None, state: str | None = None, enabled: bool | None = None) -> dict[str, Any]

Experiments

client.experiments.add_member(resource_id: str, *, user_id: str, role: str) -> Permissions
client.experiments.compare(ids: list[str]) -> dict[str, Any]
client.experiments.create(*, name: str, description: str | None = None, tags: Sequence[str] | None = None, parent_run_id: str | None = None, status: str | None = None, params: Mapping[str, ParamValue] | None = None, system_info: Mapping[str, Any] | None = None, git_info: Mapping[str, Any] | None = None) -> Experiment
client.experiments.delete(experiment_id: str) -> None
client.experiments.download_artifact(experiment_id: str, path: str, dst_path: str | os.PathLike[str] | None = None) -> str
client.experiments.get_metric_history(experiment_id: str, key: str) -> list[MetricPoint]
client.experiments.list(*, search: str | None = None, status: str | None = None, tag: str | None = None, pinned: bool | None = None, parent_run_id: str | None = None, limit: int | None = None) -> SyncPaginator[Experiment]
client.experiments.list_artifacts(experiment_id: str) -> list[ExperimentArtifact]
client.experiments.list_metric_keys(experiment_id: str) -> list[str]
client.experiments.list_runs(experiment_id: str, *, status: str | None = None) -> list[Experiment]
client.experiments.log_artifact(experiment_id: str, local_path: str | os.PathLike[str], *, path: str | None = None, type: str = "file", description: str | None = None, content_type: str | None = None) -> ExperimentArtifact
client.experiments.log_batch(experiment_id: str, *, metrics: Sequence[Mapping[str, Any]] = (), params: Mapping[str, ParamValue] | None = None) -> None
client.experiments.log_metrics(experiment_id: str, metrics: Mapping[str, float], *, step: int | None = None, timestamp: datetime | int | str | None = None) -> None
client.experiments.log_params(experiment_id: str, params: Mapping[str, ParamValue]) -> None
client.experiments.permissions(resource_id: str) -> Permissions
client.experiments.register(*, name: str, description: str | None = None, tags: Sequence[str] | None = None) -> Experiment
client.experiments.register_model(experiment_id: str, *, name: str | None = None, model_id: str | None = None, artifact_path: str = "model", description: str | None = None) -> RunModelRegistration
client.experiments.remove_member(resource_id: str, user_id: str) -> None
client.experiments.retrieve(experiment_id: str) -> Experiment
client.experiments.set_visibility(resource_id: str, visibility: str) -> Permissions
client.experiments.stats() -> ExperimentStats
client.experiments.update(experiment_id: str, *, name: str | None = None, description: str | None = None, tags: Sequence[str] | None = None, status: str | None = None, framework: str | None = None, pinned: bool | None = None) -> Experiment

AutoML

client.automl.create_job(*, name: str, target_column: str, hardware: Mapping[str, Any], dataset: str | None = None, data_source_id: str | None = None, addon_id: str | None = None, read: Mapping[str, str] | None = None, output_volume_id: str | None = None, output_volume_name: str | None = None, dataset_file: str | None = None, feature_columns: Sequence[str] | None = None, problem_type: str | None = None, predictor_type: str | None = None, preset: str | None = None, time_limit: int | None = None, metric: str | None = None, environment_id: str | None = None, advanced: Mapping[str, Any] | None = None) -> AutoMLJob
client.automl.dataset_columns(dataset_id: str, *, file: str | None = None) -> list[str]
client.automl.dataset_files(dataset_id: str) -> list[dict[str, Any]]
client.automl.datasets(*, limit: int | None = None) -> SyncPaginator[AutoMLDataset]
client.automl.delete_job(job_id: str) -> None
client.automl.deploy_best_model(job_id: str, **kwargs) -> dict[str, Any]
client.automl.job_logs(job_id: str, *, lines: int | None = None, since: str | None = None) -> dict[str, Any]
client.automl.job_metrics(job_id: str) -> dict[str, Any]
client.automl.job_status(job_id: str) -> dict[str, Any]
client.automl.list_jobs(*, status: str | None = None, search: str | None = None, limit: int | None = None) -> SyncPaginator[AutoMLJob]
client.automl.retrieve_job(job_id: str) -> AutoMLJob
client.automl.stats() -> AutoMLStats
client.automl.stop_job(job_id: str) -> AutoMLJob
client.automl.upload_dataset(file: str | Any, *, filename: str | None = None, content_type: str = "text/csv") -> str

Model Registry

client.model_registry.activate_baseline(model_id: str, baseline_id: str) -> dict[str, Any]
client.model_registry.activate_version(model_id: str, version: int) -> RegisteredModel
client.model_registry.actuals_upload_url(model_id: str, filename: str) -> UploadLink
client.model_registry.analytics(model_id: str, *, period: str | None = None) -> dict[str, Any]
client.model_registry.baseline_upload_url(model_id: str, filename: str) -> UploadLink
client.model_registry.build_baseline(model_id: str, *, upload_id: str | None = None, filename: str | None = None, volume_id: str | None = None, path: str | None = None, version: int | None = None, analyze_daily: bool = False) -> BaselineJob
client.model_registry.build_baseline_from_file(model_id: str, file: str | Path | BinaryIO, *, version: int | None = None, analyze_daily: bool = False) -> BaselineJob
client.model_registry.create(*, name: str, framework: str, source: str | None = None, description: str | None = None, framework_version: str | None = None, python_version: str | None = None, tags: Sequence[str] | None = None, workspace_id: str | None = None, artifact: Mapping[str, Any] | None = None, manifest: Mapping[str, Any] | None = None, manifest_raw: str | None = None, problem_type: str | None = None, feature_names: Sequence[str] | None = None, input_fields: Sequence[Mapping[str, str]] | None = None, requirements: Sequence[str] | None = None, environment_variables: Mapping[str, str] | None = None) -> RegisteredModel
client.model_registry.create_version(model_id: str, *, artifact: Mapping[str, Any], description: str | None = None, manifest: Mapping[str, Any] | None = None, manifest_raw: str | None = None, metrics: Mapping[str, Any] | None = None, framework_version: str | None = None, python_version: str | None = None, requirements: Sequence[str] | None = None, input_fields: Sequence[Mapping[str, str]] | None = None) -> dict[str, Any]
client.model_registry.create_version_with_upload(file: str | Path | BinaryIO, model_id: str, *, description: str | None = None, metrics: Mapping[str, Any] | None = None, framework_version: str | None = None, python_version: str | None = None, requirements: Sequence[str] | None = None, input_fields: Sequence[Mapping[str, str]] | None = None) -> dict[str, Any]
client.model_registry.create_with_upload(file: str | Path | BinaryIO, *, name: str, framework: str, description: str | None = None, tags: list[str] | None = None, workspace_id: str | None = None, problem_type: str | None = None, feature_names: Sequence[str] | None = None, framework_version: str | None = None, python_version: str | None = None, input_fields: Sequence[Mapping[str, str]] | None = None, requirements: Sequence[str] | None = None, environment_variables: Mapping[str, str] | None = None) -> RegisteredModel
client.model_registry.delete(model_id: str) -> None
client.model_registry.deploy(model_id: str, **kwargs) -> RegisteredModel
client.model_registry.deploy_version(model_id: str, version: int, **kwargs) -> RegisteredModel
client.model_registry.import_actuals(model_id: str, *, upload_id: str | None = None, filename: str | None = None, volume_id: str | None = None, path: str | None = None) -> ActualsImport
client.model_registry.import_actuals_file(model_id: str, file: str | Path | BinaryIO) -> ActualsImport
client.model_registry.list(*, search: str | None = None, framework: str | None = None, source: str | None = None, deployment_status: str | None = None, tag: str | None = None, workspace_id: str | None = None, limit: int | None = None) -> SyncPaginator[RegisteredModel]
client.model_registry.list_actuals_import_rejections(model_id: str, import_id: str, *, search: str | None = None, limit: int | None = None) -> SyncPaginator[ActualsImportRejection]
client.model_registry.list_actuals_imports(model_id: str, *, search: str | None = None, sort: str | None = None, limit: int | None = None) -> SyncPaginator[ActualsImport]
client.model_registry.list_baseline_jobs(model_id: str, *, search: str | None = None, sort: str | None = None, limit: int | None = None) -> SyncPaginator[BaselineJob]
client.model_registry.list_callers(model_id: str, *, period: str | None = None, search: str | None = None, sort: str | None = None, limit: int | None = None) -> SyncPaginator[ModelCaller]
client.model_registry.list_versions(model_id: str) -> list[ModelVersion]
client.model_registry.logs(model_id: str, *, log_type: str | None = None) -> dict[str, Any]
client.model_registry.predict(model_id: str, input_data: Any, *, entity_id: str | None = None, source: str | None = None, path: str | None = None) -> dict[str, Any]
client.model_registry.record_actuals(model_id: str, actuals: Sequence[Mapping[str, Any]]) -> ActualsRecordResult
client.model_registry.retrieve(model_id: str) -> RegisteredModel
client.model_registry.start(model_id: str) -> RegisteredModel
client.model_registry.status(model_id: str) -> dict[str, Any]
client.model_registry.stop(model_id: str) -> RegisteredModel
client.model_registry.update(model_id: str, *, name: str | None = None, description: str | None = None, framework: str | None = None, tags: Sequence[str] | None = None, problem_type: str | None = None) -> RegisteredModel
client.model_registry.update_monitoring(model_id: str, *, record_inputs: bool | None = None, label_window_days: int | None = None) -> dict[str, Any]
client.model_registry.update_serving(model_id: str, *, environment_id: str | None = None, resources: Mapping[str, Any] | None = None, autoscaling: Mapping[str, Any] | None = None, scheduling_mode: str | None = None, auto_shutdown_minutes: int | None = None, schedule_rules: Sequence[Mapping[str, Any]] | None = None, scaling_mode: str | None = None, min_replicas: int | None = None, max_replicas: int | None = None, target_concurrency: int | None = None, use_spot: bool | None = None, spot_fallback: bool | None = None) -> dict[str, Any]
client.model_registry.upload_artifact(file: str | Path | BinaryIO) -> dict[str, Any]

Fine-Tuning

client.fine_tuning.base_models() -> list[dict[str, Any]]
client.fine_tuning.create_job(*, name: str, base_model: str, training_dataset: str, volume_id: str | None = None, data_version: int | None = None, url_volume_id: str | None = None, output_volume_id: str | None = None, output_volume_name: str | None = None, description: str | None = None, validation_file: str | None = None, dataset_format: str | None = None, epochs: int | None = None, batch_size: int | None = None, training_method: str | None = None, learning_rate: float | None = None, gpu_count: int | None = None, gpu_type: str | None = None, use_spot: bool | None = None, spot_fallback: bool | None = None, hyperparameters: Mapping[str, Any] | None = None, suffix: str | None = None) -> FineTuningJob
client.fine_tuning.delete_job(job_id: str) -> None
client.fine_tuning.deploy_model(job_id: str, **kwargs) -> AIModel
client.fine_tuning.hardware() -> list[dict[str, Any]]
client.fine_tuning.job_logs(job_id: str, *, log_type: str | None = None) -> dict[str, Any]
client.fine_tuning.job_metrics(job_id: str) -> dict[str, Any]
client.fine_tuning.job_status(job_id: str) -> dict[str, Any]
client.fine_tuning.list_jobs(*, status: str | None = None, base_model: str | None = None, search: str | None = None, limit: int | None = None) -> SyncPaginator[FineTuningJob]
client.fine_tuning.model_requirements(base_model: str, *, method: str | None = None) -> dict[str, Any]
client.fine_tuning.recommend(base_model: str, *, use_case: str | None = None, dataset_size: int | None = None) -> dict[str, Any]
client.fine_tuning.restart_job(job_id: str) -> FineTuningJob
client.fine_tuning.retrieve_job(job_id: str) -> FineTuningJob
client.fine_tuning.stats() -> FineTuningStats
client.fine_tuning.stop_job(job_id: str) -> FineTuningJob
client.fine_tuning.validate_config(base_model: str, *, method: str, hardware: Mapping[str, Any] | None = None, method_config: Mapping[str, Any] | None = None) -> dict[str, Any]

Drift Detection

client.drift_detection.active_baseline(model_id: str) -> ReferenceBaseline | None
client.drift_detection.analyze(*, model_id: str, window_days: int | None = None, window_start: str | None = None, window_end: str | None = None) -> DriftAnalysisJob
client.drift_detection.analyze_status(job_id: str, *, model_id: str) -> dict[str, Any]
client.drift_detection.latest_result(model_id: str) -> DriftResult | None
client.drift_detection.list_baselines(model_id: str, *, search: str | None = None, sort: str | None = None, limit: int | None = None) -> SyncPaginator[ReferenceBaseline]
client.drift_detection.list_predictions(model_id: str, *, source: str | None = None, start_date: str | None = None, end_date: str | None = None, search: str | None = None, sort: str | None = None, limit: int | None = None) -> SyncPaginator[PredictionRecord]
client.drift_detection.log_prediction(*, model_id: str, features: Mapping[str, Any], prediction: Any, probabilities: Sequence[float] | None = None, entity_id: str | None = None, model_version: int | None = None, latency_ms: float | None = None) -> str
client.drift_detection.models(*, status: str | None = None, search: str | None = None, sort: str | None = None, limit: int | None = None) -> SyncPaginator[DriftModel]
client.drift_detection.result_features(result_id: str, *, model_id: str, rows: str | None = None, search: str | None = None, sort: str | None = None, limit: int | None = None) -> SyncPaginator[DriftResultRow]
client.drift_detection.results(model_id: str, *, status: str | None = None, search: str | None = None, sort: str | None = None, limit: int | None = None) -> SyncPaginator[DriftResult]
client.drift_detection.settings(model_id: str) -> DriftSettings | None
client.drift_detection.update_settings(model_id: str, *, enabled: bool | None = None, algorithms: Mapping[str, Any] | None = None, performance_drop_warning: float | None = None, performance_drop_alert: float | None = None, min_baseline_sample_size: int | None = None, min_window_sample_size: int | None = None, notifications: Mapping[str, Any] | None = None, schedule: Mapping[str, Any] | None = None) -> DriftSettings | None

A/B Tests

client.ab_tests.analyze_experiment(experiment_id: str) -> dict[str, Any]
client.ab_tests.conclude_experiment(experiment_id: str) -> ABTestExperiment
client.ab_tests.create(*, name: str, strategy: str, variants: Sequence[Mapping[str, Any]], description: str | None = None, tags: Sequence[str] | None = None, workspace_id: str | None = None, sticky_routing: bool | None = None, feature_rules: Sequence[Mapping[str, Any]] | None = None, bandit_config: Mapping[str, Any] | None = None, canary_config: Mapping[str, Any] | None = None) -> ABTest
client.ab_tests.create_experiment(test_id: str, *, name: str, control_variant_id: str, treatment_variant_ids: Sequence[str], primary_metric: str, description: str | None = None, hypothesis: str | None = None, confidence_level: float | None = None, minimum_detectable_effect: float | None = None, min_sample_per_variant: int | None = None, max_sample_per_variant: int | None = None, max_duration_days: float | None = None) -> ABTestExperiment
client.ab_tests.delete(test_id: str) -> None
client.ab_tests.delete_experiment(experiment_id: str) -> None
client.ab_tests.deploy(test_id: str) -> ABTest
client.ab_tests.list(*, status: str | None = None, strategy: str | None = None, model_id: str | None = None, workspace_id: str | None = None, search: str | None = None, sort: str | None = None, limit: int | None = None) -> SyncPaginator[ABTest]
client.ab_tests.list_experiments(test_id: str, *, search: str | None = None, sort: str | None = None, limit: int | None = None) -> SyncPaginator[ABTestExperiment]
client.ab_tests.metrics(test_id: str) -> ABTestMetrics
client.ab_tests.predict(test_id: str, input_data: Any, *, entity_id: str | None = None) -> dict[str, Any]
client.ab_tests.prediction_feedback(prediction_id: str, *, reward: float | None = None, label: str | None = None) -> dict[str, Any]
client.ab_tests.predictions(test_id: str, *, variant_id: str | None = None, search: str | None = None, sort: str | None = None, limit: int | None = None) -> SyncPaginator[PredictionRecord]
client.ab_tests.retrieve(test_id: str) -> ABTest
client.ab_tests.start(test_id: str) -> ABTest
client.ab_tests.start_experiment(experiment_id: str) -> ABTestExperiment
client.ab_tests.stop(test_id: str) -> ABTest
client.ab_tests.stop_experiment(experiment_id: str) -> ABTestExperiment
client.ab_tests.traffic(test_id: str) -> ABTestTraffic
client.ab_tests.update(test_id: str, *, name: str | None = None, description: str | None = None, tags: Sequence[str] | None = None) -> ABTest
client.ab_tests.update_variant(test_id: str, variant_id: str, *, weight: float | None = None, enabled: bool | None = None) -> dict[str, Any]

Governance

client.governance.add_policy(solution_id: str, policy_id: str) -> GovernanceSolution
client.governance.add_workload(solution_id: str, *, type: str, id: str, name: str | None = None) -> GovernanceSolution
client.governance.approve_gate_submission(submission_id: str, *, decision: str, comments: str | None = None) -> GateSubmission
client.governance.audit(*, entity_type: str | None = None, entity_id: str | None = None, solution_id: str | None = None, action: str | None = None, user_id: str | None = None, search: str | None = None, start_date: str | None = None, end_date: str | None = None, sort: str | None = None, limit: int | None = None) -> SyncPaginator[GovernanceAuditEntry]
client.governance.create_policy(*, name: str, description: str, category: str, severity: str, applicable_resource_types: Sequence[str], stages: Sequence[Mapping[str, Any]], is_active: bool, is_draft: bool, tags: Sequence[str] | None = None) -> GovernancePolicy
client.governance.create_solution(*, name: str, description: str | None = None, workloads: Sequence[Mapping[str, Any]] | None = None, policy_ids: Sequence[str] | None = None) -> GovernanceSolution
client.governance.delete_evidence(evidence_id: str) -> None
client.governance.delete_policy(policy_id: str) -> None
client.governance.delete_solution(solution_id: str) -> None
client.governance.download_evidence(evidence_id: str) -> bytes
client.governance.enforcement_check(*, resource_type: str, resource_id: str, organization_id: str) -> EnforcementResult
client.governance.list_policies(*, category: str | None = None, severity: str | None = None, is_active: bool | None = None, is_draft: bool | None = None, tag: str | None = None, search: str | None = None, sort: str | None = None, limit: int | None = None) -> SyncPaginator[GovernancePolicy]
client.governance.list_solutions(*, status: str | None = None, policy_id: str | None = None, workload_type: str | None = None, workload_id: str | None = None, search: str | None = None, sort: str | None = None, limit: int | None = None) -> SyncPaginator[GovernanceSolution]
client.governance.metrics() -> GovernanceMetrics
client.governance.pending_reviews(*, limit: int | None = None) -> SyncPaginator[GateSubmission]
client.governance.policy_versions(policy_id: str) -> PolicyVersionHistory
client.governance.recompute_solution(solution_id: str) -> SolutionStatusSummary
client.governance.remove_policy(solution_id: str, policy_id: str) -> None
client.governance.remove_workload(solution_id: str, workload_type: str, workload_id: str) -> None
client.governance.resource_types() -> list[GovernanceResourceType]
client.governance.retrieve_policy(policy_id: str) -> GovernancePolicy
client.governance.retrieve_solution(solution_id: str) -> GovernanceSolution
client.governance.reviewer_options() -> ReviewerOptions
client.governance.solution_requirements(solution_id: str, *, resource_type: str | None = None, limit: int | None = None) -> SyncPaginator[GateRequirement]
client.governance.submit_gate(solution_id: str, gate_id: str, *, policy_id: str, data: Mapping[str, Any] | None = None) -> GateSubmission
client.governance.update_policy(policy_id: str, *, name: str | None = None, description: str | None = None, category: str | None = None, severity: str | None = None, applicable_resource_types: Sequence[str] | None = None, stages: Sequence[Mapping[str, Any]] | None = None, is_active: bool | None = None, is_draft: bool | None = None, tags: Sequence[str] | None = None) -> GovernancePolicy
client.governance.update_solution(solution_id: str, *, name: str | None = None, description: str | None = None) -> GovernanceSolution
client.governance.upload_evidence(solution_id: str, gate_id: str, *, policy_id: str, file: FileInput) -> EvidenceAttachment
client.governance.waive_gate_submission(submission_id: str, *, reason: str) -> GateSubmission

FinOps Budgets

client.finops.budgets.list(*, search: str | None = None, status: str | None = None, scope_level: str | None = None, limit: int | None = None) -> SyncPaginator[Budget]
client.finops.budgets.retrieve(budget_id: str) -> Budget

FinOps Costs

client.finops.costs.anomalies(*, days: int | None = None, sensitivity: Sensitivity | None = None) -> CostAnomalies
client.finops.costs.breakdown(*, window: str | None = None, group_by: str | None = None, resource_type: str | None = None, org_id: str | None = None, user_id: str | None = None, namespace: str | None = None) -> CostGroupBreakdown
client.finops.costs.cost_top_drivers(*, window: str | None = None, limit: int | None = None) -> list[TopCostDriver]
client.finops.costs.daily(*, start_date: str | None = None, end_date: str | None = None, resource_type: str | None = None) -> DailyCosts
client.finops.costs.dashboard() -> FinOpsDashboard
client.finops.costs.dashboard_stats(*, period: str | None = None) -> DashboardStats
client.finops.costs.data_health() -> FinOpsDataHealth
client.finops.costs.efficiency(*, window: str | None = None, group_by: str | None = None, resource_type: str | None = None, namespace: str | None = None) -> CostEfficiency
client.finops.costs.forecast(*, months: int | None = None) -> CostForecast
client.finops.costs.historical(*, start_date: str | None = None, end_date: str | None = None, group_by: str | None = None, org_id: str | None = None, user_id: str | None = None) -> HistoricalCosts
client.finops.costs.monthly(*, months: int | None = None, year: int | None = None) -> MonthlyCosts
client.finops.costs.realtime(*, window: str | None = None, namespace: str | None = None) -> RealtimeCosts
client.finops.costs.savings(*, category: str | None = None, min_savings: float | None = None) -> SavingsRecommendations
client.finops.costs.services(*, period: str | None = None, start_date: str | None = None, end_date: str | None = None) -> ServiceCosts
client.finops.costs.top_drivers(*, limit: int | None = None, period: str | None = None) -> list[TopCostDriver]
client.finops.costs.trends(*, window: str | None = None, granularity: str | None = None, group_by: str | None = None, resource_type: str | None = None) -> CostTrend

FinOps Resource Groups

client.finops.resource_groups.add_resource(resource_group_id: str, *, type: str, resource_id: str, name: str) -> ResourceGroup
client.finops.resource_groups.create(*, name: str, description: str | None = None) -> ResourceGroup
client.finops.resource_groups.delete(resource_group_id: str) -> None
client.finops.resource_groups.list(*, search: str | None = None, status: str | None = None, sort: str | None = None, limit: int | None = None) -> SyncPaginator[ResourceGroup]
client.finops.resource_groups.remove_resource(resource_group_id: str, resource_id: str, *, type: str) -> ResourceGroup
client.finops.resource_groups.retrieve(resource_group_id: str) -> ResourceGroup
client.finops.resource_groups.update(resource_group_id: str, *, name: str | None = None, description: str | None = None, status: str | None = None) -> ResourceGroup

FinOps Schedules

client.finops.schedules.create(*, name: str, scope: Mapping[str, Any], schedule: Mapping[str, Any], description: str | None = None, organization_id: str | None = None, enabled: bool | None = None) -> Schedule
client.finops.schedules.delete(schedule_id: str) -> None
client.finops.schedules.execute(schedule_id: str, *, action: Literal['stop', 'start']) -> ScheduleExecutionLog
client.finops.schedules.history(schedule_id: str, *, limit: int | None = None) -> list[ScheduleExecutionLog]
client.finops.schedules.list(*, search: str | None = None, status: str | None = None, scope_type: str | None = None, enabled: bool | None = None, limit: int | None = None) -> SyncPaginator[Schedule]
client.finops.schedules.pause(schedule_id: str) -> None
client.finops.schedules.resume(schedule_id: str) -> None
client.finops.schedules.retrieve(schedule_id: str) -> Schedule
client.finops.schedules.update(schedule_id: str, *, name: str | None = None, description: str | None = None, scope: Mapping[str, Any] | None = None, schedule: Mapping[str, Any] | None = None, enabled: bool | None = None) -> Schedule

Users

client.users.archive(user_id: str, *, asset_action: str | None = None, transfer_to_user_id: str | None = None) -> UserArchiveResult
client.users.assets(user_id: str) -> UserAssetSummary
client.users.create(*, email: str, name: str, role: str | None = None, send_email: bool | None = None, profile: Mapping[str, Any] | None = None) -> CreatedUser
client.users.delete_me() -> AccountDeletionResult
client.users.github_ssh_keys() -> list[GithubSSHKey]
client.users.list(*, search: str | None = None, archived: bool | None = None, active: bool | None = None, sort: str | None = None, limit: int | None = None) -> SyncPaginator[User]
client.users.me() -> CurrentUser
client.users.reset_password(user_id: str) -> PasswordResetResult
client.users.retrieve(user_id: str) -> User
client.users.unarchive(user_id: str) -> User
client.users.update(user_id: str, *, name: str | None = None, email: str | None = None, active: bool | None = None, archived: bool | None = None, is_admin: bool | None = None, is_developer: bool | None = None) -> User
client.users.update_me(*, name: str | None = None, photo: str | None = None, stan_personality: str | None = None) -> CurrentUser

Organizations

client.organizations.add_credits(org_id: str, *, amount: int, note: str | None = None) -> CreditTransaction
client.organizations.add_member(org_id: str, *, user_id: str, role: str | None = None) -> Member
client.organizations.cancel_invitation(org_id: str, invitation_id: str) -> None
client.organizations.credits(org_id: str) -> OrganizationCredits
client.organizations.invite(org_id: str, *, email: str, role: str, platform_role: str | None = None, name: str | None = None) -> Invitation
client.organizations.list(*, status: str | None = None, limit: int | None = None) -> SyncPaginator[Organization]
client.organizations.list_invitations(org_id: str) -> list[Invitation]
client.organizations.list_members(org_id: str) -> list[Member]
client.organizations.list_transactions(org_id: str, *, type: str | None = None, limit: int | None = None) -> SyncPaginator[CreditTransaction]
client.organizations.remove_member(org_id: str, user_id: str) -> MemberRemoval
client.organizations.resend_invitation(org_id: str, invitation_id: str) -> None
client.organizations.retrieve(org_id: str) -> Organization
client.organizations.update(org_id: str, *, name: str | None = None, description: str | None = None, status: str | None = None, billing_email: str | None = None, settings: Mapping[str, Any] | None = None, alert_thresholds: Sequence[int] | None = None) -> Organization
client.organizations.update_member(org_id: str, user_id: str, *, role: str | None = None, platform_role: str | None = None, active: bool | None = None) -> Member

Marketplace

client.marketplace.available_addons() -> AvailableAddons
client.marketplace.available_models() -> AvailableModels
client.marketplace.cancel_deployment(deployment_id: str) -> MarketplaceDeployment
client.marketplace.create_item(*, name: str, description: str, vendor: str, type: str, vertical: str, app_name: str | None = None, tags: Sequence[str] | None = None, featured: bool | None = None, **extra) -> str
client.marketplace.delete_deployment(deployment_id: str) -> None
client.marketplace.delete_item(item_id: str) -> None
client.marketplace.deploy(*, app_name: str, marketplace_item_id: str, terms_accepted: bool, resources: Mapping[str, Any] | None = None, deployment_id: str | None = None, config: Mapping[str, Any] | None = None) -> DeploymentStarted
client.marketplace.deployment_status(deployment_id: str) -> DeploymentStatus
client.marketplace.item_deploy_config(item_id: str) -> dict[str, Any]
client.marketplace.item_license(item_id: str) -> MarketplaceLicense
client.marketplace.list_deployments() -> dict[str, DeployedItem]
client.marketplace.list_items(*, search: str | None = None, vertical: str | None = None, type: str | None = None, featured: bool | None = None, sort: str | None = None, limit: int | None = None) -> SyncPaginator[MarketplaceItem]
client.marketplace.list_reviews(item_id: str) -> MarketplaceReviews
client.marketplace.list_verticals() -> list[MarketplaceVertical]
client.marketplace.post_review(item_id: str, *, rating: float, title: str, comment: str) -> MarketplaceReview
client.marketplace.record_offering_usage(*, offering_id: str, meter_key: str, quantity: float, idempotency_key: str, occurred_at: str | None = None) -> OfferingUsageRecorded
client.marketplace.retrieve_deployment(deployment_id: str) -> MarketplaceDeployment
client.marketplace.retrieve_item(item_id: str) -> MarketplaceItem
client.marketplace.update_item(item_id: str, *, name: str | None = None, description: str | None = None, vendor: str | None = None, type: str | None = None, vertical: str | None = None, app_name: str | None = None, tags: Sequence[str] | None = None, featured: bool | None = None, **extra) -> None

Plugins

client.plugins.install(plugin_id: str, *, values: dict[str, Any] | None = None, features: dict[str, bool] | None = None, organization_id: str | None = None) -> PluginInstance
client.plugins.list() -> list[Plugin]
client.plugins.list_instances() -> SyncPaginator[PluginInstance]
client.plugins.retrieve_instance(instance_id: str) -> PluginInstance
client.plugins.uninstall(instance_id: str) -> None
client.plugins.update_instance(instance_id: str, *, enabled: bool | None = None, values: dict[str, Any] | None = None, features: dict[str, bool] | None = None) -> PluginInstance

Data Forge

client.data_forge.analytics(project_id: str) -> DataForgeAnalytics
client.data_forge.available_models() -> list[dict[str, Any]]
client.data_forge.bulk_action_pairs(project_id: str, *, action: str, pair_ids: list[str] | None = None, filters: dict[str, Any] | None = None) -> dict[str, Any]
client.data_forge.cancel_generation(generation_id: str) -> DataForgeGeneration
client.data_forge.create_project(*, name: str, description: str | None = None, chunk_strategy: str | None = None, embedding_model_id: str | None = None) -> DataForgeProject
client.data_forge.delete_document(project_id: str, document_id: str) -> None
client.data_forge.delete_project(project_id: str) -> None
client.data_forge.embedding_models() -> list[dict[str, Any]]
client.data_forge.export_dataset(project_id: str, *, format: str = "chatml", include_system_prompt: bool = True, min_quality_score: float | None = None) -> DataForgeExport
client.data_forge.generation_logs(generation_id: str, *, tail: int = 200) -> dict[str, Any]
client.data_forge.list_chunks(project_id: str, *, limit: int | None = None) -> SyncPaginator[DataForgeChunk]
client.data_forge.list_documents(project_id: str) -> list[DataForgeDocument]
client.data_forge.list_generations(project_id: str, *, limit: int | None = None) -> SyncPaginator[DataForgeGeneration]
client.data_forge.list_pairs(project_id: str, *, status: str | None = None, quality_min: float | None = None, difficulty: str | None = None, document_id: str | None = None, search: str | None = None, limit: int | None = None) -> SyncPaginator[DataForgePair]
client.data_forge.list_projects(*, status: str | None = None, search: str | None = None, limit: int | None = None) -> SyncPaginator[DataForgeProject]
client.data_forge.parse_documents(project_id: str) -> dict[str, Any]
client.data_forge.register_document(project_id: str, *, filename: str, content_type: str, file_size: int, s3_key: str) -> DataForgeDocument
client.data_forge.retrieve_export(project_id: str, version: int) -> DataForgeExport
client.data_forge.retrieve_generation(generation_id: str) -> DataForgeGeneration
client.data_forge.retrieve_project(project_id: str) -> DataForgeProject
client.data_forge.start_generation(project_id: str, *, teacher_model_id: str, output_format: str, pairs_per_chunk: int | None = None, difficulty_distribution: Mapping[str, Any] | None = None, system_prompt: str | None = None, temperature: float | None = None, style_template: str | None = None, thresholds: Mapping[str, Any] | None = None) -> DataForgeGeneration
client.data_forge.update_chunk(project_id: str, chunk_id: str, *, content: str | None = None, **kwargs) -> dict[str, Any]
client.data_forge.update_pair(pair_id: str, *, question: str | None = None, answer: str | None = None, system_prompt: str | None = None, status: str | None = None, reviewer_notes: str | None = None) -> DataForgePair
client.data_forge.update_project(project_id: str, *, name: str | None = None, description: str | None = None, config: Mapping[str, Any] | None = None) -> DataForgeProject
client.data_forge.upload_url(project_id: str, *, filename: str, content_type: str) -> dict[str, Any]

Streaming

client.streaming.deploy(workflow_id: str, *, cpu: str | None = None, memory: str | None = None, disk: str | None = None, gpu: str | None = None, gpu_type: str | None = None, idle_timeout_seconds: int | None = None, max_session_duration_seconds: int | None = None, max_concurrent_sessions: int | None = None, autoscaling: Mapping[str, Any] | None = None) -> StreamingWorkflow
client.streaming.end_session(session_id: str) -> None
client.streaming.errors(session_id: str) -> list[StreamingErrorEvent]
client.streaming.handoffs(session_id: str) -> dict[str, Any]
client.streaming.inject_message(session_id: str, text: str, *, role: Role = "system") -> None
client.streaming.list_deployments(workflow_id: str) -> list[StreamingDeployment]
client.streaming.list_recordings(session_id: str, *, limit: int | None = None) -> SyncPaginator[StreamingRecording]
client.streaming.list_sessions(*, workflow_id: str | None = None, status: str | None = None, sort: str | None = None, limit: int | None = None) -> SyncPaginator[StreamingSession]
client.streaming.list_sessions_for_workflow(workflow_id: str, *, status: str | None = None, limit: int | None = None) -> SyncPaginator[StreamingSession]
client.streaming.list_workflows(*, search: str | None = None, status: str | None = None, sort: str | None = None, limit: int | None = None) -> SyncPaginator[StreamingWorkflow]
client.streaming.session(session_id: str) -> StreamingSession
client.streaming.session_logs(session_id: str, *, lines: int | None = None, container: str | None = None) -> dict[str, Any]
client.streaming.session_status(session_id: str) -> dict[str, Any]
client.streaming.start_session(workflow_id: str, *, metadata: dict[str, Any] | None = None, correlation_id: str | None = None, disposition_schema_version: str | None = None, mode: Literal['draft', 'production'] | None = None) -> SessionStartResult
client.streaming.transcript(session_id: str, *, limit: int | None = None) -> SyncPaginator[TranscriptTurn]
client.streaming.undeploy(workflow_id: str) -> StreamingWorkflow
client.streaming.workflow(workflow_id: str) -> StreamingWorkflow

Notifications

client.notifications.delete(notification_id: str) -> None
client.notifications.list(*, unread_only: bool | None = None, sort: str | None = None, limit: int | None = None) -> SyncPaginator[Notification]
client.notifications.mark_all_read() -> int
client.notifications.register_device(*, token: str, platform: str | None = None) -> None
client.notifications.unread_count() -> int
client.notifications.update(notification_id: str, *, read: bool) -> Notification

Dashboard

client.dashboard.summary() -> DashboardSummary

Analytics

client.analytics.beacon(*, events: Sequence[Mapping[str, Any]]) -> int

Feature Store

client.feature_store.apply(store_id: str, *, entities: Sequence[Mapping[str, Any]] | None = None, views: Sequence[Mapping[str, Any]] | None = None, services: Sequence[Mapping[str, Any]] | None = None) -> dict[str, Any]
client.feature_store.deprecate_view(store_id: str, view: str, version: int) -> dict[str, Any]
client.feature_store.get_historical_features(store_id: str, feature_service: str, entity_rows: Sequence[Mapping[str, Any]] | None = None, *, entity_s3_uri: str | None = None, entity_format: str | None = None) -> dict[str, Any]
client.feature_store.get_online_features(store_id: str, feature_service: str, entity_rows: Sequence[Mapping[str, Any]], *, max_staleness_seconds: int | None = None) -> dict[str, Any]
client.feature_store.get_store(store_id: str) -> dict[str, Any]
client.feature_store.list_stores(*, limit: int | None = None) -> SyncPaginator[FeatureStoreRecord]
client.feature_store.materialize(store_id: str, view: str) -> dict[str, Any]
client.feature_store.push(store_id: str, view: str, events: Sequence[Mapping[str, Any]]) -> dict[str, Any]
client.feature_store.write(store_id: str, view: str, rows: Sequence[Mapping[str, Any]]) -> dict[str, Any]