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: List[str], expires_in_days: Optional[int] = None) -> ApiKeyCreateResponse
client.auth.list_keys(*, status: Optional[str] = None, limit: int = 50) -> SyncPaginator[ApiKey]
client.auth.retrieve_key(key_id: str) -> ApiKey
client.auth.revoke_key(key_id: str) -> Dict[str, Any]
client.auth.rotate_key(key_id: str) -> ApiKeyRotateResponse
client.auth.whoami() -> WhoamiResponse

Apps

client.apps.create(*, name: str, description: Optional[str] = None, image: Optional[str] = None, port: Optional[int] = None, replicas: Optional[int] = None, environment: Optional[Mapping[str, str]] = None, resources: Optional[Mapping[str, Any]] = None, project_id: Optional[str] = None, labels: Optional[Mapping[str, str]] = None) -> App
client.apps.create_with_upload(file: Union[str, Path, BinaryIO], *, name: Optional[str] = None, description: Optional[str] = None, framework: Optional[str] = None, runtime: Optional[str] = None, **kwargs) -> Dict[str, Any]
client.apps.delete(app_id: str) -> None
client.apps.deploy(app_id: str, **kwargs) -> Dict[str, Any]
client.apps.deploy_upload(app_id: str, file: Union[str, Path, BinaryIO], **kwargs) -> Dict[str, Any]
client.apps.list(*, status: Optional[str] = None, environment: Optional[str] = None, search: Optional[str] = None, limit: int = 50) -> SyncPaginator[App]
client.apps.logs(app_id: str, *, lines: Optional[int] = None, since: Optional[str] = None, container: Optional[str] = None) -> Any
client.apps.metrics(app_id: str) -> Dict[str, Any]
client.apps.restart(app_id: str) -> Dict[str, Any]
client.apps.retrieve(app_id: str) -> App
client.apps.start(app_id: str) -> Dict[str, Any]
client.apps.status(app_id: str) -> AppStatus
client.apps.stop(app_id: str) -> Dict[str, Any]
client.apps.update(app_id: str, *, name: Optional[str] = None, description: Optional[str] = None, image: Optional[str] = None, port: Optional[int] = None, replicas: Optional[int] = None, environment: Optional[Mapping[str, str]] = None, resources: Optional[Mapping[str, Any]] = None, labels: Optional[Mapping[str, str]] = None) -> App

Add-ons

client.addons.backup(addon_id: str) -> Dict[str, Any]
client.addons.connect_app(addon_id: str, app_id: str) -> Dict[str, Any]
client.addons.create(*, label: str, type: str, cpu: str, memory: str, disk: str, description: Optional[str] = None, version: Optional[str] = None, environment: Optional[str] = None, tier: Optional[str] = None, config: Optional[Mapping[str, Any]] = 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: Optional[str] = None, type: Optional[str] = None, status: Optional[str] = None, environment: Optional[str] = None, limit: int = 50) -> SyncPaginator[Addon]
client.addons.logs(addon_id: str, *, lines: Optional[int] = None, since: Optional[str] = None, container: Optional[str] = None) -> Any
client.addons.metrics(addon_id: str) -> Dict[str, Any]
client.addons.recover(addon_id: str) -> Dict[str, Any]
client.addons.restart(addon_id: str) -> Dict[str, Any]
client.addons.retrieve(addon_id: str) -> Addon
client.addons.schedule(addon_id: str) -> Dict[str, Any]
client.addons.start(addon_id: str) -> Dict[str, Any]
client.addons.status(addon_id: str) -> Dict[str, Any]
client.addons.stop(addon_id: str) -> Dict[str, Any]
client.addons.update(addon_id: str, *, label: Optional[str] = None, description: Optional[str] = None, version: Optional[str] = None, cpu: Optional[str] = None, memory: Optional[str] = None, disk: Optional[str] = None, config: Optional[Mapping[str, Any]] = None) -> Addon
client.addons.update_backup_config(addon_id: str, *, enabled: bool, schedule: str, retention: int) -> Dict[str, Any]
client.addons.update_permissions(addon_id: str, *, is_public: bool, allowed_users: Sequence[str]) -> Dict[str, Any]
client.addons.update_schedule(addon_id: str, *, enabled: bool, timezone: str, start_time: str, stop_time: str, days_of_week: Sequence[int], skip_holidays: Optional[bool] = None, holiday_calendar: Optional[str] = None) -> Dict[str, Any]

Data Sources

client.datasources.create(*, name: str, label: str, type: str, credentials: Mapping[str, Any], description: Optional[str] = None, category: Optional[str] = None, metadata: Optional[Mapping[str, Any]] = None) -> DataSource
client.datasources.credentials(datasource_id: str) -> Dict[str, Any]
client.datasources.delete(datasource_id: str) -> None
client.datasources.list(*, search: Optional[str] = None, type: Optional[str] = None, category: Optional[str] = None, status: Optional[str] = None, limit: int = 50) -> SyncPaginator[DataSource]
client.datasources.metadata(datasource_id: str) -> Dict[str, Any]
client.datasources.retrieve(datasource_id: str) -> DataSource
client.datasources.test_connection(datasource_id: str) -> Dict[str, Any]
client.datasources.update(datasource_id: str, *, name: Optional[str] = None, label: Optional[str] = None, description: Optional[str] = None, credentials: Optional[Mapping[str, Any]] = None, metadata: Optional[Mapping[str, Any]] = None) -> DataSource
client.datasources.update_permissions(datasource_id: str, *, allow_all_users: bool, allowed_users: Sequence[str]) -> Dict[str, Any]

Projects

client.projects.activity(project_id: str, *, limit: int = 50, offset: int = 0) -> SyncPaginator[ProjectActivity]
client.projects.add_collaborator(project_id: str, *, email: str, role: str, user_id: Optional[str] = None) -> Dict[str, Any]
client.projects.archive(project_id: str) -> Dict[str, Any]
client.projects.collaborators(project_id: str) -> List[ProjectCollaborator]
client.projects.create(*, name: str, description: str, filesystem_type: Optional[str] = None, github_config: Optional[Mapping[str, Any]] = None, tags: Optional[Sequence[str]] = None) -> Project
client.projects.delete(project_id: str) -> None
client.projects.list(*, search: Optional[str] = None, status: Optional[str] = None, category: Optional[str] = None, tag: Optional[str] = None, limit: int = 50) -> SyncPaginator[Project]
client.projects.remove_collaborator(project_id: str, user_id: str) -> Dict[str, Any]
client.projects.restore(project_id: str) -> Dict[str, Any]
client.projects.retrieve(project_id: str) -> Project
client.projects.stats(project_id: str) -> ProjectStats
client.projects.update(project_id: str, *, name: Optional[str] = None, description: Optional[str] = None, category: Optional[str] = None, visibility: Optional[str] = None, tags: Optional[Sequence[str]] = None, status: Optional[str] = None) -> Project
client.projects.update_collaborator_role(project_id: str, user_id: str, *, role: str) -> Dict[str, Any]
client.projects.volumes(project_id: str) -> List[Volume]
client.projects.workspaces(project_id: str, *, limit: int = 50) -> SyncPaginator[Workspace]

Workspaces

client.workspaces.create(*, name: str, description: str, environment_type: str, image: Optional[str] = None, resources: Optional[Mapping[str, Any]] = None, project_id: Optional[str] = None, capacity_type: Optional[str] = None, use_spot_instances: Optional[bool] = None) -> Workspace
client.workspaces.delete(workspace_id: str) -> None
client.workspaces.list(*, search: Optional[str] = None, status: Optional[str] = None, project_id: Optional[str] = None, limit: int = 50) -> SyncPaginator[Workspace]
client.workspaces.logs(workspace_id: str, *, type: Optional[str] = None) -> WorkspaceLogs
client.workspaces.metrics(workspace_id: str) -> WorkspaceMetrics
client.workspaces.restart(workspace_id: str) -> Dict[str, Any]
client.workspaces.retrieve(workspace_id: str) -> Workspace
client.workspaces.start(workspace_id: str) -> Dict[str, Any]
client.workspaces.status(workspace_id: str) -> WorkspaceStatus
client.workspaces.stop(workspace_id: str) -> Dict[str, Any]
client.workspaces.sync(workspace_id: str) -> Dict[str, Any]
client.workspaces.update(workspace_id: str, *, name: Optional[str] = None, description: Optional[str] = None, image: Optional[str] = None, resources: Optional[Mapping[str, Any]] = None, environment_type: Optional[str] = None) -> Workspace

Volumes

