Annotation queues

Reference for client.annotation_queues in the Future AGI Python and TypeScript SDKs: annotation_queues.add_label, annotation_queues.agreement, annotation_queues.analytics, annotation_queues.create, annotation_queues.delete, annotation_queues.export and 17 more.

client.annotation_queues on fi.Client (Python) and client.annotationQueues on Client from @future-agi/sdk (TypeScript), with the nested resources client.annotation_queues.items. The models these methods return are on Annotation response models; how arguments, pagination, errors and strict mode work is in the overview.

Methods

MethodDescription
annotation_queues.add_labelAdd an annotation label to a queue.
annotation_queues.agreementInter-annotator agreement for a queue.
annotation_queues.analyticsThroughput, annotator performance and label distribution for a queue.
annotation_queues.createCreate an annotation queue with its labels and annotators.
annotation_queues.deleteDelete an annotation queue.
annotation_queues.exportExport a queue’s annotations, as JSON or, with export_format=csv, as CSV text.
annotation_queues.export_to_datasetWrite a queue’s annotations into a new or existing dataset.
annotation_queues.getReturn an annotation queue by its identifier.
annotation_queues.listList annotation queues in the current workspace.
annotation_queues.progressItem counts by status and per-annotator progress for a queue.
annotation_queues.remove_labelRemove an annotation label from a queue.
annotation_queues.updateUpdate selected fields of an annotation queue.
annotation_queues.update_statusChange a queue’s status (draft, active, paused, completed, archived).
annotation_queues.items.addAdd items (spans, traces, dataset rows) to a queue, by id or by a selection filter.
annotation_queues.items.annotate_detailReturn everything needed to annotate one queue item; reserve=true acquires an editing reservation for the caller.
annotation_queues.items.assignAssign or unassign queue items to annotators.
annotation_queues.items.completeMark an annotated queue item complete and return the next item to work on.
annotation_queues.items.import_annotationsImport existing annotations onto a queue item, optionally on behalf of an annotator.
annotation_queues.items.listList items belonging to an annotation queue.
annotation_queues.items.list_annotationsList the annotations recorded on a queue item.
annotation_queues.items.removeRemove items from a queue.
annotation_queues.items.skipSkip a queue item and return the next one to work on.
annotation_queues.items.submitSubmit annotation values for an item in an annotation queue.

client.annotation_queues

annotation_queues.add_label

Add an annotation label to a queue.

POST /model-hub/annotation-queues/{id}/add-label/
result = client.annotation_queues.add_label("your-id", label_id="your-label-id")
const result = await client.annotationQueues.addLabel("your-id", { label_id: "your-label-id" });
Signature
client.annotation_queues.add_label(
    id: str,
    *,
    label_id: str,
    required: bool | None | NotGiven = NOT_GIVEN,
    extra_query: dict[str, Any] | None = None,
    extra_body: dict[str, Any] | None = None,
    options: RequestOptions | None = None,
) -> models.QueueAddLabelResult
client.annotationQueues.addLabel(id: string, params: AnnotationQueuesAddLabelParams, options?: RequestOptions): Promise<models.QueueAddLabelResult>

export interface AnnotationQueuesAddLabelParams {
  label_id: string;
  required?: boolean | null;
}

Parameters

id string Required

A UUID string identifying this annotation queue.

label_id string Required
required boolean Optional

Returns

QueueAddLabelResult.

annotation_queues.agreement

Inter-annotator agreement for a queue.

GET /model-hub/annotation-queues/{id}/agreement/
result = client.annotation_queues.agreement("your-id")
const result = await client.annotationQueues.agreement("your-id");
Signature
client.annotation_queues.agreement(
    id: str,
    *,
    extra_query: dict[str, Any] | None = None,
    options: RequestOptions | None = None,
) -> models.QueueAgreementResult
client.annotationQueues.agreement(id: string, options?: RequestOptions): Promise<models.QueueAgreementResult>

Parameters

id string Required

A UUID string identifying this annotation queue.

Returns

QueueAgreementResult.