client.volumes.create(*, project_id: str, label: str, size_gb: float, description: Optional[str] = None, type: Optional[str] = None, mount_path: Optional[str] = None) -> Volume
client.volumes.delete(volume_id: str) -> None
client.volumes.list(*, search: Optional[str] = None, type: Optional[str] = None, project_id: Optional[str] = None, limit: int = 50) -> SyncPaginator[Volume]
client.volumes.list_shared(*, search: Optional[str] = None, limit: int = 50) -> SyncPaginator[Volume]
client.volumes.make_shared(volume_id: str) -> Dict[str, Any]
client.volumes.retrieve(volume_id: str) -> Volume
client.volumes.sync(volume_id: str) -> Dict[str, Any]
client.volumes.update(volume_id: str, *, label: Optional[str] = None, name: Optional[str] = None, description: Optional[str] = None, size_gb: Optional[float] = None, mount_path: Optional[str] = None) -> Volume

Compute

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

Workflows

client.workflows.add_connection(workflow_id: str, *, source_node_id: str, target_node_id: str, source_port: Optional[str] = None, target_port: Optional[str] = None, feedback: Optional[bool] = None, max_iterations: Optional[int] = None) -> Dict[str, Any]
client.workflows.add_node(workflow_id: str, *, node_id: str, label: Optional[str] = None, version: Optional[str] = None, config: Optional[Mapping[str, Any]] = None, position: Optional[Mapping[str, Any]] = None) -> Dict[str, Any]
client.workflows.compute_scopes(workflow_id: str) -> Dict[str, Any]
client.workflows.create(*, name: str, description: Optional[str] = None, status: Optional[str] = None, workflow_type: Optional[str] = None, tags: Optional[Sequence[str]] = None, nodes: Optional[Sequence[Mapping[str, Any]]] = None, connections: Optional[Sequence[Mapping[str, Any]]] = None, settings: Optional[Mapping[str, Any]] = None) -> Workflow
client.workflows.create_version(workflow_id: str, *, version_tag: str, description: Optional[str] = None) -> Dict[str, Any]
client.workflows.delete(workflow_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.deploy(workflow_id: str, **kwargs) -> Dict[str, Any]
client.workflows.discover(**params) -> Dict[str, Any]
client.workflows.duplicate(workflow_id: str) -> Dict[str, Any]
client.workflows.email_trigger(workflow_id: str, *, from_address: Optional[str] = None, to: Optional[str] = None, subject: Optional[str] = None, body_text: Optional[str] = None, body_html: Optional[str] = None, attachments: Optional[Sequence[Mapping[str, Any]]] = None, email_headers: Optional[Mapping[str, Any]] = None) -> Dict[str, Any]
client.workflows.emit_event(*, event_type: str, event_data: Optional[Mapping[str, Any]] = None, source: Optional[str] = None) -> Dict[str, Any]
client.workflows.enqueue(workflow_id: str, *, message: Optional[Mapping[str, Any]] = None, priority: Optional[int] = None) -> Dict[str, Any]
client.workflows.execute(workflow_id: str, *, config: Optional[Dict[str, Any]] = None) -> Dict[str, Any]
client.workflows.export(workflow_id: str) -> Dict[str, Any]
client.workflows.import_bundle(*, export_data: Mapping[str, Any], resolved_deps: Optional[Mapping[str, Any]] = 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: Optional[str] = None, search: Optional[str] = None, tag: Optional[str] = None, limit: int = 50) -> SyncPaginator[Workflow]
client.workflows.list_nodes(workflow_id: str) -> Dict[str, Any]
client.workflows.retrieve(workflow_id: str) -> Workflow
client.workflows.share(workflow_id: str, *, user_id: str, permission: Optional[str] = None) -> Dict[str, Any]
client.workflows.shared_users(workflow_id: str) -> List[WorkflowSharedUser]
client.workflows.start(workflow_id: str) -> Dict[str, Any]
client.workflows.stats() -> WorkflowStats
client.workflows.stop(workflow_id: str) -> Dict[str, Any]
client.workflows.templates() -> List[Workflow]
client.workflows.trigger(workflow_id: str, *, inputs: Optional[Dict[str, Any]] = None, trigger_type: Optional[str] = None, sync: bool = False) -> Dict[str, Any]
client.workflows.undeploy(workflow_id: str) -> Dict[str, Any]
client.workflows.unshare(workflow_id: str, *, user_id: str) -> Dict[str, Any]
client.workflows.update(workflow_id: str, *, name: Optional[str] = None, description: Optional[str] = None, status: Optional[str] = None, tags: Optional[Sequence[str]] = None, nodes: Optional[Sequence[Mapping[str, Any]]] = None, connections: Optional[Sequence[Mapping[str, Any]]] = None, config: Optional[Mapping[str, Any]] = None, settings: Optional[Mapping[str, Any]] = None) -> Workflow
client.workflows.update_lifecycle(workflow_id: str, *, type: str, idle_timeout_minutes: Optional[int] = None, schedule: Optional[Mapping[str, Any]] = None) -> Dict[str, Any]
client.workflows.update_node(workflow_id: str, node_id: str, *, config: Optional[Mapping[str, Any]] = None, label: Optional[str] = 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.list(*, workflow_id: Optional[str] = None, status: Optional[str] = None, since: Optional[str] = None, until: Optional[str] = None, trigger_type: Optional[str] = None, limit: int = 50) -> SyncPaginator[Execution]
client.executions.logs(execution_id: str, *, level: Optional[str] = None, limit: Optional[int] = None) -> List[ExecutionLog]
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: Optional[Dict[str, Any]] = None) -> Dict[str, Any]
client.executions.retrieve(execution_id: str) -> Execution
client.executions.spans(execution_id: str, *, node_id: Optional[str] = None) -> List[ExecutionSpan]
client.executions.stop(execution_id: str) -> Dict[str, Any]
client.executions.submit_input(execution_id: str, *, request_id: str, data: Any, respondent: Optional[str] = None) -> Dict[str, Any]

Workflow Nodes

client.workflow_nodes.create(*, label: str, category: str, type: str, function_definition: Mapping[str, Any], description: Optional[str] = None, is_active: Optional[bool] = None, input_definition: Optional[Mapping[str, Any]] = None, output_definition: Optional[Mapping[str, Any]] = None, editor_config: Optional[Mapping[str, Any]] = None, default_data: Optional[Mapping[str, Any]] = None) -> WorkflowNode
client.workflow_nodes.datasource_fields(datasource_id: str) -> Dict[str, Any]
client.workflow_nodes.delete(node_id: str) -> None
client.workflow_nodes.list(*, search: Optional[str] = None, category: Optional[str] = None, type: Optional[str] = None, is_system: Optional[bool] = None, limit: int = 50) -> SyncPaginator[WorkflowNode]
client.workflow_nodes.retrieve(node_id: str) -> WorkflowNode
client.workflow_nodes.schema(node_id: str) -> Dict[str, Any]
client.workflow_nodes.services_addons(*, type: Optional[str] = None) -> ServiceAddonsResponse
client.workflow_nodes.services_datasources(*, type: Optional[str] = None, category: Optional[str] = None) -> ServiceDataSourcesResponse
client.workflow_nodes.services_models(*, provider: Optional[str] = None, type: Optional[str] = None) -> ServiceModelsResponse
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: Optional[str] = None, category: Optional[str] = None, type: Optional[str] = None, description: Optional[str] = None, is_active: Optional[bool] = None, input_definition: Optional[Mapping[str, Any]] = None, output_definition: Optional[Mapping[str, Any]] = None, editor_config: Optional[Mapping[str, Any]] = None, default_data: Optional[Mapping[str, Any]] = None) -> WorkflowNode

AI Inference

client.ai.inference.cancel_generation(*, job_id: str) -> GenerationJob
client.ai.inference.chat_completion(*, model: str, messages: List[Union[Dict[str, Any], ChatMessage]], stream: bool = False, max_tokens: Optional[int] = None, temperature: float = 0.7, top_p: float = 1.0, stop: Optional[Union[str, List[str]]] = None, **kwargs) -> Union[ChatCompletion, Iterator[StreamChunk]]
client.ai.inference.completion(*, model: str, prompt: str, stream: bool = False, max_tokens: Optional[int] = None, temperature: float = 0.7, **kwargs) -> Union[Completion, Iterator[StreamChunk]]
client.ai.inference.embedding(*, model: str, input: Union[str, List[str]], **kwargs) -> EmbeddingResponse
client.ai.inference.generate(*, model: str, prompt: str, type: Optional[str] = None, **kwargs: Any) -> 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: Union[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[Union[str, Dict[str, Any]]], top_n: Optional[int] = 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: Optional[str] = None, prompt: Optional[str] = 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.clear_cache(model_id: str) -> Dict[str, Any]
client.ai.models.create(*, name: str, type: str, provider: str, vendor_model_id: str, model_type: Optional[str] = None, description: Optional[str] = None, capabilities: Optional[Sequence[str]] = None, max_tokens: Optional[int] = None, context_window: Optional[int] = None, config: Optional[Mapping[str, Any]] = None, **extra: Any) -> AIModel
client.ai.models.delete(model_id: str) -> None
client.ai.models.deploy(model_id: str, **kwargs) -> Dict[str, Any]
client.ai.models.list(*, search: Optional[str] = None, type: Optional[str] = None, status: Optional[str] = None, provider: Optional[str] = None, model_type: Optional[str] = None, limit: int = 50) -> SyncPaginator[AIModel]
client.ai.models.list_certified() -> Dict[str, Any]
client.ai.models.list_prebuilt() -> Dict[str, Any]
client.ai.models.list_providers() -> Dict[str, Any]
client.ai.models.logs(model_id: str, *, lines: Optional[int] = None, since: Optional[str] = None, container: Optional[str] = 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(model_id: str) -> AIModelPermissions
client.ai.models.retrieve(model_id: str) -> AIModel
client.ai.models.start(model_id: str) -> Dict[str, Any]
client.ai.models.status(model_id: str) -> AIModelStatus
client.ai.models.stop(model_id: str) -> Dict[str, Any]
client.ai.models.update(model_id: str, *, name: Optional[str] = None, type: Optional[str] = None, provider: Optional[str] = None, vendor_model_id: Optional[str] = None, model_type: Optional[str] = None, description: Optional[str] = None, capabilities: Optional[Sequence[str]] = None, max_tokens: Optional[int] = None, context_window: Optional[int] = None, config: Optional[Mapping[str, Any]] = None, **extra: Any) -> AIModel
client.ai.models.update_permissions(model_id: str, *, is_shared: Optional[bool] = None, shared_with: Optional[List[str]] = None) -> Dict[str, Any]

AI Provider Keys

client.ai.provider_keys.create(*, name: str, provider: str, api_key: str, description: Optional[str] = None, provider_organization: Optional[str] = None) -> ProviderKey
client.ai.provider_keys.delete(key_id: str) -> None
client.ai.provider_keys.list(*, provider: Optional[str] = None, status: Optional[str] = None, search: Optional[str] = None, limit: int = 50) -> 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: Optional[str] = None, description: Optional[str] = None, api_key: Optional[str] = None, provider_organization: Optional[str] = None) -> ProviderKey

AI Analytics

client.ai.analytics.costs(*, start_date: Optional[str] = None, end_date: Optional[str] = None, model_id: Optional[str] = None, provider: Optional[str] = None, group_by: Optional[str] = None) -> CostBreakdown
client.ai.analytics.performance(*, start_date: Optional[str] = None, end_date: Optional[str] = None, model_id: Optional[str] = None, provider: Optional[str] = None) -> PerformanceStats
client.ai.analytics.providers(*, start_date: Optional[str] = None, end_date: Optional[str] = None) -> ProviderStats
client.ai.analytics.time_series(*, start_date: Optional[str] = None, end_date: Optional[str] = None, model_id: Optional[str] = None, metric: Optional[str] = None, granularity: Optional[str] = None, provider: Optional[str] = None) -> TimeSeriesData
client.ai.analytics.usage(*, start_date: Optional[str] = None, end_date: Optional[str] = None, model_id: Optional[str] = None, provider: Optional[str] = None, granularity: Optional[str] = None) -> UsageStats

Agents

client.agents.analytics(agent_id: str, *, days: int = 30) -> AgentAnalytics
client.agents.attach_skill(agent_id: str, *, skill_id: str, editable: Optional[bool] = None, auto_connected: Optional[bool] = None, connected_by: Optional[str] = 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: Optional[str] = None, nodes: Optional[Sequence[Mapping[str, Any]]] = None, connections: Optional[Sequence[Mapping[str, Any]]] = None) -> Dict[str, Any]
client.agents.create_artifact(agent_id: str, *, title: str, content: str, artifact_type: Optional[str] = None, thread_id: Optional[str] = None, summary: Optional[str] = None, skill_id: Optional[str] = None, tags: Optional[Sequence[str]] = None, metadata: Optional[Mapping[str, Any]] = None) -> Dict[str, Any]
client.agents.create_thread(agent_id: str, *, title: Optional[str] = None) -> AgentThread
client.agents.delete(agent_id: str) -> None
client.agents.delete_artifact(agent_id: str, artifact_id: str) -> None
client.agents.delete_thread(agent_id: str, thread_id: str) -> None
client.agents.detach_skill(agent_id: str, skill_id: str) -> Dict[str, Any]
client.agents.list(*, status: Optional[str] = None, search: Optional[str] = None, limit: int = 50) -> SyncPaginator[Agent]
client.agents.list_artifacts(agent_id: str) -> Dict[str, Any]
client.agents.list_skills(agent_id: str) -> Dict[str, Any]
client.agents.list_threads(agent_id: str) -> List[AgentThread]
client.agents.promote(workflow_id: str) -> Dict[str, Any]
client.agents.redeploy(agent_id: str) -> Dict[str, Any]
client.agents.retrieve(agent_id: str) -> Agent
client.agents.retrieve_artifact(agent_id: str, artifact_id: str) -> Dict[str, Any]
client.agents.start(agent_id: str) -> Dict[str, Any]
client.agents.status(agent_id: str) -> AgentStatus
client.agents.stop(agent_id: str) -> Dict[str, Any]
client.agents.update(agent_id: str, *, name: Optional[str] = None, description: Optional[str] = None, nodes: Optional[Sequence[Mapping[str, Any]]] = None, connections: Optional[Sequence[Mapping[str, Any]]] = None, config: Optional[Mapping[str, Any]] = 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: Optional[List[str]] = None) -> Dict[str, Any]
client.agents.update_operating_prompt(agent_id: str, operating_prompt_id: Optional[str]) -> 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]
client.agents.upload_knowledge(agent_id: str, file: Union[str, Path, BinaryIO], *, description: Optional[str] = None, tags: Optional[str] = None, document_id: Optional[str] = None) -> KnowledgeUploadResult

Agent Messages

client.agent_messages.delete(message_id: str) -> None
client.agent_messages.list(*, type: Optional[str] = None, agent_id: Optional[str] = None, category: Optional[str] = None) -> List[AgentMessage]
client.agent_messages.mark_read(message_id: str) -> Dict[str, Any]
client.agent_messages.send(*, from_agent_id: str, from_agent_name: str, content: str, to_agent_id: Optional[str] = None, to_agent_name: Optional[str] = None, category: Optional[str] = None, metadata: Optional[Mapping[str, Any]] = None, organization_id: Optional[str] = None, expires_at: Optional[str] = None) -> AgentMessage

Agent Router

client.agent_router.add_member(router_id: str, *, model_id: str, weight: Optional[float] = None, priority: Optional[int] = None, enabled: Optional[bool] = None, cost_per_1k_input: Optional[float] = None, cost_per_1k_output: Optional[float] = None, capabilities: Optional[Sequence[str]] = None) -> AgentRouterModel
client.agent_router.create(*, name: str, strategy: str, description: Optional[str] = None, members: Optional[Sequence[Mapping[str, Any]]] = None, fallback_behavior: Optional[str] = None, routellm_config: Optional[Mapping[str, Any]] = None, complexity_config: Optional[Mapping[str, Any]] = None, content_type_config: Optional[Mapping[str, Any]] = None, bandit_config: Optional[Mapping[str, Any]] = None) -> AgentRouterModel
client.agent_router.delete(router_id: str) -> None
client.agent_router.list() -> List[AgentRouter]
client.agent_router.remove_member(router_id: str, member_id: str) -> None
client.agent_router.retrieve(router_id: str) -> AgentRouter
client.agent_router.update(router_id: str, *, name: Optional[str] = None, strategy: Optional[str] = None, description: Optional[str] = None, members: Optional[Sequence[Mapping[str, Any]]] = None, fallback_behavior: Optional[str] = None) -> AgentRouterModel

Agent Sessions

client.sessions.end(agent_id: str, session_id: str, *, reason: Optional[str] = None) -> Dict[str, Any]
client.sessions.list(agent_id: str, *, state: Optional[str] = None, limit: Optional[int] = None, offset: Optional[int] = None) -> List[AgentSession]
client.sessions.pause(agent_id: str, session_id: str) -> Dict[str, Any]
client.sessions.resume(agent_id: str, session_id: str) -> Dict[str, Any]
client.sessions.retrieve(agent_id: str, session_id: str) -> AgentSession
client.sessions.transfer(agent_id: str, session_id: str, target_agent_id: str) -> Dict[str, Any]
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: Optional[int] = 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: Optional[str] = None, streaming_session_id: Optional[str] = None) -> AgentSession

Avatars

client.avatars.create(*, name: str, description: Optional[str] = None, type: Optional[str] = None, image_url: Optional[str] = None, config: Optional[Mapping[str, Any]] = None) -> Avatar
client.avatars.delete(avatar_id: str) -> None
client.avatars.list(**params) -> List[Avatar]
client.avatars.preview(avatar_id: str, *, options: Optional[Mapping[str, Any]] = None) -> Dict[str, Any]
client.avatars.retrieve(avatar_id: str) -> Avatar
client.avatars.update(avatar_id: str, *, name: Optional[str] = None, description: Optional[str] = None, image_url: Optional[str] = None, config: Optional[Mapping[str, Any]] = None) -> Avatar