annotation_queues.analytics

Throughput, annotator performance and label distribution for a queue.

GET /model-hub/annotation-queues/{id}/analytics/
result = client.annotation_queues.analytics("your-id")
const result = await client.annotationQueues.analytics("your-id");
Signature
client.annotation_queues.analytics(
    id: str,
    *,
    extra_query: dict[str, Any] | None = None,
    options: RequestOptions | None = None,
) -> models.QueueAnalyticsResult
client.annotationQueues.analytics(id: string, options?: RequestOptions): Promise<models.QueueAnalyticsResult>

Parameters

id string Required

A UUID string identifying this annotation queue.

Returns

QueueAnalyticsResult.

annotation_queues.create

Create an annotation queue with its labels and annotators.

POST /model-hub/annotation-queues/
result = client.annotation_queues.create(name="your-name", label_ids=[])
const result = await client.annotationQueues.create({
  name: "your-name",
  label_ids: [],
});
Signature
client.annotation_queues.create(
    *,
    name: str,
    label_ids: list[str],
    description: str | None | NotGiven = NOT_GIVEN,
    instructions: str | None | NotGiven = NOT_GIVEN,
    assignment_strategy: Literal['manual', 'round_robin', 'load_balanced'] | None | NotGiven = NOT_GIVEN,
    annotations_required: int | None | NotGiven = NOT_GIVEN,
    reservation_timeout_minutes: int | None | NotGiven = NOT_GIVEN,
    requires_review: bool | None | NotGiven = NOT_GIVEN,
    auto_assign: bool | None | NotGiven = NOT_GIVEN,
    annotator_ids: list[str] | None | NotGiven = NOT_GIVEN,
    annotator_roles: dict[str, Any] | None | NotGiven = NOT_GIVEN,
    extra_query: dict[str, Any] | None = None,
    extra_body: dict[str, Any] | None = None,
    options: RequestOptions | None = None,
) -> models.AnnotationQueue
client.annotationQueues.create(params: AnnotationQueuesCreateParams, options?: RequestOptions): Promise<models.AnnotationQueue>

export interface AnnotationQueuesCreateParams {
  name: string;
  label_ids: Array<string>;
  description?: string | null;
  instructions?: string | null;
  assignment_strategy?: "manual" | "round_robin" | "load_balanced" | null;
  annotations_required?: number | null;
  reservation_timeout_minutes?: number | null;
  requires_review?: boolean | null;
  auto_assign?: boolean | null;
  annotator_ids?: Array<string> | null;
  annotator_roles?: Record<string, unknown> | null;
}

Parameters

name string Required
label_ids string[] Required
description string Optional
instructions string Optional
assignment_strategy string Optional
Allowed values:
manualround_robinload_balanced
annotations_required integer Optional
reservation_timeout_minutes integer Optional
requires_review boolean Optional
auto_assign boolean Optional
annotator_ids string[] Optional
annotator_roles object Optional

Returns

AnnotationQueue.

annotation_queues.delete

Delete an annotation queue.

DELETE /model-hub/annotation-queues/{id}/
result = client.annotation_queues.delete("your-id")
const result = await client.annotationQueues.delete("your-id");
Signature
client.annotation_queues.delete(
    id: str,
    *,
    extra_query: dict[str, Any] | None = None,
    extra_body: dict[str, Any] | None = None,
    options: RequestOptions | None = None,
) -> Any
client.annotationQueues.delete(id: string, options?: RequestOptions): Promise<unknown>

Parameters

id string Required

A UUID string identifying this annotation queue.

Returns

The decoded response. The contract does not describe its shape, so it is untyped.

annotation_queues.export

Export a queue’s annotations, as JSON or, with export_format=csv, as CSV text.

GET /model-hub/annotation-queues/{id}/export/
result = client.annotation_queues.export("your-id")
const result = await client.annotationQueues.export("your-id");
Signature
client.annotation_queues.export(
    id: str,
    *,
    export_format: Literal['json', 'csv'] | None | NotGiven = NOT_GIVEN,
    status: str | None | NotGiven = NOT_GIVEN,
    extra_query: dict[str, Any] | None = None,
    options: RequestOptions | None = None,
) -> Any
client.annotationQueues.export(id: string, params: AnnotationQueuesExportParams = {}, options?: RequestOptions): Promise<unknown>