Code Sessions

client.code_sessions.create(*, project_name: str, project_description: str, project_id: Optional[str] = None, workspace_id: Optional[str] = None) -> CodeSession
client.code_sessions.delete(session_id: str) -> None
client.code_sessions.deploy(session_id: str) -> Dict[str, Any]
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) -> Dict[str, Any]

Memory

client.memory.add_link(memory_id: str, *, target_id: str, relation: str, weight: Optional[float] = None) -> MemoryLink
client.memory.assess(memory_id: str) -> Dict[str, Any]
client.memory.consolidate(*, scope: Optional[Mapping[str, Any]] = None, config: Optional[Mapping[str, Any]] = None, dry_run: Optional[bool] = None) -> Dict[str, Any]
client.memory.create(*, kind: str, content: str, summary: Optional[str] = None, tags: Optional[Sequence[str]] = None, category: Optional[str] = None, source: Optional[str] = None, event_time: Optional[str] = None, valid_from: Optional[str] = None, valid_until: Optional[str] = None, source_thread_id: Optional[str] = None, source_message_id: Optional[str] = None, source_tool_name: Optional[str] = None, importance: Optional[float] = None, decay_half_life_days: Optional[float] = None, confidence: Optional[float] = None, links: Optional[Sequence[Mapping[str, Any]]] = None, scope: Optional[Mapping[str, Any]] = None) -> MemoryModel
client.memory.delete(memory_id: str) -> None
client.memory.delete_link(memory_id: str, target_id: str) -> None
client.memory.export(**params) -> Dict[str, Any]
client.memory.import_memories(*, memories: Sequence[Mapping[str, Any]], scope: Optional[Mapping[str, Any]] = None) -> Dict[str, Any]
client.memory.ingest(*, content: str, kind: str, tags: Optional[Sequence[str]] = None, scope: Optional[Mapping[str, Any]] = None, model: Optional[str] = None, candidate_k: Optional[int] = None) -> Dict[str, Any]
client.memory.invalidate(memory_id: str, *, superseded_by: Optional[str] = None) -> Dict[str, Any]
client.memory.linked_to(memory_id: str, **params) -> List[Memory]
client.memory.list(*, kind: Optional[str] = None, tags: Optional[List[str]] = None, search: Optional[str] = None, agent_id: Optional[str] = None, app_id: Optional[str] = None, workflow_id: Optional[str] = None, as_of: Optional[str] = None, limit: int = 50) -> SyncPaginator[Memory]
client.memory.record_access(memory_id: str) -> Dict[str, Any]
client.memory.restore_version(memory_id: str, version: int) -> MemoryModel
client.memory.retrieve(memory_id: str) -> Memory
client.memory.retrieve_version(memory_id: str, version: int) -> MemoryVersion
client.memory.search(*, query: str, k: Optional[int] = None, kind: Optional[str] = None, tags: Optional[Sequence[str]] = None, scope: Optional[Mapping[str, Any]] = None, rrf_k: Optional[int] = None, weights: Optional[Mapping[str, Any]] = None, decay_half_life_days_override: Optional[float] = None, as_of: Optional[str] = None, include_invalidated: Optional[bool] = None, rerank: Optional[bool] = None, rerank_model: Optional[str] = None) -> Dict[str, Any]
client.memory.share(memory_id: str, *, user_id: str) -> Dict[str, Any]
client.memory.toggle_public(memory_id: str) -> Dict[str, Any]
client.memory.unshare(memory_id: str, *, user_id: str) -> Dict[str, Any]
client.memory.update(memory_id: str, *, kind: Optional[str] = None, content: Optional[str] = None, summary: Optional[str] = None, tags: Optional[Sequence[str]] = None, category: Optional[str] = None, event_time: Optional[str] = None, valid_from: Optional[str] = None, valid_until: Optional[str] = None, source_thread_id: Optional[str] = None, source_message_id: Optional[str] = None, source_tool_name: Optional[str] = None, importance: Optional[float] = None, decay_half_life_days: Optional[float] = None, confidence: Optional[float] = None, links: Optional[Sequence[Mapping[str, Any]]] = None, change_note: Optional[str] = None) -> MemoryModel
client.memory.update_scope(memory_id: str, *, scope: Optional[Dict[str, Any]] = None) -> Dict[str, Any]
client.memory.versions(memory_id: str) -> List[MemoryVersion]

Rules

client.rules.applicable(*, user_turn: Optional[str] = None, tool_name: Optional[str] = None, scope: Optional[Mapping[str, Any]] = None) -> Dict[str, Any]
client.rules.assess(rule_id: str) -> Dict[str, Any]
client.rules.check(*, tool_name: Optional[str] = None, description: Optional[str] = None, args: Optional[Mapping[str, Any]] = None, user_turn: Optional[str] = None, scope: Optional[Mapping[str, Any]] = None) -> Dict[str, Any]
client.rules.create(*, description: str, content: str, category: str, severity: Optional[str] = None, hierarchy_scope: Optional[str] = None, enforcement_mode: Optional[str] = None, triggers: Optional[Mapping[str, Any]] = None, tags: Optional[Sequence[str]] = None, enabled: Optional[bool] = None, source: Optional[str] = None, scope: Optional[Mapping[str, Any]] = None) -> Rule
client.rules.delete(rule_id: str) -> None
client.rules.export(**params) -> Dict[str, Any]
client.rules.import_from_github(*, github_url: str) -> Dict[str, Any]
client.rules.import_rules(*, rules: Sequence[Mapping[str, Any]], scope: Optional[Mapping[str, Any]] = None) -> Dict[str, Any]
client.rules.list(*, category: Optional[str] = None, severity: Optional[str] = None, hierarchy_scope: Optional[str] = None, enabled: Optional[bool] = None, tags: Optional[List[str]] = None, search: Optional[str] = None, agent_id: Optional[str] = None, app_id: Optional[str] = None, workflow_id: Optional[str] = None, limit: int = 50) -> SyncPaginator[Rule]
client.rules.list_violations(rule_id: str, **params) -> List[RuleViolation]
client.rules.record_violation(rule_id: str, *, attempted_action: str, detected_by: Optional[str] = None, thread_id: Optional[str] = None, run_id: Optional[str] = None, scope: Optional[Mapping[str, Any]] = None, evidence: Optional[Mapping[str, Any]] = None) -> RuleViolation
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.share(rule_id: str, *, user_id: str) -> Dict[str, Any]
client.rules.toggle_enabled(rule_id: str) -> Dict[str, Any]
client.rules.toggle_public(rule_id: str) -> Dict[str, Any]
client.rules.unshare(rule_id: str, *, user_id: str) -> Dict[str, Any]
client.rules.update(rule_id: str, *, description: Optional[str] = None, content: Optional[str] = None, category: Optional[str] = None, severity: Optional[str] = None, hierarchy_scope: Optional[str] = None, enforcement_mode: Optional[str] = None, triggers: Optional[Mapping[str, Any]] = None, tags: Optional[Sequence[str]] = None, enabled: Optional[bool] = None, change_note: Optional[str] = None) -> Rule
client.rules.update_scope(rule_id: str, *, scope: Optional[Dict[str, Any]] = None) -> Dict[str, Any]
client.rules.versions(rule_id: str) -> List[RuleVersion]
client.rules.violations_aggregate(**params) -> Dict[str, Any]

Tasks

client.tasks.cancel(task_id: str, *, reason: Optional[str] = None) -> Task
client.tasks.complete(task_id: str, *, notes: Optional[str] = None, execution_id: Optional[str] = None) -> Task
client.tasks.create(*, description: str, subject_ref: Optional[Mapping[str, Any]] = None, due_at: Optional[str] = None, notes: Optional[str] = None, recurrence: Optional[Mapping[str, Any]] = None, tags: Optional[Sequence[str]] = None, agent_id: Optional[str] = None, app_id: Optional[str] = None, workflow_id: Optional[str] = None, created_by_agent: Optional[str] = None, assigned_to_agent: Optional[str] = None, shared_with: Optional[Sequence[str]] = None, is_public: Optional[bool] = None) -> Task
client.tasks.delete(task_id: str) -> None
client.tasks.end_recurrence(task_id: str) -> Task
client.tasks.list(*, kind: Optional[str] = None, status: Optional[str] = None, include_completed: Optional[bool] = None, search_text: Optional[str] = None, agent_id: Optional[str] = None, app_id: Optional[str] = None, workflow_id: Optional[str] = None, limit: int = 50) -> SyncPaginator[Task]
client.tasks.retrieve(task_id: str) -> Task
client.tasks.share(task_id: str, user_ids: List[str]) -> Dict[str, Any]
client.tasks.skip_next(task_id: str) -> Task
client.tasks.status(task_id: str) -> TaskStatus
client.tasks.toggle_public(task_id: str) -> Dict[str, Any]
client.tasks.unshare(task_id: str, user_ids: List[str]) -> Dict[str, Any]
client.tasks.update(task_id: str, *, description: Optional[str] = None, subject_ref: Optional[Mapping[str, Any]] = None, due_at: Optional[str] = None, notes: Optional[str] = None, recurrence: Optional[Mapping[str, Any]] = None, tags: Optional[Sequence[str]] = None, status: Optional[str] = None, agent_id: Optional[str] = None, app_id: Optional[str] = None, workflow_id: Optional[str] = None) -> Task
client.tasks.update_scope(task_id: str, *, scope: Optional[Dict[str, Any]] = None) -> Dict[str, Any]

Prompts

client.prompts.create(*, name: str, content: str, type: str = 'system-prompt', description: Optional[str] = None, variables: Optional[Sequence[Mapping[str, Any]]] = None, tags: Optional[Sequence[str]] = None, source: Optional[str] = None, files: Optional[Sequence[Mapping[str, Any]]] = None, github_url: Optional[str] = None, scope: Optional[Mapping[str, Any]] = None) -> Prompt
client.prompts.delete(prompt_id: str) -> None
client.prompts.duplicate(prompt_id: str) -> Dict[str, Any]
client.prompts.list(*, type: Optional[str] = None, search: Optional[str] = None, tags: Optional[str] = None, limit: Optional[int] = None) -> SyncPaginator[Prompt]
client.prompts.list_versions(prompt_id: str) -> List[PromptVersion]
client.prompts.record_usage(prompt_id: str) -> None
client.prompts.render(prompt_id: str, variables: Mapping[str, str]) -> PromptRenderResult
client.prompts.restore_version(prompt_id: str, version_number: int) -> Dict[str, Any]
client.prompts.retrieve(prompt_id: str) -> Prompt
client.prompts.search(*, q: str, type: Optional[str] = None, tags: Optional[str] = None, limit: Optional[int] = None) -> Dict[str, Any]
client.prompts.update(prompt_id: str, *, name: Optional[str] = None, description: Optional[str] = None, content: Optional[str] = None, variables: Optional[Sequence[Mapping[str, Any]]] = None, tags: Optional[Sequence[str]] = None, change_note: Optional[str] = None) -> Dict[str, Any]
client.prompts.update_scope(prompt_id: str, *, scope: Optional[Mapping[str, Any]] = None) -> Dict[str, Any]

Skills

client.skills.assess(skill_id: str) -> Dict[str, Any]
client.skills.create(*, name: str, content: str, description: Optional[str] = None, variables: Optional[Sequence[Mapping[str, Any]]] = None, tags: Optional[Sequence[str]] = None, category: Optional[str] = None, source: Optional[str] = None, files: Optional[Sequence[Mapping[str, Any]]] = None, github_url: Optional[str] = None, mcp_tools: Optional[Sequence[str]] = None, scope: Optional[Mapping[str, Any]] = None) -> Skill
client.skills.delete(skill_id: str) -> None
client.skills.duplicate(skill_id: str) -> Dict[str, Any]
client.skills.import_from_github(github_url: str) -> Dict[str, Any]
client.skills.list(*, category: Optional[str] = None, search: Optional[str] = None, tags: Optional[str] = None, limit: Optional[int] = None) -> SyncPaginator[Skill]
client.skills.list_versions(skill_id: str) -> List[SkillVersion]
client.skills.record_usage(skill_id: str) -> None
client.skills.render(skill_id: str, variables: Mapping[str, str]) -> SkillRenderResult
client.skills.restore_version(skill_id: str, version_number: int) -> Dict[str, Any]
client.skills.retrieve(skill_id: str) -> Skill
client.skills.update(skill_id: str, *, name: Optional[str] = None, description: Optional[str] = None, content: Optional[str] = None, variables: Optional[Sequence[Mapping[str, Any]]] = None, tags: Optional[Sequence[str]] = None, category: Optional[str] = None, change_note: Optional[str] = None, files: Optional[Sequence[Mapping[str, Any]]] = None, mcp_tools: Optional[Sequence[str]] = None) -> Dict[str, Any]
client.skills.update_scope(skill_id: str, *, scope: Optional[Mapping[str, Any]] = None) -> Dict[str, Any]

Artifacts

client.artifacts.create(*, title: str, artifact_type: str, content_type: str, content: str, summary: Optional[str] = None, tags: Optional[Sequence[str]] = None) -> Artifact
client.artifacts.delete(artifact_id: str) -> None
client.artifacts.download_url(artifact_id: str, *, ttl_seconds: Optional[int] = None) -> ArtifactDownloadUrl
client.artifacts.list(*, search: Optional[str] = None, artifact_type: Optional[str] = None, tags: Optional[List[str]] = None, producer_agent_id: Optional[str] = None, producer_skill_id: Optional[str] = None, limit: int = 50) -> SyncPaginator[Artifact]
client.artifacts.refresh_size(artifact_id: str) -> Artifact
client.artifacts.retrieve(artifact_id: str) -> Artifact
client.artifacts.share(artifact_id: str, user_id: str) -> Dict[str, Any]
client.artifacts.toggle_org_share(artifact_id: str) -> Dict[str, Any]
client.artifacts.toggle_public(artifact_id: str) -> Dict[str, Any]
client.artifacts.unshare(artifact_id: str, user_id: str) -> Dict[str, Any]
client.artifacts.update(artifact_id: str, *, title: Optional[str] = None, summary: Optional[str] = None, tags: Optional[Sequence[str]] = None) -> Artifact
client.artifacts.update_scope(artifact_id: str, *, scope: Optional[Dict[str, Any]] = None) -> Dict[str, Any]

Preferences

client.preferences.by_key(key: str) -> Preference
client.preferences.create(*, key: str, value: Any, category: Optional[str] = None, preference_source: Optional[str] = None, confidence: Optional[float] = None, evidence: Optional[str] = None, tags: Optional[Sequence[str]] = None, scope: Optional[Mapping[str, Any]] = None) -> Preference
client.preferences.delete(preference_id: str) -> None
client.preferences.forget(key: str, *, scope: Optional[Dict[str, Any]] = None) -> Dict[str, Any]
client.preferences.list(*, search: Optional[str] = None, category: Optional[str] = None, preference_source: Optional[str] = None, tags: Optional[List[str]] = None, include_superseded: Optional[bool] = None, limit: int = 50) -> SyncPaginator[Preference]
client.preferences.retrieve(preference_id: str) -> Preference
client.preferences.set(key: str, value: Any, *, category: Optional[str] = None, preference_source: Optional[str] = None, confidence: Optional[float] = None, evidence: Optional[str] = None, tags: Optional[Sequence[str]] = None, scope: Optional[Mapping[str, Any]] = None) -> Preference
client.preferences.share(preference_id: str, user_id: str) -> Dict[str, Any]
client.preferences.toggle_public(preference_id: str) -> Dict[str, Any]
client.preferences.unshare(preference_id: str, user_id: str) -> Dict[str, Any]
client.preferences.update(preference_id: str, *, value: Any = None, category: Optional[str] = None, preference_source: Optional[str] = None, confidence: Optional[float] = None, evidence: Optional[str] = None, tags: Optional[Sequence[str]] = None) -> Preference
client.preferences.update_scope(preference_id: str, *, scope: Optional[Dict[str, Any]] = None) -> Dict[str, Any]

STAN

client.stan.create_session(*, model_id: str, active_workflow_id: Optional[str] = None, active_workflow_name: Optional[str] = None) -> Dict[str, Any]
client.stan.end_session(session_id: str) -> None
client.stan.retrieve_session(session_id: str) -> Dict[str, Any]
client.stan.send_message(session_id: str, *, message: 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: Optional[int] = None, offset: Optional[int] = None) -> Dict[str, Any]
client.stan_settings.list_skills() -> Dict[str, Any]
client.stan_settings.message(*, message: str, source: Optional[str] = None) -> Dict[str, Any]
client.stan_settings.personality() -> Dict[str, Any]
client.stan_settings.resume_conversation(conversation_id: str) -> Dict[str, Any]
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: Optional[float] = None) -> Dict[str, Any]
client.stan_memories.delete(memory_id: str) -> None
client.stan_memories.delete_all(*, type: Optional[str] = None) -> Dict[str, Any]
client.stan_memories.list(*, type: Optional[str] = None, limit: Optional[int] = None, offset: Optional[int] = None) -> Dict[str, Any]
client.stan_memories.stats() -> Dict[str, Any]

STAN Tasks