export interface AnnotationQueuesExportParams {
  export_format?: "json" | "csv" | null;
  status?: string | null;
}

Parameters

id string Required

A UUID string identifying this annotation queue.

export_format string Optional
Allowed values:
jsoncsv
status string Optional

Returns

The decoded JSON when the response is JSON, else the body as text.

annotation_queues.export_to_dataset

Write a queue’s annotations into a new or existing dataset.

POST /model-hub/annotation-queues/{id}/export-to-dataset/
result = client.annotation_queues.export_to_dataset("your-id")
const result = await client.annotationQueues.exportToDataset("your-id");
Signature
client.annotation_queues.export_to_dataset(
    id: str,
    *,
    dataset_id: str | None | NotGiven = NOT_GIVEN,
    dataset_name: str | None | NotGiven = NOT_GIVEN,
    status_filter: str | None | NotGiven = NOT_GIVEN,
    column_mapping: list[dict[str, Any]] | None | NotGiven = NOT_GIVEN,
    extra_query: dict[str, Any] | None = None,
    extra_body: dict[str, Any] | None = None,
    options: RequestOptions | None = None,
) -> models.QueueExportToDatasetResult
client.annotationQueues.exportToDataset(id: string, params: AnnotationQueuesExportToDatasetParams = {}, options?: RequestOptions): Promise<models.QueueExportToDatasetResult>

export interface AnnotationQueuesExportToDatasetParams {
  dataset_id?: string | null;
  dataset_name?: string | null;
  status_filter?: string | null;
  column_mapping?: Array<Record<string, unknown>> | null;
}

Parameters

id string Required

A UUID string identifying this annotation queue.

dataset_id string Optional
dataset_name string Optional
status_filter string Optional
column_mapping object[] Optional

Returns

QueueExportToDatasetResult.

annotation_queues.get

Return an annotation queue by its identifier.

GET /model-hub/annotation-queues/{id}/

MCP tool: get_annotation_queue

result = client.annotation_queues.get("your-id")
const result = await client.annotationQueues.get("your-id");
Signature
client.annotation_queues.get(
    id: str,
    *,
    extra_query: dict[str, Any] | None = None,
    options: RequestOptions | None = None,
) -> models.AnnotationQueue
client.annotationQueues.get(id: string, options?: RequestOptions): Promise<models.AnnotationQueue>

Parameters

id string Required

A UUID string identifying this annotation queue.

Returns

AnnotationQueue.

annotation_queues.list

List annotation queues in the current workspace.

GET /model-hub/annotation-queues/

Paginated: returns a pager (how pagination works) · MCP tool: list_annotation_queues

for item in client.annotation_queues.list():
    print(item)
for await (const item of client.annotationQueues.list()) {
  console.log(item);
}
Signature
client.annotation_queues.list(
    *,
    limit: int | None | NotGiven = NOT_GIVEN,
    status: str | None | NotGiven = NOT_GIVEN,
    search: str | None | NotGiven = NOT_GIVEN,
    include_counts: bool | None | NotGiven = NOT_GIVEN,
    archived: bool | None | NotGiven = NOT_GIVEN,
    page_size: int | None | NotGiven = NOT_GIVEN,
    extra_query: dict[str, Any] | None = None,
    options: RequestOptions | None = None,
) -> SyncPager[models.AnnotationQueue]
client.annotationQueues.list(params: AnnotationQueuesListParams = {}, options?: RequestOptions): Pager<models.AnnotationQueue>

export interface AnnotationQueuesListParams {
  /** Number of results to return per page. */
  limit?: number | null;
  status?: string | null;
  search?: string | null;
  include_counts?: boolean | null;
  archived?: boolean | null;
  page_size?: number | null;
}

Parameters

limit integer Optional

Number of results to return per page.

status string Optional
search string Optional
include_counts boolean Optional
archived boolean Optional
page_size integer Optional

The pager sends page itself; pass limit to change the page size.

Returns

A pager of AnnotationQueue items: iterate it, or call to_list() (Python) / toArray() (TypeScript).

annotation_queues.progress

Item counts by status and per-annotator progress for a queue.

GET /model-hub/annotation-queues/{id}/progress/
result = client.annotation_queues.progress("your-id")
const result = await client.annotationQueues.progress("your-id");
Signature
client.annotation_queues.progress(
    id: str,
    *,
    extra_query: dict[str, Any] | None = None,
    options: RequestOptions | None = None,
) -> models.QueueProgressResult
client.annotationQueues.progress(id: string, options?: RequestOptions): Promise<models.QueueProgressResult>

Parameters

id string Required

A UUID string identifying this annotation queue.

Returns

QueueProgressResult.

annotation_queues.remove_label

Remove an annotation label from a queue.

POST /model-hub/annotation-queues/{id}/remove-label/
result = client.annotation_queues.remove_label("your-id", label_id="your-label-id")
const result = await client.annotationQueues.removeLabel("your-id", { label_id: "your-label-id" });
Signature
client.annotation_queues.remove_label(
    id: str,
    *,
    label_id: str,
    required: bool | None | NotGiven = NOT_GIVEN,
    extra_query: dict[str, Any] | None = None,
    extra_body: dict[str, Any] | None = None,
    options: RequestOptions | None = None,
) -> models.QueueRemoveLabelResult
client.annotationQueues.removeLabel(id: string, params: AnnotationQueuesRemoveLabelParams, options?: RequestOptions): Promise<models.QueueRemoveLabelResult>

export interface AnnotationQueuesRemoveLabelParams {
  label_id: string;
  required?: boolean | null;
}

Parameters

id string Required

A UUID string identifying this annotation queue.

label_id string Required
required boolean Optional

Returns

QueueRemoveLabelResult.

annotation_queues.update

Update selected fields of an annotation queue.

PATCH /model-hub/annotation-queues/{id}/
result = client.annotation_queues.update("your-id")
const result = await client.annotationQueues.update("your-id");
Signature
client.annotation_queues.update(
    id: str,
    *,
    name: str | None | NotGiven = NOT_GIVEN,
    description: str | None | NotGiven = NOT_GIVEN,
    instructions: str | None | NotGiven = NOT_GIVEN,
    assignment_strategy: Literal['manual', 'round_robin', 'load_balanced'] | None | NotGiven = NOT_GIVEN,
    annotations_required: int | None | NotGiven = NOT_GIVEN,
    reservation_timeout_minutes: int | None | NotGiven = NOT_GIVEN,
    requires_review: bool | None | NotGiven = NOT_GIVEN,
    auto_assign: bool | None | NotGiven = NOT_GIVEN,
    label_ids: list[str] | None | NotGiven = NOT_GIVEN,
    annotator_ids: list[str] | None | NotGiven = NOT_GIVEN,
    annotator_roles: dict[str, Any] | None | NotGiven = NOT_GIVEN,
    extra_query: dict[str, Any] | None = None,
    extra_body: dict[str, Any] | None = None,
    options: RequestOptions | None = None,
) -> models.AnnotationQueue
client.annotationQueues.update(id: string, params: AnnotationQueuesUpdateParams = {}, options?: RequestOptions): Promise<models.AnnotationQueue>

export interface AnnotationQueuesUpdateParams {
  name?: string | null;
  description?: string | null;
  instructions?: string | null;
  assignment_strategy?: "manual" | "round_robin" | "load_balanced" | null;
  annotations_required?: number | null;
  reservation_timeout_minutes?: number | null;
  requires_review?: boolean | null;
  auto_assign?: boolean | null;
  label_ids?: Array<string> | null;
  annotator_ids?: Array<string> | null;
  annotator_roles?: Record<string, unknown> | null;
}

Parameters

id string Required