client.stan_tasks.create(*, name: str, action: str, model_id: str, schedule_type: str, run_at: Optional[str] = None, cron: Optional[str] = None, timezone: Optional[str] = None, description: Optional[str] = None, execution_mode: Optional[str] = None, tool_name: Optional[str] = None, tool_params: Optional[Mapping[str, Any]] = None, model_name: Optional[str] = None) -> Dict[str, Any]
client.stan_tasks.delete(task_id: str) -> None
client.stan_tasks.heartbeat() -> Dict[str, Any]
client.stan_tasks.list(*, limit: Optional[int] = None, offset: Optional[int] = None) -> Dict[str, Any]
client.stan_tasks.pause(task_id: str) -> Dict[str, Any]
client.stan_tasks.resume(task_id: str) -> Dict[str, Any]
client.stan_tasks.retrieve(task_id: str) -> Dict[str, Any]
client.stan_tasks.run_heartbeat() -> Dict[str, Any]
client.stan_tasks.update(task_id: str, *, name: Optional[str] = None, description: Optional[str] = None, execution_mode: Optional[str] = None, action: Optional[str] = None, tool_name: Optional[str] = None, tool_params: Optional[Mapping[str, Any]] = None, schedule_type: Optional[str] = None, run_at: Optional[str] = None, cron: Optional[str] = None, timezone: Optional[str] = None, model_id: Optional[str] = None, model_name: Optional[str] = None, status: Optional[str] = None) -> Dict[str, Any]
client.stan_tasks.update_heartbeat(*, enabled: Optional[bool] = None, checks: Optional[Sequence[str]] = None, interval_minutes: Optional[int] = None) -> Dict[str, Any]

Experiments

client.experiments.compare(ids: List[str]) -> Dict[str, Any]
client.experiments.create(*, name: str, description: Optional[str] = None, tags: Optional[Sequence[str]] = None) -> Experiment
client.experiments.delete(experiment_id: str) -> None
client.experiments.list(*, search: Optional[str] = None, status: Optional[str] = None, tag: Optional[str] = None, pinned: Optional[bool] = None, limit: int = 50) -> SyncPaginator[Experiment]
client.experiments.log_artifact(experiment_id: str, *, name: str, s3_key: Optional[str] = None, content_base64: Optional[str] = None, path: Optional[str] = None, type: Optional[str] = None, content_type: Optional[str] = None, size: Optional[int] = None) -> Dict[str, Any]
client.experiments.log_metric(experiment_id: str, *, metrics: Sequence[Mapping[str, Any]]) -> Dict[str, Any]
client.experiments.log_param(experiment_id: str, *, params: Mapping[str, Any]) -> Dict[str, Any]
client.experiments.pin(experiment_id: str) -> Dict[str, Any]
client.experiments.register(*, name: str, description: Optional[str] = None, tags: Optional[Sequence[str]] = None) -> Dict[str, Any]
client.experiments.retrieve(experiment_id: str) -> Experiment
client.experiments.stats() -> ExperimentStats
client.experiments.update(experiment_id: str, *, name: Optional[str] = None, description: Optional[str] = None, tags: Optional[Sequence[str]] = None, status: Optional[str] = None) -> Experiment
client.experiments.update_tags(experiment_id: str, tags: List[str]) -> Dict[str, Any]

AutoML

client.automl.create_job(*, name: str, dataset: str, target_column: str, problem_type: str = 'tabular', predictor_type: str = 'auto', preset: str = 'medium_quality', time_limit: int = 600, metric: Optional[str] = None, feature_columns: Optional[Sequence[str]] = None, label_column: Optional[str] = None, data_source: Optional[Mapping[str, Any]] = None, hardware: Optional[Mapping[str, Any]] = None, advanced: Optional[Mapping[str, Any]] = None) -> AutoMLJob
client.automl.datasets() -> List[Dict[str, Any]]
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: Optional[int] = None, since: Optional[str] = None) -> Dict[str, Any]
client.automl.list_jobs(*, status: Optional[str] = None, search: Optional[str] = None, limit: int = 50) -> SyncPaginator[AutoMLJob]
client.automl.retrieve_job(job_id: str) -> AutoMLJob
client.automl.stats() -> AutoMLStats
client.automl.stop_job(job_id: str) -> Dict[str, Any]

Model Registry

client.model_registry.create(*, name: str, framework: str, source: Optional[str] = None, description: Optional[str] = None, framework_version: Optional[str] = None, python_version: Optional[str] = None, tags: Optional[Sequence[str]] = None, workspace_id: Optional[str] = None, artifact: Optional[Mapping[str, Any]] = None, manifest: Optional[Mapping[str, Any]] = None, manifest_raw: Optional[str] = None) -> RegisteredModel
client.model_registry.create_with_upload(file: Union[str, Path, BinaryIO], *, name: str, framework: str, description: Optional[str] = None, tags: Optional[List[str]] = None, workspace_id: Optional[str] = None) -> RegisteredModel
client.model_registry.delete(model_id: str) -> None
client.model_registry.deploy(model_id: str, **kwargs) -> Dict[str, Any]
client.model_registry.list(*, search: Optional[str] = None, framework: Optional[str] = None, source: Optional[str] = None, deployment_status: Optional[str] = None, tag: Optional[str] = None, workspace_id: Optional[str] = None, limit: int = 50) -> SyncPaginator[RegisteredModel]
client.model_registry.predict(model_id: str, input_data: Union[Dict[str, Any], List[Any]], *, entity_id: Optional[str] = None, log_prediction: Optional[bool] = None) -> Dict[str, Any]
client.model_registry.retrieve(model_id: str) -> RegisteredModel
client.model_registry.update(model_id: str, *, name: Optional[str] = None, description: Optional[str] = None, framework: Optional[str] = None, tags: Optional[Sequence[str]] = None) -> RegisteredModel
client.model_registry.upload_artifact(file: Union[str, Path, BinaryIO]) -> Dict[str, Any]
client.model_registry.list_versions(model_id: str) -> List[ModelVersion]
client.model_registry.create_version(model_id: str, *, artifact: Mapping[str, Any], description: Optional[str] = None, manifest: Optional[Mapping[str, Any]] = None, manifest_raw: Optional[str] = None, metrics: Optional[Mapping[str, Any]] = None) -> Dict[str, Any]
client.model_registry.create_version_with_upload(file: Union[str, Path, BinaryIO], model_id: str, *, description: Optional[str] = None, metrics: Optional[Mapping[str, Any]] = None) -> Dict[str, Any]
client.model_registry.activate_version(model_id: str, version: int) -> Dict[str, Any]
client.model_registry.deploy_version(model_id: str, version: int) -> 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, description: Optional[str] = None, validation_file: Optional[str] = None, hyperparameters: Optional[Mapping[str, Any]] = None, suffix: Optional[str] = None) -> FineTuningJob
client.fine_tuning.delete_job(job_id: str) -> None
client.fine_tuning.deploy_model(job_id: str, **kwargs) -> Dict[str, Any]
client.fine_tuning.estimate_cost(*, base_model: str, dataset_size: int, **kwargs) -> FineTuningCostEstimate
client.fine_tuning.hardware() -> List[Dict[str, Any]]
client.fine_tuning.job_logs(job_id: str, *, lines: Optional[int] = None, since: Optional[str] = None) -> Dict[str, Any]
client.fine_tuning.job_metrics(job_id: str) -> Dict[str, Any]
client.fine_tuning.list_jobs(*, status: Optional[str] = None, base_model: Optional[str] = None, search: Optional[str] = None, limit: int = 50) -> SyncPaginator[FineTuningJob]
client.fine_tuning.restart_job(job_id: str) -> Dict[str, Any]
client.fine_tuning.retrieve_job(job_id: str) -> FineTuningJob
client.fine_tuning.stats() -> FineTuningStats
client.fine_tuning.stop_job(job_id: str) -> Dict[str, Any]

Drift Detection

client.drift_detection.activate_baseline(baseline_id: str, *, model_id: str) -> Dict[str, Any]
client.drift_detection.active_baselines(model_id: str) -> Dict[str, Any]
client.drift_detection.alerts(model_id: str) -> Dict[str, Any]
client.drift_detection.analyze(*, model_id: str, window_days: Optional[int] = None, window_start: Optional[str] = None, window_end: Optional[str] = None) -> Dict[str, Any]
client.drift_detection.analyze_status(analysis_id: str) -> Dict[str, Any]
client.drift_detection.create_baseline(*, model_id: str, version: str, feature_data: Mapping[str, Sequence[Any]], labeled_predictions: Optional[Sequence[Mapping[str, Any]]] = None) -> Dict[str, Any]
client.drift_detection.latest_results(model_id: str) -> Dict[str, Any]
client.drift_detection.list_baselines(model_id: str) -> Dict[str, Any]
client.drift_detection.list_predictions(model_id: str, *, limit: Optional[int] = None, offset: Optional[int] = None, start_date: Optional[str] = None, end_date: Optional[str] = None, has_ground_truth: Optional[bool] = None) -> Dict[str, Any]
client.drift_detection.log_ground_truth(*, model_id: str, entity_id: str, actual_outcome: Any) -> Dict[str, Any]
client.drift_detection.log_ground_truth_batch(*, model_id: str, records: Sequence[Mapping[str, Any]]) -> Dict[str, Any]
client.drift_detection.log_prediction(*, model_id: str, features: Mapping[str, Any], prediction: Any, probabilities: Optional[Sequence[float]] = None, entity_id: Optional[str] = None) -> Dict[str, Any]
client.drift_detection.performance(model_id: str) -> Dict[str, Any]
client.drift_detection.results(model_id: str, *, limit: Optional[int] = None) -> Dict[str, Any]
client.drift_detection.unmatched_predictions(model_id: str, *, limit: Optional[int] = None) -> Dict[str, Any]
client.drift_detection.update_alerts(*, model_id: str, **thresholds: Any) -> Dict[str, Any]