A UUID string identifying this annotation queue.

name string Optional
description string Optional
instructions string Optional
assignment_strategy string Optional
Allowed values:
manualround_robinload_balanced
annotations_required integer Optional
reservation_timeout_minutes integer Optional
requires_review boolean Optional
auto_assign boolean Optional
label_ids string[] Optional
annotator_ids string[] Optional
annotator_roles object Optional

Returns

AnnotationQueue.

annotation_queues.update_status

Change a queue’s status (draft, active, paused, completed, archived).

POST /model-hub/annotation-queues/{id}/update-status/
result = client.annotation_queues.update_status("your-id", status="draft")
const result = await client.annotationQueues.updateStatus("your-id", { status: "draft" });
Signature
client.annotation_queues.update_status(
    id: str,
    *,
    status: Literal['draft', 'active', 'paused', 'completed'],
    extra_query: dict[str, Any] | None = None,
    extra_body: dict[str, Any] | None = None,
    options: RequestOptions | None = None,
) -> models.AnnotationQueue
client.annotationQueues.updateStatus(id: string, params: AnnotationQueuesUpdateStatusParams, options?: RequestOptions): Promise<models.AnnotationQueue>

export interface AnnotationQueuesUpdateStatusParams {
  status: "draft" | "active" | "paused" | "completed";
}

Parameters

id string Required

A UUID string identifying this annotation queue.

status string Required
Allowed values:
draftactivepausedcompleted

Returns

AnnotationQueue.

client.annotation_queues.items

TypeScript: client.annotationQueues.items.

annotation_queues.items.add

Add items (spans, traces, dataset rows) to a queue, by id or by a selection filter.

POST /model-hub/annotation-queues/{queue_id}/items/add-items/
result = client.annotation_queues.items.add("your-queue-id")
const result = await client.annotationQueues.items.add("your-queue-id");
Signature
client.annotation_queues.items.add(
    queue_id: str,
    *,
    items: list[dict[str, Any]] | None | NotGiven = NOT_GIVEN,
    selection: dict[str, Any] | None | NotGiven = NOT_GIVEN,
    project_id: str | None | NotGiven = NOT_GIVEN,
    extra_query: dict[str, Any] | None = None,
    extra_body: dict[str, Any] | None = None,
    options: RequestOptions | None = None,
) -> models.QueueAddItemsResult
client.annotationQueues.items.add(queueId: string, params: AnnotationQueuesItemsAddParams = {}, options?: RequestOptions): Promise<models.QueueAddItemsResult>

export interface AnnotationQueuesItemsAddParams {
  items?: Array<Record<string, unknown>> | null;
  selection?: Record<string, unknown> | null;
  project_id?: string | null;
}

Parameters

queue_id string Required

Positional argument queue_id.

items object[] Optional
selection object Optional
project_id string Optional

Returns

QueueAddItemsResult.

annotation_queues.items.annotate_detail

Return everything needed to annotate one queue item; reserve=true acquires an editing reservation for the caller. Includes its source content, the queue instructions, every label with its settings (the allowed values a submitted value must match), any annotations already recorded, and the next/previous item ids. Call this before submit_annotation; the label settings are not available anywhere else.

GET /model-hub/annotation-queues/{queue_id}/items/{id}/annotate-detail/

MCP tool: get_annotation_item_detail

result = client.annotation_queues.items.annotate_detail("your-queue-id", "your-id")
const result = await client.annotationQueues.items.annotateDetail("your-queue-id", "your-id");
Signature
client.annotation_queues.items.annotate_detail(
    queue_id: str,
    id: str,
    *,
    annotator_id: str | None | NotGiven = NOT_GIVEN,
    include_completed: bool | None | NotGiven = NOT_GIVEN,
    view_mode: str | None | NotGiven = NOT_GIVEN,
    review_status: str | None | NotGiven = NOT_GIVEN,
    exclude_review_status: str | None | NotGiven = NOT_GIVEN,
    include_all_annotations: bool | None | NotGiven = NOT_GIVEN,
    reserve: bool | None | NotGiven = NOT_GIVEN,
    extra_query: dict[str, Any] | None = None,
    options: RequestOptions | None = None,
) -> models.QueueAnnotateDetailResult
client.annotationQueues.items.annotateDetail(queueId: string, id: string, params: AnnotationQueuesItemsAnnotateDetailParams = {}, options?: RequestOptions): Promise<models.QueueAnnotateDetailResult>

export interface AnnotationQueuesItemsAnnotateDetailParams {
  annotator_id?: string | null;
  include_completed?: boolean | null;
  view_mode?: string | null;
  review_status?: string | null;
  exclude_review_status?: string | null;
  include_all_annotations?: boolean | null;
  reserve?: boolean | null;
}

Parameters

queue_id string Required

Positional argument queue_id.

id string Required

A UUID string identifying this queue item.

annotator_id string Optional
include_completed boolean Optional
view_mode string Optional
review_status string Optional
exclude_review_status string Optional
include_all_annotations boolean Optional
reserve boolean Optional

Returns

QueueAnnotateDetailResult.

annotation_queues.items.assign

Assign or unassign queue items to annotators.

POST /model-hub/annotation-queues/{queue_id}/items/assign/
result = client.annotation_queues.items.assign("your-queue-id", item_ids=[])
const result = await client.annotationQueues.items.assign("your-queue-id", { item_ids: [] });
Signature
client.annotation_queues.items.assign(
    queue_id: str,
    *,
    item_ids: list[str],
    user_ids: list[str] | None | NotGiven = NOT_GIVEN,
    action: Literal['add', 'set', 'remove'] | None | NotGiven = NOT_GIVEN,
    extra_query: dict[str, Any] | None = None,
    extra_body: dict[str, Any] | None = None,
    options: RequestOptions | None = None,
) -> models.QueueAssignItemsResult
client.annotationQueues.items.assign(queueId: string, params: AnnotationQueuesItemsAssignParams, options?: RequestOptions): Promise<models.QueueAssignItemsResult>

export interface AnnotationQueuesItemsAssignParams {
  item_ids: Array<string>;
  user_ids?: Array<string> | null;
  action?: "add" | "set" | "remove" | null;
}

Parameters

queue_id string Required

Positional argument queue_id.

item_ids string[] Required
user_ids string[] Optional
action string Optional
Allowed values:
addsetremove

Returns

QueueAssignItemsResult.

annotation_queues.items.complete

Mark an annotated queue item complete and return the next item to work on. Required to finish an item - submit_annotation alone leaves it in_progress and the queue never closes.

POST /model-hub/annotation-queues/{queue_id}/items/{id}/complete/

MCP tool: complete_annotation_item

result = client.annotation_queues.items.complete("your-queue-id", "your-id")
const result = await client.annotationQueues.items.complete("your-queue-id", "your-id");
Signature
client.annotation_queues.items.complete(
    queue_id: str,
    id: str,
    *,
    exclude: list[str] | None | NotGiven = NOT_GIVEN,
    exclude_review_status: str | None | NotGiven = NOT_GIVEN,
    include_completed: bool | None | NotGiven = NOT_GIVEN,
    extra_query: dict[str, Any] | None = None,
    extra_body: dict[str, Any] | None = None,
    options: RequestOptions | None = None,
) -> models.QueueNavigationResult
client.annotationQueues.items.complete(queueId: string, id: string, params: AnnotationQueuesItemsCompleteParams = {}, options?: RequestOptions): Promise<models.QueueNavigationResult>

export interface AnnotationQueuesItemsCompleteParams {
  exclude?: Array<string> | null;
  exclude_review_status?: string | null;
  include_completed?: boolean | null;
}

Parameters

queue_id string Required

Positional argument queue_id.

id string Required

A UUID string identifying this queue item.

exclude string[] Optional
exclude_review_status string Optional
include_completed boolean Optional

Returns

QueueNavigationResult.

annotation_queues.items.import_annotations

Import existing annotations onto a queue item, optionally on behalf of an annotator.