A/B Tests

client.ab_tests.analyze_experiment(experiment_id: str) -> Dict[str, Any]
client.ab_tests.create(*, name: str, strategy: str, variants: Sequence[Mapping[str, Any]], description: Optional[str] = None, tags: Optional[Sequence[str]] = None, feature_rules: Optional[Sequence[Mapping[str, Any]]] = None, bandit_config: Optional[Mapping[str, Any]] = None, canary_config: Optional[Mapping[str, Any]] = None) -> ABTest
client.ab_tests.create_experiment(test_id: str, *, name: str, control_variant_id: str, treatment_variant_ids: Sequence[str], description: Optional[str] = None, hypothesis: Optional[str] = None, primary_metric: Optional[str] = None, confidence_level: Optional[float] = None, minimum_detectable_effect: Optional[float] = None, min_sample_per_variant: Optional[int] = None) -> Dict[str, Any]
client.ab_tests.delete(test_id: str) -> None
client.ab_tests.delete_experiment(experiment_id: str) -> None
client.ab_tests.deploy(test_id: str) -> Dict[str, Any]
client.ab_tests.list(*, status: Optional[str] = None, strategy: Optional[str] = None, workspace_id: Optional[str] = None) -> List[ABTest]
client.ab_tests.metrics(test_id: str, *, start_date: Optional[str] = None, end_date: Optional[str] = None) -> Dict[str, Any]
client.ab_tests.prediction_feedback(prediction_id: str, *, reward: Optional[float] = None, label: Optional[str] = None) -> Dict[str, Any]
client.ab_tests.predictions(test_id: str, *, limit: Optional[int] = None, offset: Optional[int] = None, variant_id: Optional[str] = None) -> Dict[str, Any]
client.ab_tests.retrieve(test_id: str) -> ABTest
client.ab_tests.set_variant_weight(test_id: str, variant_id: str, *, weight: float) -> Dict[str, Any]
client.ab_tests.start(test_id: str) -> Dict[str, Any]
client.ab_tests.start_experiment(experiment_id: str) -> Dict[str, Any]
client.ab_tests.stop(test_id: str) -> Dict[str, Any]
client.ab_tests.stop_experiment(experiment_id: str) -> Dict[str, Any]
client.ab_tests.toggle_variant(test_id: str, variant_id: str, *, enabled: bool) -> Dict[str, Any]
client.ab_tests.update(test_id: str, *, name: Optional[str] = None, description: Optional[str] = None, tags: Optional[Sequence[str]] = None, strategy: Optional[str] = None, status: Optional[str] = None) -> ABTest

Governance

client.governance.approve_gate_submission(submission_id: str, *, decision: str, comments: Optional[str] = None) -> Dict[str, Any]
client.governance.audit(**params) -> Dict[str, Any]
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) -> GovernancePolicy
client.governance.create_solution(*, name: str, description: Optional[str] = None, policy_ids: Optional[Sequence[str]] = None) -> GovernanceSolution
client.governance.delete_policy(policy_id: str) -> None
client.governance.delete_solution(solution_id: str) -> None
client.governance.enforcement_check(**params) -> Dict[str, Any]
client.governance.list_policies(*, category: Optional[str] = None, severity: Optional[str] = None, is_active: Optional[bool] = None, search: Optional[str] = None, limit: int = 50) -> SyncPaginator[GovernancePolicy]
client.governance.list_solutions(**params) -> SyncPaginator[GovernanceSolution]
client.governance.metrics() -> Dict[str, Any]
client.governance.pending_reviews(**params) -> Dict[str, Any]
client.governance.recompute_solution(solution_id: str) -> Dict[str, Any]
client.governance.resource_types() -> Dict[str, Any]
client.governance.retrieve_evidence(evidence_id: str) -> Dict[str, Any]
client.governance.retrieve_policy(policy_id: str) -> GovernancePolicy
client.governance.retrieve_solution(solution_id: str) -> GovernanceSolution
client.governance.solution_requirements(solution_id: str) -> Dict[str, Any]
client.governance.submit_gate(solution_id: str, gate_id: str, *, policy_id: str, data: Optional[Mapping[str, Any]] = None) -> Dict[str, Any]
client.governance.update_policy(policy_id: str, *, name: Optional[str] = None, description: Optional[str] = None, category: Optional[str] = None, severity: Optional[str] = None, applicable_resource_types: Optional[Sequence[str]] = None, stages: Optional[Sequence[Mapping[str, Any]]] = None, is_active: Optional[bool] = None, is_draft: Optional[bool] = None) -> GovernancePolicy
client.governance.update_solution(solution_id: str, *, name: Optional[str] = None, description: Optional[str] = None, status: Optional[str] = None) -> GovernanceSolution
client.governance.waive_gate_submission(submission_id: str, *, reason: str) -> Dict[str, Any]

FinOps Budgets

Budgets are read-only through the SDK. They are created and managed by administrators and by internal platform services.

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

FinOps Costs

client.finops.costs.anomalies(*, days: Optional[int] = None, threshold: Optional[float] = None) -> Dict[str, Any]
client.finops.costs.breakdown(**params) -> Dict[str, Any]
client.finops.costs.cost_top_drivers(**params) -> Dict[str, Any]
client.finops.costs.daily(*, start_date: Optional[str] = None, end_date: Optional[str] = None, resource_type: Optional[str] = None) -> Dict[str, Any]
client.finops.costs.dashboard() -> Dict[str, Any]
client.finops.costs.dashboard_stats(*, period: Optional[str] = None) -> Dict[str, Any]
client.finops.costs.data_health() -> Dict[str, Any]
client.finops.costs.efficiency(**params) -> Dict[str, Any]
client.finops.costs.forecast(*, months: Optional[int] = None, model: Optional[str] = None) -> Dict[str, Any]
client.finops.costs.historical(**params) -> Dict[str, Any]
client.finops.costs.monthly(*, months: Optional[int] = None, year: Optional[int] = None) -> Dict[str, Any]
client.finops.costs.realtime() -> Dict[str, Any]
client.finops.costs.savings(*, category: Optional[str] = None, min_savings: Optional[float] = None) -> Dict[str, Any]
client.finops.costs.services(*, period: Optional[str] = None, start_date: Optional[str] = None, end_date: Optional[str] = None) -> Dict[str, Any]
client.finops.costs.top_drivers(*, limit: Optional[int] = None, period: Optional[str] = None) -> Dict[str, Any]
client.finops.costs.trends(**params) -> Dict[str, Any]

FinOps Resource Groups

client.finops.resource_groups.add_resource(group_id: str, *, type: str, resource_id: str, name: str) -> Dict[str, Any]
client.finops.resource_groups.create(*, name: str, description: Optional[str] = None, tags: Optional[Mapping[str, str]] = None) -> ResourceGroup
client.finops.resource_groups.delete(group_id: str) -> None
client.finops.resource_groups.list(*, search: Optional[str] = None, status: Optional[str] = None, limit: int = 50) -> SyncPaginator[ResourceGroup]
client.finops.resource_groups.remove_resource(group_id: str, resource_id: str, *, type: str) -> Dict[str, Any]
client.finops.resource_groups.retrieve(group_id: str) -> ResourceGroup
client.finops.resource_groups.update(group_id: str, *, name: Optional[str] = None, description: Optional[str] = None, status: Optional[str] = None, tags: Optional[Mapping[str, str]] = None) -> ResourceGroup

FinOps Schedules

client.finops.schedules.create(*, name: str, scope: Mapping[str, Any], schedule: Mapping[str, Any], description: Optional[str] = None) -> Schedule
client.finops.schedules.delete(schedule_id: str) -> None
client.finops.schedules.execute(schedule_id: str, *, options: Optional[Mapping[str, Any]] = None) -> Dict[str, Any]
client.finops.schedules.history(schedule_id: str) -> Dict[str, Any]
client.finops.schedules.list(*, search: Optional[str] = None, status: Optional[str] = None, scope_level: Optional[str] = None, enabled: Optional[bool] = None, limit: int = 50) -> SyncPaginator[Schedule]
client.finops.schedules.pause(schedule_id: str) -> Schedule
client.finops.schedules.resume(schedule_id: str) -> Schedule
client.finops.schedules.retrieve(schedule_id: str) -> Schedule
client.finops.schedules.update(schedule_id: str, *, name: Optional[str] = None, scope: Optional[Mapping[str, Any]] = None, schedule: Optional[Mapping[str, Any]] = None, description: Optional[str] = None) -> Schedule

Users

client.users.api_keys() -> List[ApiKeyInfo]
client.users.archive(user_id: str) -> Dict[str, Any]
client.users.assets(user_id: str) -> Dict[str, Any]
client.users.create(*, email: str, name: str, role: Optional[str] = None, password: Optional[str] = None) -> User
client.users.create_api_key(*, name: str, scopes: Sequence[str], expires_in_days: Optional[int] = None) -> Dict[str, Any]
client.users.list(*, search: Optional[str] = None, archived: Optional[bool] = None, active: Optional[bool] = None, limit: int = 50) -> SyncPaginator[User]
client.users.me() -> User
client.users.reset_password(user_id: str) -> Dict[str, Any]
client.users.retrieve(user_id: str) -> User
client.users.revoke_api_key(key_id: str) -> Dict[str, Any]
client.users.unarchive(user_id: str) -> Dict[str, Any]
client.users.update(user_id: str, *, name: Optional[str] = None, role: Optional[str] = None, email: Optional[str] = None) -> User
client.users.update_me(*, name: Optional[str] = None, photo: Optional[str] = None, stan_personality: Optional[str] = None) -> User

Organizations

client.organizations.add_member(org_id: str, *, user_id: str, role: str = "member") -> Dict[str, Any]
client.organizations.cancel_invitation(org_id: str, invite_id: str) -> Dict[str, Any]
client.organizations.credits(org_id: str) -> OrganizationCredits
client.organizations.invite(org_id: str, *, email: str, role: str = "member") -> Dict[str, Any]
client.organizations.list() -> SyncPaginator[Organization]
client.organizations.list_invitations(org_id: str) -> List[Invitation]
client.organizations.members(org_id: str) -> List[Member]
client.organizations.remove_member(org_id: str, user_id: str) -> None
client.organizations.retrieve(org_id: str) -> Organization
client.organizations.transactions(org_id: str, *, limit: int = 50) -> List[CreditTransaction]
client.organizations.update(org_id: str, *, name: Optional[str] = None, description: Optional[str] = None, status: Optional[str] = None, plan: Optional[str] = None, settings: Optional[Mapping[str, Any]] = None) -> Organization
client.organizations.update_member_role(org_id: str, user_id: str, *, role: str) -> Dict[str, Any]

Marketplace

client.marketplace.available_addons(**params) -> Dict[str, Any]
client.marketplace.available_models(**params) -> Dict[str, Any]
client.marketplace.cancel_deployment(deployment_id: str) -> Dict[str, Any]
client.marketplace.clear_deployment_progress(deployment_id: str) -> Dict[str, Any]
client.marketplace.create_item(*, name: str, description: str, vendor: str, type: str, vertical: str, tags: Optional[Sequence[str]] = None, config: Optional[Mapping[str, Any]] = None) -> MarketplaceItem
client.marketplace.delete_item(item_id: str) -> None
client.marketplace.deploy(*, app_name: str, marketplace_item_id: str, terms_accepted: bool, config: Optional[Mapping[str, Any]] = None) -> Dict[str, Any]
client.marketplace.deployment_status(deployment_id: str) -> Dict[str, Any]
client.marketplace.item_deploy_config(item_id: str) -> Dict[str, Any]
client.marketplace.item_license(item_id: str) -> Dict[str, Any]
client.marketplace.list_deployments(**params) -> List[MarketplaceDeployment]
client.marketplace.list_items(*, search: Optional[str] = None, vertical: Optional[str] = None, type: Optional[str] = None, featured: Optional[bool] = None, limit: int = 50) -> SyncPaginator[MarketplaceItem]
client.marketplace.list_reviews(item_id: str, **params) -> List[MarketplaceReview]
client.marketplace.post_review(item_id: str, *, rating: float, title: str, comment: str) -> MarketplaceReview
client.marketplace.retrieve_deployment(deployment_id: str) -> MarketplaceDeployment
client.marketplace.retrieve_item(item_id: str) -> MarketplaceItem
client.marketplace.update_item(item_id: str, *, name: Optional[str] = None, description: Optional[str] = None, type: Optional[str] = None, vertical: Optional[str] = None, tags: Optional[Sequence[str]] = None, config: Optional[Mapping[str, Any]] = None, featured: Optional[bool] = None) -> MarketplaceItem
client.marketplace.verticals() -> Dict[str, Any]

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: Optional[List[str]] = None, filters: Optional[Dict[str, Any]] = None) -> Dict[str, Any]
client.data_forge.cancel_generation(generation_id: str) -> Dict[str, Any]
client.data_forge.create_project(*, name: str, description: Optional[str] = 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.export_dataset(project_id: str, *, format: str = "chatml", include_system_prompt: bool = True, min_quality_score: Optional[float] = None) -> DataForgeExport
client.data_forge.generation_logs(generation_id: str, *, tail: int = 200) -> Dict[str, Any]
client.data_forge.list_chunks(project_id: str, *, document_id: Optional[str] = None, page: int = 1, page_size: int = 50) -> Dict[str, Any]
client.data_forge.list_documents(project_id: str) -> List[DataForgeDocument]
client.data_forge.list_generations(project_id: str) -> List[DataForgeGeneration]
client.data_forge.list_pairs(project_id: str, *, status: Optional[str] = None, generation_id: Optional[str] = None, search: Optional[str] = None, page: int = 1, page_size: int = 50) -> Dict[str, Any]
client.data_forge.list_projects(*, status: Optional[str] = None, search: Optional[str] = None, limit: int = 50) -> 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, *, model_id: str, generation_type: str = "qa", temperature: float = 0.7, system_prompt: Optional[str] = None, num_pairs: Optional[int] = None, max_tokens: Optional[int] = None, chunk_ids: Optional[List[str]] = None, config: Optional[Dict[str, Any]] = None, **kwargs) -> DataForgeGeneration
client.data_forge.update_chunk(project_id: str, chunk_id: str, *, content: Optional[str] = None, **kwargs) -> Dict[str, Any]
client.data_forge.update_pair(pair_id: str, *, status: Optional[str] = None, question: Optional[str] = None, answer: Optional[str] = None, reviewer_notes: Optional[str] = None, **kwargs) -> Dict[str, Any]
client.data_forge.update_project(project_id: str, *, name: Optional[str] = None, description: Optional[str] = None, default_config: Optional[Mapping[str, Any]] = 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, *, workflow_name: Optional[str] = None, cpu: Optional[str] = None, memory: Optional[str] = None, disk: Optional[str] = None, gpu: Optional[int] = None, gpu_type: Optional[str] = None, idle_timeout_seconds: Optional[int] = None, max_session_duration_seconds: Optional[int] = None, max_concurrent_sessions: Optional[int] = None, strongly_services: Optional[Mapping[str, Any]] = None) -> StreamingDeployment
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_sessions(*, workflow_id: Optional[str] = None, status: Optional[str] = None, limit: Optional[int] = None, offset: Optional[int] = None, sort: Optional[str] = None) -> List[StreamingSession]
client.streaming.list_sessions_for_workflow(workflow_id: str, *, status: Optional[str] = None, limit: Optional[int] = None, offset: Optional[int] = None) -> List[StreamingSession]
client.streaming.list_workflows(*, search: Optional[str] = None, status: Optional[str] = None, limit: Optional[int] = None, offset: Optional[int] = None, sort: Optional[str] = None) -> List[StreamingWorkflow]
client.streaming.metrics(session_id: str) -> List[SessionMetricsWindow]
client.streaming.session(session_id: str) -> StreamingSession
client.streaming.start_session(workflow_id: str, *, metadata: Optional[Dict[str, Any]] = None, estimated_duration_seconds: Optional[int] = None, correlation_id: Optional[str] = None, disposition_schema_version: Optional[str] = None) -> SessionStartResult
client.streaming.transcript(session_id: str, *, limit: Optional[int] = None, offset: Optional[int] = None) -> List[TranscriptTurn]
client.streaming.undeploy(workflow_id: str) -> None
client.streaming.workflow(workflow_id: str) -> StreamingWorkflow

Notifications

client.notifications.list(*, unread_only: Optional[bool] = None, limit: Optional[int] = None) -> Dict[str, Any]
client.notifications.mark_all_read() -> Dict[str, Any]
client.notifications.mark_read(notification_id: str) -> Dict[str, Any]
client.notifications.unread_count() -> Dict[str, Any]

Dashboard

client.dashboard.summary() -> Dict[str, Any]

Analytics

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