POST /model-hub/annotation-queues/{queue_id}/items/{id}/annotations/import/
result = client.annotation_queues.items.import_annotations(
    "your-queue-id",
    "your-id",
    annotations=[],
)
const result = await client.annotationQueues.items.importAnnotations("your-queue-id", "your-id", { annotations: [] });
Signature
client.annotation_queues.items.import_annotations(
    queue_id: str,
    id: str,
    *,
    annotations: list[dict[str, Any]],
    annotator_id: str | None | NotGiven = NOT_GIVEN,
    extra_query: dict[str, Any] | None = None,
    extra_body: dict[str, Any] | None = None,
    options: RequestOptions | None = None,
) -> models.QueueImportAnnotationsResult
client.annotationQueues.items.importAnnotations(queueId: string, id: string, params: AnnotationQueuesItemsImportAnnotationsParams, options?: RequestOptions): Promise<models.QueueImportAnnotationsResult>

export interface AnnotationQueuesItemsImportAnnotationsParams {
  annotations: Array<Record<string, unknown>>;
  annotator_id?: string | null;
}

Parameters

queue_id string Required

Positional argument queue_id.

id string Required

A UUID string identifying this queue item.

annotations object[] Required
annotator_id string Optional

Returns

QueueImportAnnotationsResult.

annotation_queues.items.list

List items belonging to an annotation queue.

GET /model-hub/annotation-queues/{queue_id}/items/

Paginated: returns a pager (how pagination works) · MCP tool: list_annotation_queue_items

for item in client.annotation_queues.items.list("your-queue-id"):
    print(item)
for await (const item of client.annotationQueues.items.list("your-queue-id")) {
  console.log(item);
}
Signature
client.annotation_queues.items.list(
    queue_id: str,
    *,
    limit: int | None | NotGiven = NOT_GIVEN,
    status: list[str] | None | NotGiven = NOT_GIVEN,
    source_type: list[str] | None | NotGiven = NOT_GIVEN,
    assigned_to: str | None | NotGiven = NOT_GIVEN,
    review_status: str | None | NotGiven = NOT_GIVEN,
    ordering: Literal['created_at', '-created_at'] | None | NotGiven = NOT_GIVEN,
    extra_query: dict[str, Any] | None = None,
    options: RequestOptions | None = None,
) -> SyncPager[models.QueueItem]
client.annotationQueues.items.list(queueId: string, params: AnnotationQueuesItemsListParams = {}, options?: RequestOptions): Pager<models.QueueItem>

export interface AnnotationQueuesItemsListParams {
  /** Number of results to return per page. */
  limit?: number | null;
  status?: Array<string> | null;
  source_type?: Array<string> | null;
  assigned_to?: string | null;
  review_status?: string | null;
  ordering?: "created_at" | "-created_at" | null;
}

Parameters

queue_id string Required

Positional argument queue_id.

limit integer Optional

Number of results to return per page.

status string[] Optional
source_type string[] Optional
assigned_to string Optional
review_status string Optional
ordering string Optional
Allowed values:
created_at-created_at

The pager sends page itself; pass limit to change the page size.

Returns

A pager of QueueItem items: iterate it, or call to_list() (Python) / toArray() (TypeScript).

annotation_queues.items.list_annotations

List the annotations recorded on a queue item.

GET /model-hub/annotation-queues/{queue_id}/items/{id}/annotations/
result = client.annotation_queues.items.list_annotations("your-queue-id", "your-id")
const result = await client.annotationQueues.items.listAnnotations("your-queue-id", "your-id");
Signature
client.annotation_queues.items.list_annotations(
    queue_id: str,
    id: str,
    *,
    extra_query: dict[str, Any] | None = None,
    options: RequestOptions | None = None,
) -> List[models.Score]
client.annotationQueues.items.listAnnotations(queueId: string, id: string, options?: RequestOptions): Promise<Array<models.Score>>

Parameters

queue_id string Required

Positional argument queue_id.

id string Required

A UUID string identifying this queue item.

Returns

A list of Score.

annotation_queues.items.remove

Remove items from a queue.

POST /model-hub/annotation-queues/{queue_id}/items/bulk-remove/
result = client.annotation_queues.items.remove("your-queue-id", item_ids=[])
const result = await client.annotationQueues.items.remove("your-queue-id", { item_ids: [] });
Signature
client.annotation_queues.items.remove(
    queue_id: str,
    *,
    item_ids: list[str],
    extra_query: dict[str, Any] | None = None,
    extra_body: dict[str, Any] | None = None,
    options: RequestOptions | None = None,
) -> models.QueueBulkRemoveItemsResult
client.annotationQueues.items.remove(queueId: string, params: AnnotationQueuesItemsRemoveParams, options?: RequestOptions): Promise<models.QueueBulkRemoveItemsResult>

export interface AnnotationQueuesItemsRemoveParams {
  item_ids: Array<string>;
}

Parameters

queue_id string Required

Positional argument queue_id.

item_ids string[] Required

Returns

QueueBulkRemoveItemsResult.

annotation_queues.items.skip

Skip a queue item and return the next one to work on.

POST /model-hub/annotation-queues/{queue_id}/items/{id}/skip/
result = client.annotation_queues.items.skip("your-queue-id", "your-id")
const result = await client.annotationQueues.items.skip("your-queue-id", "your-id");
Signature
client.annotation_queues.items.skip(
    queue_id: str,
    id: str,
    *,
    exclude: list[str] | None | NotGiven = NOT_GIVEN,
    exclude_review_status: str | None | NotGiven = NOT_GIVEN,
    include_completed: bool | None | NotGiven = NOT_GIVEN,
    extra_query: dict[str, Any] | None = None,
    extra_body: dict[str, Any] | None = None,
    options: RequestOptions | None = None,
) -> models.QueueNavigationResult
client.annotationQueues.items.skip(queueId: string, id: string, params: AnnotationQueuesItemsSkipParams = {}, options?: RequestOptions): Promise<models.QueueNavigationResult>

export interface AnnotationQueuesItemsSkipParams {
  exclude?: Array<string> | null;
  exclude_review_status?: string | null;
  include_completed?: boolean | null;
}

Parameters

queue_id string Required

Positional argument queue_id.

id string Required

A UUID string identifying this queue item.

exclude string[] Optional
exclude_review_status string Optional
include_completed boolean Optional

Returns

QueueNavigationResult.

annotation_queues.items.submit

Submit annotation values for an item in an annotation queue. The value shape must match the label’s settings from get_annotation_item_detail. Submitting moves the item to in_progress only; call complete_annotation_item to finish it.

POST /model-hub/annotation-queues/{queue_id}/items/{id}/annotations/submit/

MCP tool: submit_annotation

result = client.annotation_queues.items.submit(
    "your-queue-id",
    "your-id",
    annotations=[],
)
const result = await client.annotationQueues.items.submit("your-queue-id", "your-id", { annotations: [] });
Signature
client.annotation_queues.items.submit(
    queue_id: str,
    id: str,
    *,
    annotations: list[dict[str, Any]],
    notes: str | None | NotGiven = NOT_GIVEN,
    item_notes: str | None | NotGiven = NOT_GIVEN,
    extra_query: dict[str, Any] | None = None,
    extra_body: dict[str, Any] | None = None,
    options: RequestOptions | None = None,
) -> models.QueueSubmitAnnotationsResult
client.annotationQueues.items.submit(queueId: string, id: string, params: AnnotationQueuesItemsSubmitParams, options?: RequestOptions): Promise<models.QueueSubmitAnnotationsResult>

export interface AnnotationQueuesItemsSubmitParams {
  annotations: Array<Record<string, unknown>>;
  notes?: string | null;
  item_notes?: string | null;
}

Parameters

queue_id string Required

Positional argument queue_id.

id string Required

A UUID string identifying this queue item.

annotations object[] Required
notes string Optional
item_notes string Optional

Returns

QueueSubmitAnnotationsResult.

Was this page helpful?

Questions & Discussion