Update

client/dist/generated/index.d.ts

@@ -0,0 +1,4 @@
+export * from './schemas.gen';
+export * from './services.gen';
+export * from './types.gen';
+//# sourceMappingURL=index.d.ts.map

client/dist/generated/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/generated/index.ts"],"names":[],"mappings":"AACA,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC"}

client/dist/generated/schemas.gen.d.ts

@@ -0,0 +1,176 @@
+export declare const CreateSessionRequestSchema: {
+    readonly properties: {
+        readonly session_id: {
+            readonly type: "string";
+            readonly title: "Session Id";
+        };
+        readonly policy_path: {
+            readonly type: "string";
+            readonly title: "Policy Path";
+        };
+        readonly camera_names: {
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly type: "array";
+            readonly title: "Camera Names";
+            readonly default: readonly ["front"];
+        };
+        readonly arena_server_url: {
+            readonly type: "string";
+            readonly title: "Arena Server Url";
+            readonly default: "http://localhost:8000";
+        };
+        readonly workspace_id: {
+            readonly anyOf: readonly [{
+                readonly type: "string";
+            }, {
+                readonly type: "null";
+            }];
+            readonly title: "Workspace Id";
+        };
+        readonly policy_type: {
+            readonly type: "string";
+            readonly title: "Policy Type";
+            readonly default: "act";
+        };
+        readonly language_instruction: {
+            readonly anyOf: readonly [{
+                readonly type: "string";
+            }, {
+                readonly type: "null";
+            }];
+            readonly title: "Language Instruction";
+        };
+    };
+    readonly type: "object";
+    readonly required: readonly ["session_id", "policy_path"];
+    readonly title: "CreateSessionRequest";
+};
+export declare const CreateSessionResponseSchema: {
+    readonly properties: {
+        readonly workspace_id: {
+            readonly type: "string";
+            readonly title: "Workspace Id";
+        };
+        readonly camera_room_ids: {
+            readonly additionalProperties: {
+                readonly type: "string";
+            };
+            readonly type: "object";
+            readonly title: "Camera Room Ids";
+        };
+        readonly joint_input_room_id: {
+            readonly type: "string";
+            readonly title: "Joint Input Room Id";
+        };
+        readonly joint_output_room_id: {
+            readonly type: "string";
+            readonly title: "Joint Output Room Id";
+        };
+    };
+    readonly type: "object";
+    readonly required: readonly ["workspace_id", "camera_room_ids", "joint_input_room_id", "joint_output_room_id"];
+    readonly title: "CreateSessionResponse";
+};
+export declare const HTTPValidationErrorSchema: {
+    readonly properties: {
+        readonly detail: {
+            readonly items: {
+                readonly $ref: "#/components/schemas/ValidationError";
+            };
+            readonly type: "array";
+            readonly title: "Detail";
+        };
+    };
+    readonly type: "object";
+    readonly title: "HTTPValidationError";
+};
+export declare const SessionStatusResponseSchema: {
+    readonly properties: {
+        readonly session_id: {
+            readonly type: "string";
+            readonly title: "Session Id";
+        };
+        readonly status: {
+            readonly type: "string";
+            readonly title: "Status";
+        };
+        readonly policy_path: {
+            readonly type: "string";
+            readonly title: "Policy Path";
+        };
+        readonly policy_type: {
+            readonly type: "string";
+            readonly title: "Policy Type";
+        };
+        readonly camera_names: {
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly type: "array";
+            readonly title: "Camera Names";
+        };
+        readonly workspace_id: {
+            readonly type: "string";
+            readonly title: "Workspace Id";
+        };
+        readonly rooms: {
+            readonly additionalProperties: true;
+            readonly type: "object";
+            readonly title: "Rooms";
+        };
+        readonly stats: {
+            readonly additionalProperties: true;
+            readonly type: "object";
+            readonly title: "Stats";
+        };
+        readonly inference_stats: {
+            readonly anyOf: readonly [{
+                readonly additionalProperties: true;
+                readonly type: "object";
+            }, {
+                readonly type: "null";
+            }];
+            readonly title: "Inference Stats";
+        };
+        readonly error_message: {
+            readonly anyOf: readonly [{
+                readonly type: "string";
+            }, {
+                readonly type: "null";
+            }];
+            readonly title: "Error Message";
+        };
+    };
+    readonly type: "object";
+    readonly required: readonly ["session_id", "status", "policy_path", "policy_type", "camera_names", "workspace_id", "rooms", "stats"];
+    readonly title: "SessionStatusResponse";
+};
+export declare const ValidationErrorSchema: {
+    readonly properties: {
+        readonly loc: {
+            readonly items: {
+                readonly anyOf: readonly [{
+                    readonly type: "string";
+                }, {
+                    readonly type: "integer";
+                }];
+            };
+            readonly type: "array";
+            readonly title: "Location";
+        };
+        readonly msg: {
+            readonly type: "string";
+            readonly title: "Message";
+        };
+        readonly type: {
+            readonly type: "string";
+            readonly title: "Error Type";
+        };
+    };
+    readonly type: "object";
+    readonly required: readonly ["loc", "msg", "type"];
+    readonly title: "ValidationError";
+};
+//# sourceMappingURL=schemas.gen.d.ts.map

client/dist/generated/schemas.gen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.gen.d.ts","sourceRoot":"","sources":["../../../../src/generated/schemas.gen.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsD7B,CAAC;AAEX,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;CAyB9B,CAAC;AAEX,eAAO,MAAM,yBAAyB;;;;;;;;;;;;CAY5B,CAAC;AAEX,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkE9B,CAAC;AAEX,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;CA4BxB,CAAC"}

client/dist/generated/services.gen.d.ts

@@ -0,0 +1,78 @@
+import { type Options } from '@hey-api/client-fetch';
+import type { ListSessionsSessionsGetResponse, CreateSessionSessionsPostData, GetSessionStatusSessionsSessionIdGetData, DeleteSessionSessionsSessionIdDeleteData, StartInferenceSessionsSessionIdStartPostData, StopInferenceSessionsSessionIdStopPostData, RestartInferenceSessionsSessionIdRestartPostData, DebugResetSessionDebugSessionsSessionIdResetPostData, GetSessionQueueInfoDebugSessionsSessionIdQueueGetData } from './types.gen';
+export declare const client: import("@hey-api/client-fetch").Client<Request, Response, import("@hey-api/client-fetch").RequestOptions>;
+/**
+ * Root
+ * Health check endpoint.
+ */
+export declare const rootGet: <ThrowOnError extends boolean = false>(options?: Options<unknown, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<unknown, unknown, ThrowOnError>;
+/**
+ * Health Check
+ * Detailed health check.
+ */
+export declare const healthCheckHealthGet: <ThrowOnError extends boolean = false>(options?: Options<unknown, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<unknown, unknown, ThrowOnError>;
+/**
+ * List Policies
+ * List supported policy types.
+ */
+export declare const listPoliciesPoliciesGet: <ThrowOnError extends boolean = false>(options?: Options<unknown, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<unknown, unknown, ThrowOnError>;
+/**
+ * List Sessions
+ * List all sessions.
+ */
+export declare const listSessionsSessionsGet: <ThrowOnError extends boolean = false>(options?: Options<unknown, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<ListSessionsSessionsGetResponse, unknown, ThrowOnError>;
+/**
+ * Create Session
+ * Create a new inference session.
+ *
+ * If workspace_id is provided, all rooms will be created in that workspace.
+ * If workspace_id is not provided, a new workspace will be generated automatically.
+ * All rooms for a session (cameras + joints) are always created in the same workspace.
+ */
+export declare const createSessionSessionsPost: <ThrowOnError extends boolean = false>(options: Options<CreateSessionSessionsPostData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").CreateSessionResponse, import("./types.gen").HTTPValidationError, ThrowOnError>;
+/**
+ * Get Session Status
+ * Get status of a specific session.
+ */
+export declare const getSessionStatusSessionsSessionIdGet: <ThrowOnError extends boolean = false>(options: Options<GetSessionStatusSessionsSessionIdGetData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").SessionStatusResponse, import("./types.gen").HTTPValidationError, ThrowOnError>;
+/**
+ * Delete Session
+ * Delete a session.
+ */
+export declare const deleteSessionSessionsSessionIdDelete: <ThrowOnError extends boolean = false>(options: Options<DeleteSessionSessionsSessionIdDeleteData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<unknown, import("./types.gen").HTTPValidationError, ThrowOnError>;
+/**
+ * Start Inference
+ * Start inference for a session.
+ */
+export declare const startInferenceSessionsSessionIdStartPost: <ThrowOnError extends boolean = false>(options: Options<StartInferenceSessionsSessionIdStartPostData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<unknown, import("./types.gen").HTTPValidationError, ThrowOnError>;
+/**
+ * Stop Inference
+ * Stop inference for a session.
+ */
+export declare const stopInferenceSessionsSessionIdStopPost: <ThrowOnError extends boolean = false>(options: Options<StopInferenceSessionsSessionIdStopPostData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<unknown, import("./types.gen").HTTPValidationError, ThrowOnError>;
+/**
+ * Restart Inference
+ * Restart inference for a session.
+ */
+export declare const restartInferenceSessionsSessionIdRestartPost: <ThrowOnError extends boolean = false>(options: Options<RestartInferenceSessionsSessionIdRestartPostData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<unknown, import("./types.gen").HTTPValidationError, ThrowOnError>;
+/**
+ * Get System Info
+ * Get system information for debugging.
+ */
+export declare const getSystemInfoDebugSystemGet: <ThrowOnError extends boolean = false>(options?: Options<unknown, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<unknown, unknown, ThrowOnError>;
+/**
+ * Get Recent Logs
+ * Get recent log entries for debugging.
+ */
+export declare const getRecentLogsDebugLogsGet: <ThrowOnError extends boolean = false>(options?: Options<unknown, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<unknown, unknown, ThrowOnError>;
+/**
+ * Debug Reset Session
+ * Reset a session's internal state for debugging.
+ */
+export declare const debugResetSessionDebugSessionsSessionIdResetPost: <ThrowOnError extends boolean = false>(options: Options<DebugResetSessionDebugSessionsSessionIdResetPostData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<unknown, import("./types.gen").HTTPValidationError, ThrowOnError>;
+/**
+ * Get Session Queue Info
+ * Get detailed information about a session's action queue.
+ */
+export declare const getSessionQueueInfoDebugSessionsSessionIdQueueGet: <ThrowOnError extends boolean = false>(options: Options<GetSessionQueueInfoDebugSessionsSessionIdQueueGetData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<unknown, import("./types.gen").HTTPValidationError, ThrowOnError>;
+//# sourceMappingURL=services.gen.d.ts.map

client/dist/generated/services.gen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"services.gen.d.ts","sourceRoot":"","sources":["../../../../src/generated/services.gen.ts"],"names":[],"mappings":"AAEA,OAAO,EAA8B,KAAK,OAAO,EAAE,MAAM,uBAAuB,CAAC;AACjF,OAAO,KAAK,EAAuL,+BAA+B,EAAE,6BAA6B,EAAqE,wCAAwC,EAA2F,wCAAwC,EAA2F,4CAA4C,EAAmG,0CAA0C,EAA+F,gDAAgD,EAAqP,oDAAoD,EAAmH,qDAAqD,EAAqH,MAAM,aAAa,CAAC;AAE9+C,eAAO,MAAM,MAAM,2GAA+B,CAAC;AAEnD;;;GAGG;AACH,eAAO,MAAM,OAAO,GAAI,YAAY,SAAS,OAAO,GAAG,KAAK,EAAE,UAAU,OAAO,CAAC,OAAO,EAAE,YAAY,CAAC,kFAKrG,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,oBAAoB,GAAI,YAAY,SAAS,OAAO,GAAG,KAAK,EAAE,UAAU,OAAO,CAAC,OAAO,EAAE,YAAY,CAAC,kFAKlH,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,uBAAuB,GAAI,YAAY,SAAS,OAAO,GAAG,KAAK,EAAE,UAAU,OAAO,CAAC,OAAO,EAAE,YAAY,CAAC,kFAKrH,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,uBAAuB,GAAI,YAAY,SAAS,OAAO,GAAG,KAAK,EAAE,UAAU,OAAO,CAAC,OAAO,EAAE,YAAY,CAAC,0GAKrH,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB,GAAI,YAAY,SAAS,OAAO,GAAG,KAAK,EAAE,SAAS,OAAO,CAAC,6BAA6B,EAAE,YAAY,CAAC,wJAK5I,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,oCAAoC,GAAI,YAAY,SAAS,OAAO,GAAG,KAAK,EAAE,SAAS,OAAO,CAAC,wCAAwC,EAAE,YAAY,CAAC,wJAKlK,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,oCAAoC,GAAI,YAAY,SAAS,OAAO,GAAG,KAAK,EAAE,SAAS,OAAO,CAAC,wCAAwC,EAAE,YAAY,CAAC,oHAKlK,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,wCAAwC,GAAI,YAAY,SAAS,OAAO,GAAG,KAAK,EAAE,SAAS,OAAO,CAAC,4CAA4C,EAAE,YAAY,CAAC,oHAK1K,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,sCAAsC,GAAI,YAAY,SAAS,OAAO,GAAG,KAAK,EAAE,SAAS,OAAO,CAAC,0CAA0C,EAAE,YAAY,CAAC,oHAKtK,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,4CAA4C,GAAI,YAAY,SAAS,OAAO,GAAG,KAAK,EAAE,SAAS,OAAO,CAAC,gDAAgD,EAAE,YAAY,CAAC,oHAKlL,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,2BAA2B,GAAI,YAAY,SAAS,OAAO,GAAG,KAAK,EAAE,UAAU,OAAO,CAAC,OAAO,EAAE,YAAY,CAAC,kFAKzH,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,yBAAyB,GAAI,YAAY,SAAS,OAAO,GAAG,KAAK,EAAE,UAAU,OAAO,CAAC,OAAO,EAAE,YAAY,CAAC,kFAKvH,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,gDAAgD,GAAI,YAAY,SAAS,OAAO,GAAG,KAAK,EAAE,SAAS,OAAO,CAAC,oDAAoD,EAAE,YAAY,CAAC,oHAK1L,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,iDAAiD,GAAI,YAAY,SAAS,OAAO,GAAG,KAAK,EAAE,SAAS,OAAO,CAAC,qDAAqD,EAAE,YAAY,CAAC,oHAK5L,CAAC"}

client/dist/generated/types.gen.d.ts

@@ -0,0 +1,110 @@
+export type CreateSessionRequest = {
+    session_id: string;
+    policy_path: string;
+    camera_names?: Array<(string)>;
+    arena_server_url?: string;
+    workspace_id?: (string | null);
+    policy_type?: string;
+    language_instruction?: (string | null);
+};
+export type CreateSessionResponse = {
+    workspace_id: string;
+    camera_room_ids: {
+        [key: string]: (string);
+    };
+    joint_input_room_id: string;
+    joint_output_room_id: string;
+};
+export type HTTPValidationError = {
+    detail?: Array<ValidationError>;
+};
+export type SessionStatusResponse = {
+    session_id: string;
+    status: string;
+    policy_path: string;
+    policy_type: string;
+    camera_names: Array<(string)>;
+    workspace_id: string;
+    rooms: {
+        [key: string]: unknown;
+    };
+    stats: {
+        [key: string]: unknown;
+    };
+    inference_stats?: ({
+        [key: string]: unknown;
+    } | null);
+    error_message?: (string | null);
+};
+export type ValidationError = {
+    loc: Array<(string | number)>;
+    msg: string;
+    type: string;
+};
+export type RootGetResponse = (unknown);
+export type RootGetError = unknown;
+export type HealthCheckHealthGetResponse = (unknown);
+export type HealthCheckHealthGetError = unknown;
+export type ListPoliciesPoliciesGetResponse = (unknown);
+export type ListPoliciesPoliciesGetError = unknown;
+export type ListSessionsSessionsGetResponse = (Array<SessionStatusResponse>);
+export type ListSessionsSessionsGetError = unknown;
+export type CreateSessionSessionsPostData = {
+    body: CreateSessionRequest;
+};
+export type CreateSessionSessionsPostResponse = (CreateSessionResponse);
+export type CreateSessionSessionsPostError = (HTTPValidationError);
+export type GetSessionStatusSessionsSessionIdGetData = {
+    path: {
+        session_id: string;
+    };
+};
+export type GetSessionStatusSessionsSessionIdGetResponse = (SessionStatusResponse);
+export type GetSessionStatusSessionsSessionIdGetError = (HTTPValidationError);
+export type DeleteSessionSessionsSessionIdDeleteData = {
+    path: {
+        session_id: string;
+    };
+};
+export type DeleteSessionSessionsSessionIdDeleteResponse = (unknown);
+export type DeleteSessionSessionsSessionIdDeleteError = (HTTPValidationError);
+export type StartInferenceSessionsSessionIdStartPostData = {
+    path: {
+        session_id: string;
+    };
+};
+export type StartInferenceSessionsSessionIdStartPostResponse = (unknown);
+export type StartInferenceSessionsSessionIdStartPostError = (HTTPValidationError);
+export type StopInferenceSessionsSessionIdStopPostData = {
+    path: {
+        session_id: string;
+    };
+};
+export type StopInferenceSessionsSessionIdStopPostResponse = (unknown);
+export type StopInferenceSessionsSessionIdStopPostError = (HTTPValidationError);
+export type RestartInferenceSessionsSessionIdRestartPostData = {
+    path: {
+        session_id: string;
+    };
+};
+export type RestartInferenceSessionsSessionIdRestartPostResponse = (unknown);
+export type RestartInferenceSessionsSessionIdRestartPostError = (HTTPValidationError);
+export type GetSystemInfoDebugSystemGetResponse = (unknown);
+export type GetSystemInfoDebugSystemGetError = unknown;
+export type GetRecentLogsDebugLogsGetResponse = (unknown);
+export type GetRecentLogsDebugLogsGetError = unknown;
+export type DebugResetSessionDebugSessionsSessionIdResetPostData = {
+    path: {
+        session_id: string;
+    };
+};
+export type DebugResetSessionDebugSessionsSessionIdResetPostResponse = (unknown);
+export type DebugResetSessionDebugSessionsSessionIdResetPostError = (HTTPValidationError);
+export type GetSessionQueueInfoDebugSessionsSessionIdQueueGetData = {
+    path: {
+        session_id: string;
+    };
+};
+export type GetSessionQueueInfoDebugSessionsSessionIdQueueGetResponse = (unknown);
+export type GetSessionQueueInfoDebugSessionsSessionIdQueueGetError = (HTTPValidationError);
+//# sourceMappingURL=types.gen.d.ts.map

client/dist/generated/types.gen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.gen.d.ts","sourceRoot":"","sources":["../../../../src/generated/types.gen.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,oBAAoB,GAAG;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;IAC/B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,YAAY,CAAC,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,oBAAoB,CAAC,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;CAC1C,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAChC,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE;QACb,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,MAAM,CAAC,CAAC;KAC3B,CAAC;IACF,mBAAmB,EAAE,MAAM,CAAC;IAC5B,oBAAoB,EAAE,MAAM,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAC9B,MAAM,CAAC,EAAE,KAAK,CAAC,eAAe,CAAC,CAAC;CACnC,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAChC,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE;QACH,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KAC1B,CAAC;IACF,KAAK,EAAE;QACH,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KAC1B,CAAC;IACF,eAAe,CAAC,EAAE,CAAC;QACnB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KAC1B,GAAG,IAAI,CAAC,CAAC;IACN,aAAa,CAAC,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;CACnC,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC1B,GAAG,EAAE,KAAK,CAAC,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,CAAC,CAAC;AAExC,MAAM,MAAM,YAAY,GAAG,OAAO,CAAC;AAEnC,MAAM,MAAM,4BAA4B,GAAG,CAAC,OAAO,CAAC,CAAC;AAErD,MAAM,MAAM,yBAAyB,GAAG,OAAO,CAAC;AAEhD,MAAM,MAAM,+BAA+B,GAAG,CAAC,OAAO,CAAC,CAAC;AAExD,MAAM,MAAM,4BAA4B,GAAG,OAAO,CAAC;AAEnD,MAAM,MAAM,+BAA+B,GAAG,CAAC,KAAK,CAAC,qBAAqB,CAAC,CAAC,CAAC;AAE7E,MAAM,MAAM,4BAA4B,GAAG,OAAO,CAAC;AAEnD,MAAM,MAAM,6BAA6B,GAAG;IACxC,IAAI,EAAE,oBAAoB,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,iCAAiC,GAAG,CAAC,qBAAqB,CAAC,CAAC;AAExE,MAAM,MAAM,8BAA8B,GAAG,CAAC,mBAAmB,CAAC,CAAC;AAEnE,MAAM,MAAM,wCAAwC,GAAG;IACnD,IAAI,EAAE;QACF,UAAU,EAAE,MAAM,CAAC;KACtB,CAAC;CACL,CAAC;AAEF,MAAM,MAAM,4CAA4C,GAAG,CAAC,qBAAqB,CAAC,CAAC;AAEnF,MAAM,MAAM,yCAAyC,GAAG,CAAC,mBAAmB,CAAC,CAAC;AAE9E,MAAM,MAAM,wCAAwC,GAAG;IACnD,IAAI,EAAE;QACF,UAAU,EAAE,MAAM,CAAC;KACtB,CAAC;CACL,CAAC;AAEF,MAAM,MAAM,4CAA4C,GAAG,CAAC,OAAO,CAAC,CAAC;AAErE,MAAM,MAAM,yCAAyC,GAAG,CAAC,mBAAmB,CAAC,CAAC;AAE9E,MAAM,MAAM,4CAA4C,GAAG;IACvD,IAAI,EAAE;QACF,UAAU,EAAE,MAAM,CAAC;KACtB,CAAC;CACL,CAAC;AAEF,MAAM,MAAM,gDAAgD,GAAG,CAAC,OAAO,CAAC,CAAC;AAEzE,MAAM,MAAM,6CAA6C,GAAG,CAAC,mBAAmB,CAAC,CAAC;AAElF,MAAM,MAAM,0CAA0C,GAAG;IACrD,IAAI,EAAE;QACF,UAAU,EAAE,MAAM,CAAC;KACtB,CAAC;CACL,CAAC;AAEF,MAAM,MAAM,8CAA8C,GAAG,CAAC,OAAO,CAAC,CAAC;AAEvE,MAAM,MAAM,2CAA2C,GAAG,CAAC,mBAAmB,CAAC,CAAC;AAEhF,MAAM,MAAM,gDAAgD,GAAG;IAC3D,IAAI,EAAE;QACF,UAAU,EAAE,MAAM,CAAC;KACtB,CAAC;CACL,CAAC;AAEF,MAAM,MAAM,oDAAoD,GAAG,CAAC,OAAO,CAAC,CAAC;AAE7E,MAAM,MAAM,iDAAiD,GAAG,CAAC,mBAAmB,CAAC,CAAC;AAEtF,MAAM,MAAM,mCAAmC,GAAG,CAAC,OAAO,CAAC,CAAC;AAE5D,MAAM,MAAM,gCAAgC,GAAG,OAAO,CAAC;AAEvD,MAAM,MAAM,iCAAiC,GAAG,CAAC,OAAO,CAAC,CAAC;AAE1D,MAAM,MAAM,8BAA8B,GAAG,OAAO,CAAC;AAErD,MAAM,MAAM,oDAAoD,GAAG;IAC/D,IAAI,EAAE;QACF,UAAU,EAAE,MAAM,CAAC;KACtB,CAAC;CACL,CAAC;AAEF,MAAM,MAAM,wDAAwD,GAAG,CAAC,OAAO,CAAC,CAAC;AAEjF,MAAM,MAAM,qDAAqD,GAAG,CAAC,mBAAmB,CAAC,CAAC;AAE1F,MAAM,MAAM,qDAAqD,GAAG;IAChE,IAAI,EAAE;QACF,UAAU,EAAE,MAAM,CAAC;KACtB,CAAC;CACL,CAAC;AAEF,MAAM,MAAM,yDAAyD,GAAG,CAAC,OAAO,CAAC,CAAC;AAElF,MAAM,MAAM,sDAAsD,GAAG,CAAC,mBAAmB,CAAC,CAAC"}

client/dist/index.d.ts

@@ -0,0 +1,102 @@
+/**
+ * LeRobot Arena Inference Server TypeScript Client
+ *
+ * This client provides TypeScript access to the LeRobot Arena Inference Server
+ * for ACT (Action Chunking Transformer) model inference and session management.
+ *
+ * @example Basic Usage
+ * ```typescript
+ * import { LeRobotInferenceServerClient, CreateSessionRequest } from '@lerobot-arena/inference-server-client';
+ *
+ * const client = new LeRobotInferenceServerClient('http://localhost:8001');
+ *
+ * // Create and start a session
+ * const sessionRequest: CreateSessionRequest = {
+ *   session_id: 'my-robot-01',
+ *   policy_path: './checkpoints/act_so101_beyond',
+ *   camera_names: ['front', 'wrist'],
+ *   arena_server_url: 'http://localhost:8000'
+ * };
+ *
+ * const session = await client.createSession(sessionRequest);
+ * await client.startInference('my-robot-01');
+ *
+ * // Monitor session
+ * const status = await client.getSessionStatus('my-robot-01');
+ * console.log(`Session status: ${status.status}`);
+ * ```
+ */
+export * from './generated';
+import type { CreateSessionRequest, CreateSessionResponse, SessionStatusResponse } from './generated';
+/**
+ * LeRobot Arena Inference Server Client
+ *
+ * A convenience wrapper around the generated OpenAPI client that provides
+ * a simpler interface for common operations while maintaining full type safety.
+ */
+export declare class LeRobotInferenceServerClient {
+    private baseUrl;
+    constructor(baseUrl: string);
+    /**
+     * Check if the inference server is healthy and responding
+     */
+    isHealthy(): Promise<boolean>;
+    /**
+     * Get detailed server health information
+     */
+    getHealth(): Promise<unknown>;
+    /**
+     * Create a new inference session
+     */
+    createSession(request: CreateSessionRequest): Promise<CreateSessionResponse>;
+    /**
+     * List all active sessions
+     */
+    listSessions(): Promise<SessionStatusResponse[]>;
+    /**
+     * Get detailed status of a specific session
+     */
+    getSessionStatus(sessionId: string): Promise<SessionStatusResponse>;
+    /**
+     * Start inference for a session
+     */
+    startInference(sessionId: string): Promise<void>;
+    /**
+     * Stop inference for a session
+     */
+    stopInference(sessionId: string): Promise<void>;
+    /**
+     * Restart inference for a session
+     */
+    restartInference(sessionId: string): Promise<void>;
+    /**
+     * Delete a session and clean up all resources
+     */
+    deleteSession(sessionId: string): Promise<void>;
+    /**
+     * Wait for a session to reach a specific status
+     */
+    waitForSessionStatus(sessionId: string, targetStatus: string, timeoutMs?: number): Promise<SessionStatusResponse>;
+    /**
+     * Convenience method to create a session and start inference in one call
+     */
+    createAndStartSession(request: CreateSessionRequest): Promise<{
+        session: CreateSessionResponse;
+        status: SessionStatusResponse;
+    }>;
+    /**
+     * Get system information for debugging
+     */
+    getSystemInfo(): Promise<unknown>;
+    /**
+     * Reset a session's internal state (debug method)
+     */
+    debugResetSession(sessionId: string): Promise<void>;
+    /**
+     * Get detailed information about a session's action queue
+     */
+    getSessionQueueInfo(sessionId: string): Promise<unknown>;
+}
+export declare function createClient(baseUrl: string): LeRobotInferenceServerClient;
+export declare const LeRobotAIServerClient: typeof LeRobotInferenceServerClient;
+//# sourceMappingURL=index.d.ts.map

client/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAGH,cAAc,aAAa,CAAC;AAkB5B,OAAO,KAAK,EACV,oBAAoB,EACpB,qBAAqB,EACrB,qBAAqB,EACtB,MAAM,aAAa,CAAC;AAErB;;;;;GAKG;AACH,qBAAa,4BAA4B;IACvC,OAAO,CAAC,OAAO,CAAS;gBAEZ,OAAO,EAAE,MAAM;IAM3B;;OAEG;IACG,SAAS,IAAI,OAAO,CAAC,OAAO,CAAC;IASnC;;OAEG;IACG,SAAS;IAQf;;OAEG;IACG,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAYlF;;OAEG;IACG,YAAY,IAAI,OAAO,CAAC,qBAAqB,EAAE,CAAC;IAQtD;;OAEG;IACG,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAYzE;;OAEG;IACG,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAUtD;;OAEG;IACG,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAUrD;;OAEG;IACG,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAUxD;;OAEG;IACG,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAUrD;;OAEG;IACG,oBAAoB,CACxB,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,SAAS,GAAE,MAAc,GACxB,OAAO,CAAC,qBAAqB,CAAC;IAgBjC;;OAEG;IACG,qBAAqB,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC;QAClE,OAAO,EAAE,qBAAqB,CAAC;QAC/B,MAAM,EAAE,qBAAqB,CAAC;KAC/B,CAAC;IAUF;;OAEG;IACG,aAAa;IAQnB;;OAEG;IACG,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAUzD;;OAEG;IACG,mBAAmB,CAAC,SAAS,EAAE,MAAM;CAU5C;AAGD,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,4BAA4B,CAE1E;AAGD,eAAO,MAAM,qBAAqB,qCAA+B,CAAC"}

client/dist/index.js

@@ -1,1621 +1,614 @@
 // @bun
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
+// src/generated/schemas.gen.ts
+var CreateSessionRequestSchema = {
+  properties: {
+    session_id: {
+      type: "string",
+      title: "Session Id"
+    },
+    policy_path: {
+      type: "string",
+      title: "Policy Path"
+    },
+    camera_names: {
+      items: {
+        type: "string"
+      },
+      type: "array",
+      title: "Camera Names",
+      default: ["front"]
+    },
+    arena_server_url: {
+      type: "string",
+      title: "Arena Server Url",
+      default: "http://localhost:8000"
+    },
+    workspace_id: {
+      anyOf: [
+        {
+          type: "string"
+        },
+        {
+          type: "null"
+        }
+      ],
+      title: "Workspace Id"
+    },
+    policy_type: {
+      type: "string",
+      title: "Policy Type",
+      default: "act"
+    },
+    language_instruction: {
+      anyOf: [
+        {
+          type: "string"
+        },
+        {
+          type: "null"
+        }
+      ],
+      title: "Language Instruction"
+    }
+  },
+  type: "object",
+  required: ["session_id", "policy_path"],
+  title: "CreateSessionRequest"
 };
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
+var CreateSessionResponseSchema = {
+  properties: {
+    workspace_id: {
+      type: "string",
+      title: "Workspace Id"
+    },
+    camera_room_ids: {
+      additionalProperties: {
+        type: "string"
+      },
+      type: "object",
+      title: "Camera Room Ids"
+    },
+    joint_input_room_id: {
+      type: "string",
+      title: "Joint Input Room Id"
+    },
+    joint_output_room_id: {
+      type: "string",
+      title: "Joint Output Room Id"
+    }
+  },
+  type: "object",
+  required: ["workspace_id", "camera_room_ids", "joint_input_room_id", "joint_output_room_id"],
+  title: "CreateSessionResponse"
 };
-
-// ../../../../node_modules/eventemitter3/index.js
-var require_eventemitter3 = __commonJS((exports, module) => {
-  var has = Object.prototype.hasOwnProperty;
-  var prefix = "~";
-  function Events() {}
-  if (Object.create) {
-    Events.prototype = Object.create(null);
-    if (!new Events().__proto__)
-      prefix = false;
-  }
-  function EE(fn, context, once) {
-    this.fn = fn;
-    this.context = context;
-    this.once = once || false;
-  }
-  function addListener(emitter, event, fn, context, once) {
-    if (typeof fn !== "function") {
-      throw new TypeError("The listener must be a function");
-    }
-    var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
-    if (!emitter._events[evt])
-      emitter._events[evt] = listener, emitter._eventsCount++;
-    else if (!emitter._events[evt].fn)
-      emitter._events[evt].push(listener);
-    else
-      emitter._events[evt] = [emitter._events[evt], listener];
-    return emitter;
-  }
-  function clearEvent(emitter, evt) {
-    if (--emitter._eventsCount === 0)
-      emitter._events = new Events;
-    else
-      delete emitter._events[evt];
-  }
-  function EventEmitter() {
-    this._events = new Events;
-    this._eventsCount = 0;
-  }
-  EventEmitter.prototype.eventNames = function eventNames() {
-    var names = [], events, name;
-    if (this._eventsCount === 0)
-      return names;
-    for (name in events = this._events) {
-      if (has.call(events, name))
-        names.push(prefix ? name.slice(1) : name);
-    }
-    if (Object.getOwnPropertySymbols) {
-      return names.concat(Object.getOwnPropertySymbols(events));
-    }
-    return names;
-  };
-  EventEmitter.prototype.listeners = function listeners(event) {
-    var evt = prefix ? prefix + event : event, handlers = this._events[evt];
-    if (!handlers)
-      return [];
-    if (handlers.fn)
-      return [handlers.fn];
-    for (var i = 0, l = handlers.length, ee = new Array(l);i < l; i++) {
-      ee[i] = handlers[i].fn;
+var HTTPValidationErrorSchema = {
+  properties: {
+    detail: {
+      items: {
+        $ref: "#/components/schemas/ValidationError"
+      },
+      type: "array",
+      title: "Detail"
     }
-    return ee;
-  };
-  EventEmitter.prototype.listenerCount = function listenerCount(event) {
-    var evt = prefix ? prefix + event : event, listeners = this._events[evt];
-    if (!listeners)
-      return 0;
-    if (listeners.fn)
-      return 1;
-    return listeners.length;
-  };
-  EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
-    var evt = prefix ? prefix + event : event;
-    if (!this._events[evt])
-      return false;
-    var listeners = this._events[evt], len = arguments.length, args, i;
-    if (listeners.fn) {
-      if (listeners.once)
-        this.removeListener(event, listeners.fn, undefined, true);
-      switch (len) {
-        case 1:
-          return listeners.fn.call(listeners.context), true;
-        case 2:
-          return listeners.fn.call(listeners.context, a1), true;
-        case 3:
-          return listeners.fn.call(listeners.context, a1, a2), true;
-        case 4:
-          return listeners.fn.call(listeners.context, a1, a2, a3), true;
-        case 5:
-          return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
-        case 6:
-          return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
-      }
-      for (i = 1, args = new Array(len - 1);i < len; i++) {
-        args[i - 1] = arguments[i];
-      }
-      listeners.fn.apply(listeners.context, args);
-    } else {
-      var length = listeners.length, j;
-      for (i = 0;i < length; i++) {
-        if (listeners[i].once)
-          this.removeListener(event, listeners[i].fn, undefined, true);
-        switch (len) {
-          case 1:
-            listeners[i].fn.call(listeners[i].context);
-            break;
-          case 2:
-            listeners[i].fn.call(listeners[i].context, a1);
-            break;
-          case 3:
-            listeners[i].fn.call(listeners[i].context, a1, a2);
-            break;
-          case 4:
-            listeners[i].fn.call(listeners[i].context, a1, a2, a3);
-            break;
-          default:
-            if (!args)
-              for (j = 1, args = new Array(len - 1);j < len; j++) {
-                args[j - 1] = arguments[j];
-              }
-            listeners[i].fn.apply(listeners[i].context, args);
+  },
+  type: "object",
+  title: "HTTPValidationError"
+};
+var SessionStatusResponseSchema = {
+  properties: {
+    session_id: {
+      type: "string",
+      title: "Session Id"
+    },
+    status: {
+      type: "string",
+      title: "Status"
+    },
+    policy_path: {
+      type: "string",
+      title: "Policy Path"
+    },
+    policy_type: {
+      type: "string",
+      title: "Policy Type"
+    },
+    camera_names: {
+      items: {
+        type: "string"
+      },
+      type: "array",
+      title: "Camera Names"
+    },
+    workspace_id: {
+      type: "string",
+      title: "Workspace Id"
+    },
+    rooms: {
+      additionalProperties: true,
+      type: "object",
+      title: "Rooms"
+    },
+    stats: {
+      additionalProperties: true,
+      type: "object",
+      title: "Stats"
+    },
+    inference_stats: {
+      anyOf: [
+        {
+          additionalProperties: true,
+          type: "object"
+        },
+        {
+          type: "null"
         }
-      }
-    }
-    return true;
-  };
-  EventEmitter.prototype.on = function on(event, fn, context) {
-    return addListener(this, event, fn, context, false);
-  };
-  EventEmitter.prototype.once = function once(event, fn, context) {
-    return addListener(this, event, fn, context, true);
-  };
-  EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
-    var evt = prefix ? prefix + event : event;
-    if (!this._events[evt])
-      return this;
-    if (!fn) {
-      clearEvent(this, evt);
-      return this;
-    }
-    var listeners = this._events[evt];
-    if (listeners.fn) {
-      if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
-        clearEvent(this, evt);
-      }
-    } else {
-      for (var i = 0, events = [], length = listeners.length;i < length; i++) {
-        if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
-          events.push(listeners[i]);
+      ],
+      title: "Inference Stats"
+    },
+    error_message: {
+      anyOf: [
+        {
+          type: "string"
+        },
+        {
+          type: "null"
         }
-      }
-      if (events.length)
-        this._events[evt] = events.length === 1 ? events[0] : events;
-      else
-        clearEvent(this, evt);
-    }
-    return this;
-  };
-  EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
-    var evt;
-    if (event) {
-      evt = prefix ? prefix + event : event;
-      if (this._events[evt])
-        clearEvent(this, evt);
-    } else {
-      this._events = new Events;
-      this._eventsCount = 0;
+      ],
+      title: "Error Message"
     }
-    return this;
-  };
-  EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
-  EventEmitter.prototype.addListener = EventEmitter.prototype.on;
-  EventEmitter.prefixed = prefix;
-  EventEmitter.EventEmitter = EventEmitter;
-  if (typeof module !== "undefined") {
-    module.exports = EventEmitter;
-  }
-});
-
-// src/robotics/index.ts
-var exports_robotics = {};
-__export(exports_robotics, {
-  createProducerClient: () => createProducerClient,
-  createConsumerClient: () => createConsumerClient,
-  createClient: () => createClient,
-  RoboticsProducer: () => RoboticsProducer,
-  RoboticsConsumer: () => RoboticsConsumer,
-  RoboticsClientCore: () => RoboticsClientCore
-});
-
-// ../../../../node_modules/eventemitter3/index.mjs
-var import__ = __toESM(require_eventemitter3(), 1);
-
-// src/robotics/core.ts
-class RoboticsClientCore extends import__.default {
-  baseUrl;
-  apiBase;
-  websocket = null;
-  workspaceId = null;
-  roomId = null;
-  role = null;
-  participantId = null;
-  connected = false;
-  options;
-  onErrorCallback = null;
-  onConnectedCallback = null;
-  onDisconnectedCallback = null;
-  constructor(baseUrl = "http://localhost:8000", options = {}) {
-    super();
-    this.baseUrl = baseUrl.replace(/\/$/, "");
-    this.apiBase = `${this.baseUrl}/robotics`;
-    this.options = {
-      timeout: 5000,
-      reconnect_attempts: 3,
-      heartbeat_interval: 30000,
-      ...options
-    };
-  }
-  async listRooms(workspaceId) {
-    const response = await this.fetchApi(`/workspaces/${workspaceId}/rooms`);
-    return response.rooms;
-  }
-  async createRoom(workspaceId, roomId) {
-    const finalWorkspaceId = workspaceId || this.generateWorkspaceId();
-    const payload = roomId ? { room_id: roomId, workspace_id: finalWorkspaceId } : { workspace_id: finalWorkspaceId };
-    const response = await this.fetchApi(`/workspaces/${finalWorkspaceId}/rooms`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(payload)
-    });
-    return { workspaceId: response.workspace_id, roomId: response.room_id };
-  }
-  async deleteRoom(workspaceId, roomId) {
-    try {
-      const response = await this.fetchApi(`/workspaces/${workspaceId}/rooms/${roomId}`, {
-        method: "DELETE"
-      });
-      return response.success;
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("404")) {
-        return false;
-      }
-      throw error;
-    }
-  }
-  async getRoomState(workspaceId, roomId) {
-    const response = await this.fetchApi(`/workspaces/${workspaceId}/rooms/${roomId}/state`);
-    return response.state;
-  }
-  async getRoomInfo(workspaceId, roomId) {
-    const response = await this.fetchApi(`/workspaces/${workspaceId}/rooms/${roomId}`);
-    return response.room;
-  }
-  async connectToRoom(workspaceId, roomId, role, participantId) {
-    if (this.connected) {
-      await this.disconnect();
-    }
-    this.workspaceId = workspaceId;
-    this.roomId = roomId;
-    this.role = role;
-    this.participantId = participantId || `${role}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-    const wsUrl = this.baseUrl.replace(/^http/, "ws").replace(/^https/, "wss");
-    const wsEndpoint = `${wsUrl}/robotics/workspaces/${workspaceId}/rooms/${roomId}/ws`;
-    try {
-      this.websocket = new WebSocket(wsEndpoint);
-      return new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
-          reject(new Error("Connection timeout"));
-        }, this.options.timeout || 5000);
-        this.websocket.onopen = () => {
-          clearTimeout(timeout);
-          this.sendJoinMessage();
-        };
-        this.websocket.onmessage = (event) => {
-          try {
-            const message = JSON.parse(event.data);
-            this.handleMessage(message);
-            if (message.type === "joined") {
-              this.connected = true;
-              this.onConnectedCallback?.();
-              this.emit("connected");
-              resolve(true);
-            } else if (message.type === "error") {
-              this.handleError(message.message);
-              resolve(false);
-            }
-          } catch (error) {
-            console.error("Failed to parse WebSocket message:", error);
+  },
+  type: "object",
+  required: ["session_id", "status", "policy_path", "policy_type", "camera_names", "workspace_id", "rooms", "stats"],
+  title: "SessionStatusResponse"
+};
+var ValidationErrorSchema = {
+  properties: {
+    loc: {
+      items: {
+        anyOf: [
+          {
+            type: "string"
+          },
+          {
+            type: "integer"
           }
-        };
-        this.websocket.onerror = (error) => {
-          clearTimeout(timeout);
-          console.error("WebSocket error:", error);
-          this.handleError("WebSocket connection error");
-          reject(error);
-        };
-        this.websocket.onclose = () => {
-          clearTimeout(timeout);
-          this.connected = false;
-          this.onDisconnectedCallback?.();
-          this.emit("disconnected");
-        };
-      });
-    } catch (error) {
-      console.error("Failed to connect to room:", error);
-      return false;
-    }
-  }
-  async disconnect() {
-    if (this.websocket && this.websocket.readyState === WebSocket.OPEN) {
-      this.websocket.close();
-    }
-    this.websocket = null;
-    this.connected = false;
-    this.workspaceId = null;
-    this.roomId = null;
-    this.role = null;
-    this.participantId = null;
-    this.onDisconnectedCallback?.();
-    this.emit("disconnected");
-  }
-  sendJoinMessage() {
-    if (!this.websocket || !this.participantId || !this.role)
-      return;
-    const joinMessage = {
-      participant_id: this.participantId,
-      role: this.role
-    };
-    this.websocket.send(JSON.stringify(joinMessage));
-  }
-  handleMessage(message) {
-    switch (message.type) {
-      case "joined":
-        console.log(`Successfully joined room ${message.room_id} as ${message.role}`);
-        break;
-      case "heartbeat_ack":
-        console.debug("Heartbeat acknowledged");
-        break;
-      case "error":
-        this.handleError(message.message);
-        break;
+        ]
+      },
+      type: "array",
+      title: "Location"
+    },
+    msg: {
+      type: "string",
+      title: "Message"
+    },
+    type: {
+      type: "string",
+      title: "Error Type"
+    }
+  },
+  type: "object",
+  required: ["loc", "msg", "type"],
+  title: "ValidationError"
+};
+// node_modules/@hey-api/client-fetch/dist/node/index.mjs
+var e = /\{[^{}]+\}/g;
+var t = ({ allowReserved: e2, name: t2, value: r }) => {
+  if (r == null)
+    return "";
+  if (typeof r == "object")
+    throw new Error("Deeply-nested arrays/objects aren\u2019t supported. Provide your own `querySerializer()` to handle these.");
+  return `${t2}=${e2 ? r : encodeURIComponent(r)}`;
+};
+var r = ({ allowReserved: e2, explode: r2, name: s, style: a, value: n }) => {
+  if (!r2) {
+    const t2 = (e2 ? n : n.map((e3) => encodeURIComponent(e3))).join(((e3) => {
+      switch (e3) {
+        case "form":
+        default:
+          return ",";
+        case "pipeDelimited":
+          return "|";
+        case "spaceDelimited":
+          return "%20";
+      }
+    })(a));
+    switch (a) {
+      case "label":
+        return `.${t2}`;
+      case "matrix":
+        return `;${s}=${t2}`;
+      case "simple":
+        return t2;
       default:
-        this.handleRoleSpecificMessage(message);
+        return `${s}=${t2}`;
     }
   }
-  handleRoleSpecificMessage(message) {
-    this.emit("message", message);
-  }
-  handleError(errorMessage) {
-    console.error("Client error:", errorMessage);
-    this.onErrorCallback?.(errorMessage);
-    this.emit("error", errorMessage);
-  }
-  async sendHeartbeat() {
-    if (!this.connected || !this.websocket)
-      return;
-    const message = { type: "heartbeat" };
-    this.websocket.send(JSON.stringify(message));
-  }
-  isConnected() {
-    return this.connected;
-  }
-  getConnectionInfo() {
-    return {
-      connected: this.connected,
-      workspace_id: this.workspaceId,
-      room_id: this.roomId,
-      role: this.role,
-      participant_id: this.participantId,
-      base_url: this.baseUrl
-    };
-  }
-  onError(callback) {
-    this.onErrorCallback = callback;
-  }
-  onConnected(callback) {
-    this.onConnectedCallback = callback;
-  }
-  onDisconnected(callback) {
-    this.onDisconnectedCallback = callback;
-  }
-  async fetchApi(endpoint, options = {}) {
-    const url = `${this.apiBase}${endpoint}`;
-    const response = await fetch(url, {
-      ...options,
-      signal: AbortSignal.timeout(this.options.timeout || 5000)
-    });
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+  const o = ((e3) => {
+    switch (e3) {
+      case "label":
+        return ".";
+      case "matrix":
+        return ";";
+      case "simple":
+        return ",";
+      default:
+        return "&";
     }
-    return response.json();
-  }
-  generateWorkspaceId() {
-    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
-      const r = Math.random() * 16 | 0;
-      const v = c === "x" ? r : r & 3 | 8;
-      return v.toString(16);
+  })(a), l = n.map((r3) => a === "label" || a === "simple" ? e2 ? r3 : encodeURIComponent(r3) : t({ allowReserved: e2, name: s, value: r3 })).join(o);
+  return a === "label" || a === "matrix" ? o + l : l;
+};
+var s = ({ allowReserved: e2, explode: r2, name: s2, style: a, value: n }) => {
+  if (n instanceof Date)
+    return `${s2}=${n.toISOString()}`;
+  if (a !== "deepObject" && !r2) {
+    let t2 = [];
+    Object.entries(n).forEach(([r4, s3]) => {
+      t2 = [...t2, r4, e2 ? s3 : encodeURIComponent(s3)];
     });
-  }
-}
-// src/robotics/producer.ts
-class RoboticsProducer extends RoboticsClientCore {
-  constructor(baseUrl = "http://localhost:8000", options = {}) {
-    super(baseUrl, options);
-  }
-  async connect(workspaceId, roomId, participantId) {
-    return this.connectToRoom(workspaceId, roomId, "producer", participantId);
-  }
-  async sendJointUpdate(joints) {
-    if (!this.connected || !this.websocket) {
-      throw new Error("Must be connected to send joint updates");
-    }
-    const message = {
-      type: "joint_update",
-      data: joints,
-      timestamp: new Date().toISOString()
-    };
-    this.websocket.send(JSON.stringify(message));
-  }
-  async sendStateSync(state) {
-    if (!this.connected || !this.websocket) {
-      throw new Error("Must be connected to send state sync");
-    }
-    const joints = Object.entries(state).map(([name, value]) => ({
-      name,
-      value
-    }));
-    await this.sendJointUpdate(joints);
-  }
-  async sendEmergencyStop(reason = "Emergency stop") {
-    if (!this.connected || !this.websocket) {
-      throw new Error("Must be connected to send emergency stop");
-    }
-    const message = {
-      type: "emergency_stop",
-      reason,
-      timestamp: new Date().toISOString()
-    };
-    this.websocket.send(JSON.stringify(message));
-  }
-  handleRoleSpecificMessage(message) {
-    switch (message.type) {
-      case "emergency_stop":
-        console.warn(`\uD83D\uDEA8 Emergency stop: ${message.reason || "Unknown reason"}`);
-        this.handleError(`Emergency stop: ${message.reason || "Unknown reason"}`);
-        break;
-      case "error":
-        console.error(`Server error: ${message.message}`);
-        this.handleError(message.message);
-        break;
+    const r3 = t2.join(",");
+    switch (a) {
+      case "form":
+        return `${s2}=${r3}`;
+      case "label":
+        return `.${r3}`;
+      case "matrix":
+        return `;${s2}=${r3}`;
       default:
-        console.warn(`Unknown message type for producer: ${message.type}`);
-    }
-  }
-  static async createAndConnect(baseUrl = "http://localhost:8000", workspaceId, roomId, participantId) {
-    const producer = new RoboticsProducer(baseUrl);
-    const roomData = await producer.createRoom(workspaceId, roomId);
-    const connected = await producer.connect(roomData.workspaceId, roomData.roomId, participantId);
-    if (!connected) {
-      throw new Error("Failed to connect as producer");
-    }
-    return producer;
-  }
-  get currentRoomId() {
-    return this.roomId;
-  }
-}
-// src/robotics/consumer.ts
-class RoboticsConsumer extends RoboticsClientCore {
-  onStateSyncCallback = null;
-  onJointUpdateCallback = null;
-  constructor(baseUrl = "http://localhost:8000", options = {}) {
-    super(baseUrl, options);
-  }
-  async connect(workspaceId, roomId, participantId) {
-    return this.connectToRoom(workspaceId, roomId, "consumer", participantId);
-  }
-  async getStateSyncAsync() {
-    if (!this.workspaceId || !this.roomId) {
-      throw new Error("Must be connected to a room");
+        return r3;
     }
-    const state = await this.getRoomState(this.workspaceId, this.roomId);
-    return state.joints;
-  }
-  onStateSync(callback) {
-    this.onStateSyncCallback = callback;
-  }
-  onJointUpdate(callback) {
-    this.onJointUpdateCallback = callback;
   }
-  handleRoleSpecificMessage(message) {
-    switch (message.type) {
-      case "state_sync":
-        this.handleStateSync(message);
-        break;
-      case "joint_update":
-        this.handleJointUpdate(message);
-        break;
-      case "emergency_stop":
-        console.warn(`\uD83D\uDEA8 Emergency stop: ${message.reason || "Unknown reason"}`);
-        this.handleError(`Emergency stop: ${message.reason || "Unknown reason"}`);
-        break;
-      case "error":
-        console.error(`Server error: ${message.message}`);
-        this.handleError(message.message);
-        break;
+  const o = ((e3) => {
+    switch (e3) {
+      case "label":
+        return ".";
+      case "matrix":
+        return ";";
+      case "simple":
+        return ",";
       default:
-        console.warn(`Unknown message type for consumer: ${message.type}`);
+        return "&";
     }
+  })(a), l = Object.entries(n).map(([r3, n2]) => t({ allowReserved: e2, name: a === "deepObject" ? `${s2}[${r3}]` : r3, value: n2 })).join(o);
+  return a === "label" || a === "matrix" ? o + l : l;
+};
+var a = ({ allowReserved: e2, array: a2, object: n } = {}) => (o) => {
+  let l = [];
+  if (o && typeof o == "object")
+    for (const i in o) {
+      const c = o[i];
+      c != null && (l = Array.isArray(c) ? [...l, r({ allowReserved: e2, explode: true, name: i, style: "form", value: c, ...a2 })] : typeof c != "object" ? [...l, t({ allowReserved: e2, name: i, value: c })] : [...l, s({ allowReserved: e2, explode: true, name: i, style: "deepObject", value: c, ...n })]);
+    }
+  return l.join("&");
+};
+var n = ({ baseUrl: a2, path: n2, query: o, querySerializer: l, url: i }) => {
+  let c = a2 + (i.startsWith("/") ? i : `/${i}`);
+  n2 && (c = (({ path: a3, url: n3 }) => {
+    let o2 = n3;
+    const l2 = n3.match(e);
+    if (l2)
+      for (const e2 of l2) {
+        let n4 = false, l3 = e2.substring(1, e2.length - 1), i2 = "simple";
+        l3.endsWith("*") && (n4 = true, l3 = l3.substring(0, l3.length - 1)), l3.startsWith(".") ? (l3 = l3.substring(1), i2 = "label") : l3.startsWith(";") && (l3 = l3.substring(1), i2 = "matrix");
+        const c2 = a3[l3];
+        c2 != null && (o2 = Array.isArray(c2) ? o2.replace(e2, r({ explode: n4, name: l3, style: i2, value: c2 })) : typeof c2 != "object" ? i2 !== "matrix" ? o2.replace(e2, i2 === "label" ? `.${c2}` : c2) : o2.replace(e2, `;${t({ name: l3, value: c2 })}`) : o2.replace(e2, s({ explode: n4, name: l3, style: i2, value: c2 })));
+      }
+    return o2;
+  })({ path: n2, url: c }));
+  let u = o ? l(o) : "";
+  return u.startsWith("?") && (u = u.substring(1)), u && (c += `?${u}`), c;
+};
+var o = (e2, t2) => {
+  const r2 = { ...e2, ...t2 };
+  return r2.baseUrl?.endsWith("/") && (r2.baseUrl = r2.baseUrl.substring(0, r2.baseUrl.length - 1)), r2.headers = l(e2.headers, t2.headers), r2;
+};
+var l = (...e2) => {
+  const t2 = new Headers;
+  for (const r2 of e2) {
+    if (!r2 || typeof r2 != "object")
+      continue;
+    const e3 = r2 instanceof Headers ? r2.entries() : Object.entries(r2);
+    for (const [r3, s2] of e3)
+      if (s2 === null)
+        t2.delete(r3);
+      else if (Array.isArray(s2))
+        for (const e4 of s2)
+          t2.append(r3, e4);
+      else
+        s2 !== undefined && t2.set(r3, typeof s2 == "object" ? JSON.stringify(s2) : s2);
   }
-  handleStateSync(message) {
-    if (this.onStateSyncCallback) {
-      this.onStateSyncCallback(message.data);
-    }
-    this.emit("stateSync", message.data);
-  }
-  handleJointUpdate(message) {
-    if (this.onJointUpdateCallback) {
-      this.onJointUpdateCallback(message.data);
-    }
-    this.emit("jointUpdate", message.data);
-  }
-  static async createAndConnect(workspaceId, roomId, baseUrl = "http://localhost:8000", participantId) {
-    const consumer = new RoboticsConsumer(baseUrl);
-    const connected = await consumer.connect(workspaceId, roomId, participantId);
-    if (!connected) {
-      throw new Error("Failed to connect as consumer");
-    }
-    return consumer;
-  }
-}
-// src/robotics/factory.ts
-function createClient(role, baseUrl = "http://localhost:8000", options = {}) {
-  if (role === "producer") {
-    return new RoboticsProducer(baseUrl, options);
-  }
-  if (role === "consumer") {
-    return new RoboticsConsumer(baseUrl, options);
+  return t2;
+};
+
+class i {
+  _fns;
+  constructor() {
+    this._fns = [];
   }
-  throw new Error(`Invalid role: ${role}. Must be 'producer' or 'consumer'`);
-}
-async function createProducerClient(baseUrl = "http://localhost:8000", workspaceId, roomId, participantId, options = {}) {
-  const producer = new RoboticsProducer(baseUrl, options);
-  const roomData = await producer.createRoom(workspaceId, roomId);
-  const connected = await producer.connect(roomData.workspaceId, roomData.roomId, participantId);
-  if (!connected) {
-    throw new Error("Failed to connect as producer");
+  eject(e2) {
+    const t2 = this._fns.indexOf(e2);
+    t2 !== -1 && (this._fns = [...this._fns.slice(0, t2), ...this._fns.slice(t2 + 1)]);
   }
-  return producer;
-}
-async function createConsumerClient(workspaceId, roomId, baseUrl = "http://localhost:8000", participantId, options = {}) {
-  const consumer = new RoboticsConsumer(baseUrl, options);
-  const connected = await consumer.connect(workspaceId, roomId, participantId);
-  if (!connected) {
-    throw new Error("Failed to connect as consumer");
+  use(e2) {
+    this._fns = [...this._fns, e2];
   }
-  return consumer;
 }
-// src/video/index.ts
-var exports_video = {};
-__export(exports_video, {
-  createProducerClient: () => createProducerClient2,
-  createConsumerClient: () => createConsumerClient2,
-  createClient: () => createClient2,
-  VideoProducer: () => VideoProducer,
-  VideoConsumer: () => VideoConsumer,
-  VideoClientCore: () => VideoClientCore
-});
+var d = { bodySerializer: (e2) => JSON.stringify(e2) };
+var h = a({ allowReserved: false, array: { explode: true, style: "form" }, object: { explode: true, style: "deepObject" } });
+var y = { "Content-Type": "application/json" };
+var m = (e2 = {}) => ({ ...d, baseUrl: "", fetch: globalThis.fetch, headers: y, parseAs: "auto", querySerializer: h, ...e2 });
+var b = (e2 = {}) => {
+  let t2 = o(m(), e2);
+  const r2 = () => ({ ...t2 }), s2 = { request: new i, response: new i }, c = async (e3) => {
+    const r3 = { ...t2, ...e3, headers: l(t2.headers, e3.headers) };
+    r3.body && r3.bodySerializer && (r3.body = r3.bodySerializer(r3.body)), r3.body || r3.headers.delete("Content-Type");
+    const o2 = n({ baseUrl: r3.baseUrl ?? "", path: r3.path, query: r3.query, querySerializer: typeof r3.querySerializer == "function" ? r3.querySerializer : a(r3.querySerializer), url: r3.url }), i2 = { redirect: "follow", ...r3 };
+    let c2 = new Request(o2, i2);
+    for (const e4 of s2.request._fns)
+      c2 = await e4(c2, r3);
+    const u = r3.fetch;
+    let d2 = await u(c2);
+    for (const e4 of s2.response._fns)
+      d2 = await e4(d2, c2, r3);
+    const p = { request: c2, response: d2 };
+    if (d2.ok) {
+      if (d2.status === 204 || d2.headers.get("Content-Length") === "0")
+        return { data: {}, ...p };
+      if (r3.parseAs === "stream")
+        return { data: d2.body, ...p };
+      const e4 = (r3.parseAs === "auto" ? ((e5) => {
+        if (e5)
+          return e5.startsWith("application/json") || e5.endsWith("+json") ? "json" : e5 === "multipart/form-data" ? "formData" : ["application/", "audio/", "image/", "video/"].some((t4) => e5.startsWith(t4)) ? "blob" : e5.startsWith("text/") ? "text" : undefined;
+      })(d2.headers.get("Content-Type")) : r3.parseAs) ?? "json";
+      let t3 = await d2[e4]();
+      return e4 === "json" && r3.responseTransformer && (t3 = await r3.responseTransformer(t3)), { data: t3, ...p };
+    }
+    let f = await d2.text();
+    if (r3.throwOnError)
+      throw new Error(f);
+    try {
+      f = JSON.parse(f);
+    } catch {}
+    return { error: f || {}, ...p };
+  };
+  return { connect: (e3) => c({ ...e3, method: "CONNECT" }), delete: (e3) => c({ ...e3, method: "DELETE" }), get: (e3) => c({ ...e3, method: "GET" }), getConfig: r2, head: (e3) => c({ ...e3, method: "HEAD" }), interceptors: s2, options: (e3) => c({ ...e3, method: "OPTIONS" }), patch: (e3) => c({ ...e3, method: "PATCH" }), post: (e3) => c({ ...e3, method: "POST" }), put: (e3) => c({ ...e3, method: "PUT" }), request: c, setConfig: (e3) => (t2 = o(t2, e3), r2()), trace: (e3) => c({ ...e3, method: "TRACE" }) };
+};
 
-// src/video/core.ts
-class VideoClientCore extends import__.default {
+// src/generated/services.gen.ts
+var client = b(m());
+var rootGet = (options) => {
+  return (options?.client ?? client).get({
+    ...options,
+    url: "/"
+  });
+};
+var healthCheckHealthGet = (options) => {
+  return (options?.client ?? client).get({
+    ...options,
+    url: "/health"
+  });
+};
+var listPoliciesPoliciesGet = (options) => {
+  return (options?.client ?? client).get({
+    ...options,
+    url: "/policies"
+  });
+};
+var listSessionsSessionsGet = (options) => {
+  return (options?.client ?? client).get({
+    ...options,
+    url: "/sessions"
+  });
+};
+var createSessionSessionsPost = (options) => {
+  return (options?.client ?? client).post({
+    ...options,
+    url: "/sessions"
+  });
+};
+var getSessionStatusSessionsSessionIdGet = (options) => {
+  return (options?.client ?? client).get({
+    ...options,
+    url: "/sessions/{session_id}"
+  });
+};
+var deleteSessionSessionsSessionIdDelete = (options) => {
+  return (options?.client ?? client).delete({
+    ...options,
+    url: "/sessions/{session_id}"
+  });
+};
+var startInferenceSessionsSessionIdStartPost = (options) => {
+  return (options?.client ?? client).post({
+    ...options,
+    url: "/sessions/{session_id}/start"
+  });
+};
+var stopInferenceSessionsSessionIdStopPost = (options) => {
+  return (options?.client ?? client).post({
+    ...options,
+    url: "/sessions/{session_id}/stop"
+  });
+};
+var restartInferenceSessionsSessionIdRestartPost = (options) => {
+  return (options?.client ?? client).post({
+    ...options,
+    url: "/sessions/{session_id}/restart"
+  });
+};
+var getSystemInfoDebugSystemGet = (options) => {
+  return (options?.client ?? client).get({
+    ...options,
+    url: "/debug/system"
+  });
+};
+var getRecentLogsDebugLogsGet = (options) => {
+  return (options?.client ?? client).get({
+    ...options,
+    url: "/debug/logs"
+  });
+};
+var debugResetSessionDebugSessionsSessionIdResetPost = (options) => {
+  return (options?.client ?? client).post({
+    ...options,
+    url: "/debug/sessions/{session_id}/reset"
+  });
+};
+var getSessionQueueInfoDebugSessionsSessionIdQueueGet = (options) => {
+  return (options?.client ?? client).get({
+    ...options,
+    url: "/debug/sessions/{session_id}/queue"
+  });
+};
+// src/index.ts
+class LeRobotInferenceServerClient {
   baseUrl;
-  apiBase;
-  websocket = null;
-  peerConnection = null;
-  localStream = null;
-  remoteStream = null;
-  workspaceId = null;
-  roomId = null;
-  role = null;
-  participantId = null;
-  connected = false;
-  options;
-  webrtcConfig;
-  onErrorCallback = null;
-  onConnectedCallback = null;
-  onDisconnectedCallback = null;
-  constructor(baseUrl = "http://localhost:8000", options = {}) {
-    super();
-    this.baseUrl = baseUrl.replace(/\/$/, "");
-    this.apiBase = `${this.baseUrl}/video`;
-    this.options = {
-      timeout: 5000,
-      reconnect_attempts: 3,
-      heartbeat_interval: 30000,
-      ...options
-    };
-    this.webrtcConfig = {
-      iceServers: [{ urls: "stun:stun.l.google.com:19302" }],
-      constraints: {
-        video: {
-          width: { ideal: 640 },
-          height: { ideal: 480 },
-          frameRate: { ideal: 30 }
-        },
-        audio: false
-      },
-      bitrate: 1e6,
-      framerate: 30,
-      resolution: { width: 640, height: 480 },
-      codecPreferences: ["VP8", "H264"],
-      ...this.options.webrtc_config
-    };
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl;
+    client.setConfig({ baseUrl });
   }
-  async listRooms(workspaceId) {
-    const response = await this.fetchApi(`/workspaces/${workspaceId}/rooms`);
-    return response.rooms;
-  }
-  async createRoom(workspaceId, roomId, config, recoveryConfig) {
-    const finalWorkspaceId = workspaceId || this.generateWorkspaceId();
-    const payload = {
-      room_id: roomId,
-      workspace_id: finalWorkspaceId,
-      config,
-      recovery_config: recoveryConfig
-    };
-    const response = await this.fetchApi(`/workspaces/${finalWorkspaceId}/rooms`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(payload)
-    });
-    return { workspaceId: response.workspace_id, roomId: response.room_id };
-  }
-  async deleteRoom(workspaceId, roomId) {
+  async isHealthy() {
     try {
-      const response = await this.fetchApi(`/workspaces/${workspaceId}/rooms/${roomId}`, {
-        method: "DELETE"
-      });
-      return response.success;
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("404")) {
-        return false;
-      }
-      throw error;
-    }
-  }
-  async getRoomState(workspaceId, roomId) {
-    const response = await this.fetchApi(`/workspaces/${workspaceId}/rooms/${roomId}/state`);
-    return response.state;
-  }
-  async getRoomInfo(workspaceId, roomId) {
-    const response = await this.fetchApi(`/workspaces/${workspaceId}/rooms/${roomId}`);
-    return response.room;
-  }
-  async sendWebRTCSignal(workspaceId, roomId, clientId, message) {
-    const request = { client_id: clientId, message };
-    return this.fetchApi(`/workspaces/${workspaceId}/rooms/${roomId}/webrtc/signal`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(request)
-    });
-  }
-  async connectToRoom(workspaceId, roomId, role, participantId) {
-    if (this.connected) {
-      await this.disconnect();
-    }
-    this.workspaceId = workspaceId;
-    this.roomId = roomId;
-    this.role = role;
-    this.participantId = participantId || `${role}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-    const wsUrl = this.baseUrl.replace(/^http/, "ws").replace(/^https/, "wss");
-    const wsEndpoint = `${wsUrl}/video/workspaces/${workspaceId}/rooms/${roomId}/ws`;
-    try {
-      this.websocket = new WebSocket(wsEndpoint);
-      return new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
-          reject(new Error("Connection timeout"));
-        }, this.options.timeout || 5000);
-        this.websocket.onopen = () => {
-          clearTimeout(timeout);
-          this.sendJoinMessage();
-        };
-        this.websocket.onmessage = (event) => {
-          try {
-            const message = JSON.parse(event.data);
-            this.handleMessage(message);
-            if (message.type === "joined") {
-              this.connected = true;
-              this.onConnectedCallback?.();
-              this.emit("connected");
-              resolve(true);
-            } else if (message.type === "error") {
-              this.handleError(message.message);
-              resolve(false);
-            }
-          } catch (error) {
-            console.error("Failed to parse WebSocket message:", error);
-          }
-        };
-        this.websocket.onerror = (error) => {
-          clearTimeout(timeout);
-          console.error("WebSocket error:", error);
-          this.handleError("WebSocket connection error");
-          reject(error);
-        };
-        this.websocket.onclose = () => {
-          clearTimeout(timeout);
-          this.connected = false;
-          this.onDisconnectedCallback?.();
-          this.emit("disconnected");
-        };
-      });
-    } catch (error) {
-      console.error("Failed to connect to room:", error);
+      const response = await healthCheckHealthGet();
+      return !response.error;
+    } catch {
       return false;
     }
   }
-  async disconnect() {
-    if (this.peerConnection) {
-      this.peerConnection.close();
-      this.peerConnection = null;
-    }
-    if (this.localStream) {
-      this.localStream.getTracks().forEach((track) => track.stop());
-      this.localStream = null;
-    }
-    if (this.websocket && this.websocket.readyState === WebSocket.OPEN) {
-      this.websocket.close();
-    }
-    this.websocket = null;
-    this.remoteStream = null;
-    this.connected = false;
-    this.workspaceId = null;
-    this.roomId = null;
-    this.role = null;
-    this.participantId = null;
-    this.onDisconnectedCallback?.();
-    this.emit("disconnected");
-  }
-  createPeerConnection() {
-    const config = {
-      iceServers: this.webrtcConfig.iceServers || [
-        { urls: "stun:stun.l.google.com:19302" }
-      ]
-    };
-    this.peerConnection = new RTCPeerConnection(config);
-    this.peerConnection.onconnectionstatechange = () => {
-      const state = this.peerConnection?.connectionState;
-      console.info(`\uD83D\uDD0C WebRTC connection state: ${state}`);
-    };
-    this.peerConnection.oniceconnectionstatechange = () => {
-      const state = this.peerConnection?.iceConnectionState;
-      console.info(`\uD83E\uDDCA ICE connection state: ${state}`);
-    };
-    this.peerConnection.onicecandidate = (event) => {
-      if (event.candidate && this.workspaceId && this.roomId && this.participantId) {
-        this.sendWebRTCSignal(this.workspaceId, this.roomId, this.participantId, {
-          type: "ice",
-          candidate: event.candidate.toJSON()
-        });
-      }
-    };
-    this.peerConnection.ontrack = (event) => {
-      console.info("\uD83D\uDCFA Received remote track:", event.track.kind);
-      this.remoteStream = event.streams[0] || null;
-      this.emit("remoteStream", this.remoteStream);
-    };
-    return this.peerConnection;
-  }
-  async createOffer() {
-    if (!this.peerConnection) {
-      throw new Error("Peer connection not created");
-    }
-    const offer = await this.peerConnection.createOffer();
-    await this.peerConnection.setLocalDescription(offer);
-    return offer;
-  }
-  async createAnswer(offer) {
-    if (!this.peerConnection) {
-      throw new Error("Peer connection not created");
-    }
-    await this.peerConnection.setRemoteDescription(offer);
-    const answer = await this.peerConnection.createAnswer();
-    await this.peerConnection.setLocalDescription(answer);
-    return answer;
-  }
-  async setRemoteDescription(description) {
-    if (!this.peerConnection) {
-      throw new Error("Peer connection not created");
-    }
-    await this.peerConnection.setRemoteDescription(description);
-  }
-  async addIceCandidate(candidate) {
-    if (!this.peerConnection) {
-      throw new Error("Peer connection not created");
-    }
-    await this.peerConnection.addIceCandidate(candidate);
-  }
-  async startProducing(constraints) {
-    const mediaConstraints = constraints || this.webrtcConfig.constraints;
-    try {
-      this.localStream = await navigator.mediaDevices.getUserMedia(mediaConstraints);
-      return this.localStream;
-    } catch (error) {
-      throw new Error(`Failed to start video production: ${error}`);
-    }
-  }
-  async startScreenShare() {
-    try {
-      this.localStream = await navigator.mediaDevices.getDisplayMedia({
-        video: {
-          width: this.webrtcConfig.resolution?.width || 1920,
-          height: this.webrtcConfig.resolution?.height || 1080,
-          frameRate: this.webrtcConfig.framerate || 30
-        },
-        audio: false
-      });
-      return this.localStream;
-    } catch (error) {
-      throw new Error(`Failed to start screen share: ${error}`);
-    }
-  }
-  stopProducing() {
-    if (this.localStream) {
-      this.localStream.getTracks().forEach((track) => track.stop());
-      this.localStream = null;
+  async getHealth() {
+    const response = await healthCheckHealthGet();
+    if (response.error) {
+      throw new Error(`Health check failed: ${JSON.stringify(response.error)}`);
     }
+    return response.data;
   }
-  getLocalStream() {
-    return this.localStream;
-  }
-  getRemoteStream() {
-    return this.remoteStream;
-  }
-  getPeerConnection() {
-    return this.peerConnection;
-  }
-  async getStats() {
-    if (!this.peerConnection) {
-      return null;
+  async createSession(request) {
+    const response = await createSessionSessionsPost({
+      body: request
+    });
+    if (response.error) {
+      throw new Error(`Failed to create session: ${JSON.stringify(response.error)}`);
     }
-    const stats = await this.peerConnection.getStats();
-    return this.extractVideoStats(stats);
+    return response.data;
   }
-  sendJoinMessage() {
-    if (!this.websocket || !this.participantId || !this.role)
-      return;
-    const joinMessage = {
-      participant_id: this.participantId,
-      role: this.role
-    };
-    this.websocket.send(JSON.stringify(joinMessage));
-  }
-  handleMessage(message) {
-    switch (message.type) {
-      case "joined":
-        console.log(`Successfully joined room ${message.room_id} as ${message.role}`);
-        break;
-      case "heartbeat_ack":
-        console.debug("Heartbeat acknowledged");
-        break;
-      case "error":
-        this.handleError(message.message);
-        break;
-      default:
-        this.handleRoleSpecificMessage(message);
+  async listSessions() {
+    const response = await listSessionsSessionsGet();
+    if (response.error) {
+      throw new Error(`Failed to list sessions: ${JSON.stringify(response.error)}`);
     }
+    return response.data;
   }
-  handleRoleSpecificMessage(message) {
-    this.emit("message", message);
-  }
-  handleError(errorMessage) {
-    console.error("Video client error:", errorMessage);
-    this.onErrorCallback?.(errorMessage);
-    this.emit("error", errorMessage);
-  }
-  async sendHeartbeat() {
-    if (!this.connected || !this.websocket)
-      return;
-    const message = { type: "heartbeat" };
-    this.websocket.send(JSON.stringify(message));
-  }
-  isConnected() {
-    return this.connected;
-  }
-  getConnectionInfo() {
-    return {
-      connected: this.connected,
-      workspace_id: this.workspaceId,
-      room_id: this.roomId,
-      role: this.role,
-      participant_id: this.participantId,
-      base_url: this.baseUrl
-    };
-  }
-  onError(callback) {
-    this.onErrorCallback = callback;
-  }
-  onConnected(callback) {
-    this.onConnectedCallback = callback;
-  }
-  onDisconnected(callback) {
-    this.onDisconnectedCallback = callback;
-  }
-  async fetchApi(endpoint, options = {}) {
-    const url = `${this.apiBase}${endpoint}`;
-    const response = await fetch(url, {
-      ...options,
-      signal: AbortSignal.timeout(this.options.timeout || 5000)
+  async getSessionStatus(sessionId) {
+    const response = await getSessionStatusSessionsSessionIdGet({
+      path: { session_id: sessionId }
     });
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    if (response.error) {
+      throw new Error(`Failed to get session status: ${JSON.stringify(response.error)}`);
     }
-    return response.json();
+    return response.data;
   }
-  extractVideoStats(stats) {
-    let inboundVideoStats = null;
-    let outboundVideoStats = null;
-    stats.forEach((report) => {
-      if (report.type === "inbound-rtp" && "kind" in report && report.kind === "video") {
-        inboundVideoStats = report;
-      } else if (report.type === "outbound-rtp" && "kind" in report && report.kind === "video") {
-        outboundVideoStats = report;
-      }
+  async startInference(sessionId) {
+    const response = await startInferenceSessionsSessionIdStartPost({
+      path: { session_id: sessionId }
     });
-    if (inboundVideoStats) {
-      return {
-        videoBitsPerSecond: inboundVideoStats.bytesReceived || 0,
-        framesPerSecond: inboundVideoStats.framesPerSecond || 0,
-        frameWidth: inboundVideoStats.frameWidth || 0,
-        frameHeight: inboundVideoStats.frameHeight || 0,
-        packetsLost: inboundVideoStats.packetsLost || 0,
-        totalPackets: inboundVideoStats.packetsReceived || inboundVideoStats.framesDecoded || 0
-      };
-    }
-    if (outboundVideoStats) {
-      return {
-        videoBitsPerSecond: outboundVideoStats.bytesSent || 0,
-        framesPerSecond: outboundVideoStats.framesPerSecond || 0,
-        frameWidth: outboundVideoStats.frameWidth || 0,
-        frameHeight: outboundVideoStats.frameHeight || 0,
-        packetsLost: outboundVideoStats.packetsLost || 0,
-        totalPackets: outboundVideoStats.packetsSent || outboundVideoStats.framesSent || 0
-      };
+    if (response.error) {
+      throw new Error(`Failed to start inference: ${JSON.stringify(response.error)}`);
     }
-    return null;
   }
-  generateWorkspaceId() {
-    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
-      const r = Math.random() * 16 | 0;
-      const v = c === "x" ? r : r & 3 | 8;
-      return v.toString(16);
+  async stopInference(sessionId) {
+    const response = await stopInferenceSessionsSessionIdStopPost({
+      path: { session_id: sessionId }
     });
-  }
-}
-// src/video/producer.ts
-class VideoProducer extends VideoClientCore {
-  consumerConnections = new Map;
-  constructor(baseUrl = "http://localhost:8000", options = {}) {
-    super(baseUrl, options);
-  }
-  async connect(workspaceId, roomId, participantId) {
-    const success = await this.connectToRoom(workspaceId, roomId, "producer", participantId);
-    if (success) {
-      this.on("consumer_joined", (consumerId) => {
-        console.info(`\uD83C\uDFAF Consumer ${consumerId} joined, initiating WebRTC...`);
-        this.initiateWebRTCWithConsumer(consumerId);
-      });
-      setTimeout(() => this.connectToExistingConsumers(), 1000);
-    }
-    return success;
-  }
-  async connectToExistingConsumers() {
-    if (!this.workspaceId || !this.roomId)
-      return;
-    try {
-      const roomInfo = await this.getRoomInfo(this.workspaceId, this.roomId);
-      for (const consumerId of roomInfo.participants.consumers) {
-        if (!this.consumerConnections.has(consumerId)) {
-          console.info(`\uD83D\uDD04 Connecting to existing consumer ${consumerId}`);
-          await this.initiateWebRTCWithConsumer(consumerId);
-        }
-      }
-    } catch (error) {
-      console.error("Failed to connect to existing consumers:", error);
-    }
-  }
-  createPeerConnectionForConsumer(consumerId) {
-    const config = {
-      iceServers: this.webrtcConfig.iceServers || [
-        { urls: "stun:stun.l.google.com:19302" }
-      ]
-    };
-    const peerConnection = new RTCPeerConnection(config);
-    if (this.localStream) {
-      this.localStream.getTracks().forEach((track) => {
-        peerConnection.addTrack(track, this.localStream);
-      });
-    }
-    peerConnection.onconnectionstatechange = () => {
-      const state = peerConnection.connectionState;
-      console.info(`\uD83D\uDD0C WebRTC connection state for ${consumerId}: ${state}`);
-      if (state === "failed" || state === "disconnected") {
-        console.warn(`Connection to ${consumerId} failed, attempting restart...`);
-        setTimeout(() => this.restartConnectionToConsumer(consumerId), 2000);
-      }
-    };
-    peerConnection.oniceconnectionstatechange = () => {
-      const state = peerConnection.iceConnectionState;
-      console.info(`\uD83E\uDDCA ICE connection state for ${consumerId}: ${state}`);
-    };
-    peerConnection.onicecandidate = (event) => {
-      if (event.candidate && this.workspaceId && this.roomId && this.participantId) {
-        this.sendWebRTCSignal(this.workspaceId, this.roomId, this.participantId, {
-          type: "ice",
-          candidate: event.candidate.toJSON(),
-          target_consumer: consumerId
-        });
-      }
-    };
-    this.consumerConnections.set(consumerId, peerConnection);
-    return peerConnection;
-  }
-  async restartConnectionToConsumer(consumerId) {
-    console.info(`\uD83D\uDD04 Restarting connection to consumer ${consumerId}`);
-    await this.initiateWebRTCWithConsumer(consumerId);
-  }
-  handleConsumerLeft(consumerId) {
-    const peerConnection = this.consumerConnections.get(consumerId);
-    if (peerConnection) {
-      peerConnection.close();
-      this.consumerConnections.delete(consumerId);
-      console.info(`\uD83E\uDDF9 Cleaned up peer connection for consumer ${consumerId}`);
-    }
-  }
-  async restartConnectionsWithNewStream(stream) {
-    console.info("\uD83D\uDD04 Restarting connections with new stream...", { streamId: stream.id });
-    for (const [consumerId, peerConnection] of this.consumerConnections) {
-      peerConnection.close();
-      console.info(`\uD83E\uDDF9 Closed existing connection to consumer ${consumerId}`);
-    }
-    this.consumerConnections.clear();
-    try {
-      if (this.workspaceId && this.roomId) {
-        const roomInfo = await this.getRoomInfo(this.workspaceId, this.roomId);
-        for (const consumerId of roomInfo.participants.consumers) {
-          console.info(`\uD83D\uDD04 Creating new connection to consumer ${consumerId}...`);
-          await this.initiateWebRTCWithConsumer(consumerId);
-        }
-      }
-    } catch (error) {
-      console.error("Failed to restart connections:", error);
-    }
-  }
-  async startCamera(constraints) {
-    if (!this.connected) {
-      throw new Error("Must be connected to start camera");
-    }
-    const stream = await this.startProducing(constraints);
-    this.localStream = stream;
-    await this.restartConnectionsWithNewStream(stream);
-    this.notifyStreamStarted(stream);
-    return stream;
-  }
-  async startScreenShare() {
-    if (!this.connected) {
-      throw new Error("Must be connected to start screen share");
-    }
-    const stream = await super.startScreenShare();
-    this.localStream = stream;
-    await this.restartConnectionsWithNewStream(stream);
-    this.notifyStreamStarted(stream);
-    return stream;
-  }
-  async stopStreaming() {
-    if (!this.connected || !this.websocket) {
-      throw new Error("Must be connected to stop streaming");
-    }
-    for (const [consumerId, peerConnection] of this.consumerConnections) {
-      peerConnection.close();
-      console.info(`\uD83E\uDDF9 Closed connection to consumer ${consumerId}`);
-    }
-    this.consumerConnections.clear();
-    this.stopProducing();
-    this.notifyStreamStopped();
-  }
-  async updateVideoConfig(config) {
-    if (!this.connected || !this.websocket) {
-      throw new Error("Must be connected to update video config");
-    }
-    const message = {
-      type: "video_config_update",
-      config,
-      timestamp: new Date().toISOString()
-    };
-    this.websocket.send(JSON.stringify(message));
-  }
-  async sendEmergencyStop(reason = "Emergency stop") {
-    if (!this.connected || !this.websocket) {
-      throw new Error("Must be connected to send emergency stop");
-    }
-    const message = {
-      type: "emergency_stop",
-      reason,
-      timestamp: new Date().toISOString()
-    };
-    this.websocket.send(JSON.stringify(message));
-  }
-  async initiateWebRTCWithConsumer(consumerId) {
-    if (!this.workspaceId || !this.roomId || !this.participantId) {
-      console.warn("WebRTC not ready, skipping negotiation with consumer");
-      return;
-    }
-    if (this.consumerConnections.has(consumerId)) {
-      const existingConn = this.consumerConnections.get(consumerId);
-      existingConn?.close();
-      this.consumerConnections.delete(consumerId);
-    }
-    try {
-      console.info(`\uD83D\uDD04 Creating WebRTC offer for consumer ${consumerId}...`);
-      const peerConnection = this.createPeerConnectionForConsumer(consumerId);
-      const offer = await peerConnection.createOffer();
-      await peerConnection.setLocalDescription(offer);
-      console.info(`\uD83D\uDCE4 Sending WebRTC offer to consumer ${consumerId}...`);
-      await this.sendWebRTCSignal(this.workspaceId, this.roomId, this.participantId, {
-        type: "offer",
-        sdp: offer.sdp,
-        target_consumer: consumerId
-      });
-      console.info(`\u2705 WebRTC offer sent to consumer ${consumerId}`);
-    } catch (error) {
-      console.error(`Failed to initiate WebRTC with consumer ${consumerId}:`, error);
-    }
-  }
-  async handleWebRTCAnswer(message) {
-    try {
-      const consumerId = message.from_consumer;
-      console.info(`\uD83D\uDCE5 Received WebRTC answer from consumer ${consumerId}`);
-      const peerConnection = this.consumerConnections.get(consumerId);
-      if (!peerConnection) {
-        console.warn(`No peer connection found for consumer ${consumerId}`);
-        return;
-      }
-      const answer = new RTCSessionDescription({
-        type: "answer",
-        sdp: message.answer.sdp
-      });
-      await peerConnection.setRemoteDescription(answer);
-      console.info(`\u2705 WebRTC negotiation completed with consumer ${consumerId}`);
-    } catch (error) {
-      console.error(`Failed to handle WebRTC answer from ${message.from_consumer}:`, error);
-      this.handleError(`Failed to handle WebRTC answer: ${error}`);
-    }
-  }
-  async handleWebRTCIce(message) {
-    try {
-      const consumerId = message.from_consumer;
-      if (!consumerId) {
-        console.warn("No consumer ID in ICE message");
-        return;
-      }
-      const peerConnection = this.consumerConnections.get(consumerId);
-      if (!peerConnection) {
-        console.warn(`No peer connection found for consumer ${consumerId}`);
-        return;
-      }
-      console.info(`\uD83D\uDCE5 Received WebRTC ICE from consumer ${consumerId}`);
-      const candidate = new RTCIceCandidate(message.candidate);
-      await peerConnection.addIceCandidate(candidate);
-      console.info(`\u2705 WebRTC ICE handled with consumer ${consumerId}`);
-    } catch (error) {
-      console.error(`Failed to handle WebRTC ICE from ${message.from_consumer}:`, error);
-      this.handleError(`Failed to handle WebRTC ICE: ${error}`);
-    }
-  }
-  handleRoleSpecificMessage(message) {
-    switch (message.type) {
-      case "participant_joined":
-        if (message.role === "consumer" && message.participant_id !== this.participantId) {
-          console.info(`\uD83C\uDFAF Consumer ${message.participant_id} joined room`);
-          this.emit("consumer_joined", message.participant_id);
-        }
-        break;
-      case "participant_left":
-        if (message.role === "consumer") {
-          console.info(`\uD83D\uDC4B Consumer ${message.participant_id} left room`);
-          this.handleConsumerLeft(message.participant_id);
-        }
-        break;
-      case "webrtc_answer":
-        this.handleWebRTCAnswer(message);
-        break;
-      case "webrtc_ice":
-        this.handleWebRTCIce(message);
-        break;
-      case "status_update":
-        this.handleStatusUpdate(message);
-        break;
-      case "stream_stats":
-        this.handleStreamStats(message);
-        break;
-      case "emergency_stop":
-        console.warn(`\uD83D\uDEA8 Emergency stop: ${message.reason || "Unknown reason"}`);
-        this.handleError(`Emergency stop: ${message.reason || "Unknown reason"}`);
-        break;
-      case "error":
-        console.error(`Server error: ${message.message}`);
-        this.handleError(message.message);
-        break;
-      default:
-        console.warn(`Unknown message type for producer: ${message.type}`);
-    }
-  }
-  handleStatusUpdate(message) {
-    console.info(`\uD83D\uDCCA Status update: ${message.status}`, message.data);
-    this.emit("statusUpdate", message.status, message.data);
-  }
-  handleStreamStats(message) {
-    console.debug(`\uD83D\uDCC8 Stream stats:`, message.stats);
-    this.emit("streamStats", message.stats);
-  }
-  async notifyStreamStarted(stream) {
-    if (!this.websocket)
-      return;
-    const message = {
-      type: "stream_started",
-      config: {
-        resolution: this.webrtcConfig.resolution,
-        framerate: this.webrtcConfig.framerate,
-        bitrate: this.webrtcConfig.bitrate
-      },
-      participant_id: this.participantId,
-      timestamp: new Date().toISOString()
-    };
-    this.websocket.send(JSON.stringify(message));
-    this.emit("streamStarted", stream);
-  }
-  async notifyStreamStopped() {
-    if (!this.websocket)
-      return;
-    const message = {
-      type: "stream_stopped",
-      participant_id: this.participantId,
-      timestamp: new Date().toISOString()
-    };
-    this.websocket.send(JSON.stringify(message));
-    this.emit("streamStopped");
-  }
-  static async createAndConnect(baseUrl = "http://localhost:8000", workspaceId, roomId, participantId) {
-    const producer = new VideoProducer(baseUrl);
-    const roomData = await producer.createRoom(workspaceId, roomId);
-    const connected = await producer.connect(roomData.workspaceId, roomData.roomId, participantId);
-    if (!connected) {
-      throw new Error("Failed to connect as video producer");
-    }
-    return producer;
-  }
-  get currentRoomId() {
-    return this.roomId;
-  }
-}
-// src/video/consumer.ts
-class VideoConsumer extends VideoClientCore {
-  onFrameUpdateCallback = null;
-  onVideoConfigUpdateCallback = null;
-  onStreamStartedCallback = null;
-  onStreamStoppedCallback = null;
-  onRecoveryTriggeredCallback = null;
-  onStatusUpdateCallback = null;
-  onStreamStatsCallback = null;
-  iceCandidateQueue = [];
-  hasRemoteDescription = false;
-  constructor(baseUrl = "http://localhost:8000", options = {}) {
-    super(baseUrl, options);
-  }
-  async connect(workspaceId, roomId, participantId) {
-    const connected = await this.connectToRoom(workspaceId, roomId, "consumer", participantId);
-    if (connected) {
-      console.info("\uD83D\uDD27 Creating peer connection for consumer...");
-      await this.startReceiving();
-    }
-    return connected;
-  }
-  async startReceiving() {
-    if (!this.connected) {
-      throw new Error("Must be connected to start receiving");
-    }
-    this.hasRemoteDescription = false;
-    this.iceCandidateQueue = [];
-    this.createPeerConnection();
-    if (this.peerConnection) {
-      this.peerConnection.ontrack = (event) => {
-        console.info("\uD83D\uDCFA Received remote track:", event.track.kind);
-        this.remoteStream = event.streams[0] || null;
-        this.emit("remoteStream", this.remoteStream);
-        this.emit("streamReceived", this.remoteStream);
-      };
+    if (response.error) {
+      throw new Error(`Failed to stop inference: ${JSON.stringify(response.error)}`);
     }
   }
-  async stopReceiving() {
-    if (this.peerConnection) {
-      this.peerConnection.close();
-      this.peerConnection = null;
-    }
-    this.remoteStream = null;
-    this.emit("streamStopped");
-  }
-  async handleWebRTCOffer(message) {
-    try {
-      console.info(`\uD83D\uDCE5 Received WebRTC offer from producer ${message.from_producer}`);
-      if (!this.peerConnection) {
-        console.warn("No peer connection available to handle offer");
-        return;
-      }
-      this.hasRemoteDescription = false;
-      this.iceCandidateQueue = [];
-      await this.setRemoteDescription(message.offer);
-      this.hasRemoteDescription = true;
-      await this.processQueuedIceCandidates();
-      const answer = await this.createAnswer(message.offer);
-      console.info(`\uD83D\uDCE4 Sending WebRTC answer to producer ${message.from_producer}`);
-      if (this.workspaceId && this.roomId && this.participantId) {
-        await this.sendWebRTCSignal(this.workspaceId, this.roomId, this.participantId, {
-          type: "answer",
-          sdp: answer.sdp,
-          target_producer: message.from_producer
-        });
-      }
-      console.info("\u2705 WebRTC negotiation completed from consumer side");
-    } catch (error) {
-      console.error("Failed to handle WebRTC offer:", error);
-      this.handleError(`Failed to handle WebRTC offer: ${error}`);
-    }
-  }
-  async handleWebRTCIce(message) {
-    if (!this.peerConnection) {
-      console.warn("No peer connection available to handle ICE");
-      return;
-    }
-    try {
-      console.info(`\uD83D\uDCE5 Received WebRTC ICE from producer ${message.from_producer}`);
-      const candidate = new RTCIceCandidate(message.candidate);
-      if (!this.hasRemoteDescription) {
-        console.info(`\uD83D\uDD04 Queuing ICE candidate from ${message.from_producer} (no remote description yet)`);
-        this.iceCandidateQueue.push({
-          candidate,
-          fromProducer: message.from_producer || "unknown"
-        });
-        return;
-      }
-      await this.peerConnection.addIceCandidate(candidate);
-      console.info(`\u2705 WebRTC ICE handled from producer ${message.from_producer}`);
-    } catch (error) {
-      console.error(`Failed to handle WebRTC ICE from ${message.from_producer}:`, error);
-      this.handleError(`Failed to handle WebRTC ICE: ${error}`);
+  async restartInference(sessionId) {
+    const response = await restartInferenceSessionsSessionIdRestartPost({
+      path: { session_id: sessionId }
+    });
+    if (response.error) {
+      throw new Error(`Failed to restart inference: ${JSON.stringify(response.error)}`);
     }
   }
-  async processQueuedIceCandidates() {
-    if (this.iceCandidateQueue.length === 0) {
-      return;
-    }
-    console.info(`\uD83D\uDD04 Processing ${this.iceCandidateQueue.length} queued ICE candidates`);
-    for (const { candidate, fromProducer } of this.iceCandidateQueue) {
-      try {
-        if (this.peerConnection) {
-          await this.peerConnection.addIceCandidate(candidate);
-          console.info(`\u2705 Processed queued ICE candidate from ${fromProducer}`);
-        }
-      } catch (error) {
-        console.error(`Failed to process queued ICE candidate from ${fromProducer}:`, error);
-      }
+  async deleteSession(sessionId) {
+    const response = await deleteSessionSessionsSessionIdDelete({
+      path: { session_id: sessionId }
+    });
+    if (response.error) {
+      throw new Error(`Failed to delete session: ${JSON.stringify(response.error)}`);
     }
-    this.iceCandidateQueue = [];
-  }
-  createPeerConnection() {
-    const config = {
-      iceServers: this.webrtcConfig.iceServers || [
-        { urls: "stun:stun.l.google.com:19302" }
-      ]
-    };
-    this.peerConnection = new RTCPeerConnection(config);
-    this.peerConnection.onconnectionstatechange = () => {
-      const state = this.peerConnection?.connectionState;
-      console.info(`\uD83D\uDD0C WebRTC connection state: ${state}`);
-    };
-    this.peerConnection.oniceconnectionstatechange = () => {
-      const state = this.peerConnection?.iceConnectionState;
-      console.info(`\uD83E\uDDCA ICE connection state: ${state}`);
-    };
-    this.peerConnection.onicecandidate = (event) => {
-      if (event.candidate && this.workspaceId && this.roomId && this.participantId) {
-        this.sendIceCandidateToProducer(event.candidate);
-      }
-    };
-    this.peerConnection.ontrack = (event) => {
-      console.info("\uD83D\uDCFA Received remote track:", event.track.kind);
-      this.remoteStream = event.streams[0] || null;
-      this.emit("remoteStream", this.remoteStream);
-      this.emit("streamReceived", this.remoteStream);
-    };
-    return this.peerConnection;
   }
-  async sendIceCandidateToProducer(candidate) {
-    if (!this.workspaceId || !this.roomId || !this.participantId)
-      return;
-    try {
-      const roomInfo = await this.getRoomInfo(this.workspaceId, this.roomId);
-      if (roomInfo.participants.producer) {
-        await this.sendWebRTCSignal(this.workspaceId, this.roomId, this.participantId, {
-          type: "ice",
-          candidate: candidate.toJSON(),
-          target_producer: roomInfo.participants.producer
-        });
+  async waitForSessionStatus(sessionId, targetStatus, timeoutMs = 30000) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+      const status = await this.getSessionStatus(sessionId);
+      if (status.status === targetStatus) {
+        return status;
       }
-    } catch (error) {
-      console.error("Failed to send ICE candidate to producer:", error);
-    }
-  }
-  async handleStreamStarted(message) {
-    if (this.onStreamStartedCallback) {
-      this.onStreamStartedCallback(message.config, message.participant_id);
-    }
-    this.emit("streamStarted", message.config, message.participant_id);
-    console.info(`\uD83D\uDE80 Stream started by producer ${message.participant_id}, ready to receive video`);
-  }
-  onFrameUpdate(callback) {
-    this.onFrameUpdateCallback = callback;
-  }
-  onVideoConfigUpdate(callback) {
-    this.onVideoConfigUpdateCallback = callback;
-  }
-  onStreamStarted(callback) {
-    this.onStreamStartedCallback = callback;
-  }
-  onStreamStopped(callback) {
-    this.onStreamStoppedCallback = callback;
-  }
-  onRecoveryTriggered(callback) {
-    this.onRecoveryTriggeredCallback = callback;
-  }
-  onStatusUpdate(callback) {
-    this.onStatusUpdateCallback = callback;
-  }
-  onStreamStats(callback) {
-    this.onStreamStatsCallback = callback;
-  }
-  handleRoleSpecificMessage(message) {
-    switch (message.type) {
-      case "frame_update":
-        this.handleFrameUpdate(message);
-        break;
-      case "video_config_update":
-        this.handleVideoConfigUpdate(message);
-        break;
-      case "stream_started":
-        this.handleStreamStarted(message);
-        break;
-      case "stream_stopped":
-        this.handleStreamStopped(message);
-        break;
-      case "recovery_triggered":
-        this.handleRecoveryTriggered(message);
-        break;
-      case "status_update":
-        this.handleStatusUpdate(message);
-        break;
-      case "stream_stats":
-        this.handleStreamStats(message);
-        break;
-      case "participant_joined":
-        console.info(`\uD83D\uDCE5 Participant joined: ${message.participant_id} as ${message.role}`);
-        break;
-      case "participant_left":
-        console.info(`\uD83D\uDCE4 Participant left: ${message.participant_id} (${message.role})`);
-        break;
-      case "webrtc_offer":
-        this.handleWebRTCOffer(message);
-        break;
-      case "webrtc_answer":
-        console.info("\uD83D\uDCE8 Received WebRTC answer (consumer should not receive this)");
-        break;
-      case "webrtc_ice":
-        this.handleWebRTCIce(message);
-        break;
-      case "emergency_stop":
-        console.warn(`\uD83D\uDEA8 Emergency stop: ${message.reason || "Unknown reason"}`);
-        this.handleError(`Emergency stop: ${message.reason || "Unknown reason"}`);
-        break;
-      case "error":
-        console.error(`Server error: ${message.message}`);
-        this.handleError(message.message);
-        break;
-      default:
-        console.warn(`Unknown message type for consumer: ${message.type}`);
-    }
-  }
-  handleFrameUpdate(message) {
-    if (this.onFrameUpdateCallback) {
-      const frameData = {
-        data: message.data,
-        metadata: message.metadata
-      };
-      this.onFrameUpdateCallback(frameData);
-    }
-    this.emit("frameUpdate", message.data);
-  }
-  handleVideoConfigUpdate(message) {
-    if (this.onVideoConfigUpdateCallback) {
-      this.onVideoConfigUpdateCallback(message.config);
-    }
-    this.emit("videoConfigUpdate", message.config);
-  }
-  handleStreamStopped(message) {
-    if (this.onStreamStoppedCallback) {
-      this.onStreamStoppedCallback(message.participant_id, message.reason);
+      await new Promise((resolve) => setTimeout(resolve, 1000));
     }
-    this.emit("streamStopped", message.participant_id, message.reason);
+    throw new Error(`Timeout waiting for session ${sessionId} to reach status ${targetStatus}`);
   }
-  handleRecoveryTriggered(message) {
-    if (this.onRecoveryTriggeredCallback) {
-      this.onRecoveryTriggeredCallback(message.policy, message.reason);
-    }
-    this.emit("recoveryTriggered", message.policy, message.reason);
-  }
-  handleStatusUpdate(message) {
-    if (this.onStatusUpdateCallback) {
-      this.onStatusUpdateCallback(message.status, message.data);
-    }
-    this.emit("statusUpdate", message.status, message.data);
+  async createAndStartSession(request) {
+    const session = await this.createSession(request);
+    await this.startInference(request.session_id);
+    const status = await this.waitForSessionStatus(request.session_id, "running");
+    return { session, status };
   }
-  handleStreamStats(message) {
-    if (this.onStreamStatsCallback) {
-      this.onStreamStatsCallback(message.stats);
+  async getSystemInfo() {
+    const response = await getSystemInfoDebugSystemGet();
+    if (response.error) {
+      throw new Error(`Failed to get system info: ${JSON.stringify(response.error)}`);
     }
-    this.emit("streamStats", message.stats);
+    return response.data;
   }
-  static async createAndConnect(workspaceId, roomId, baseUrl = "http://localhost:8000", participantId) {
-    const consumer = new VideoConsumer(baseUrl);
-    const connected = await consumer.connect(workspaceId, roomId, participantId);
-    if (!connected) {
-      throw new Error("Failed to connect as video consumer");
+  async debugResetSession(sessionId) {
+    const response = await debugResetSessionDebugSessionsSessionIdResetPost({
+      path: { session_id: sessionId }
+    });
+    if (response.error) {
+      throw new Error(`Failed to reset session: ${JSON.stringify(response.error)}`);
     }
-    return consumer;
   }
-  attachToVideoElement(videoElement) {
-    if (this.remoteStream) {
-      videoElement.srcObject = this.remoteStream;
-    }
-    this.on("remoteStream", (stream) => {
-      videoElement.srcObject = stream;
+  async getSessionQueueInfo(sessionId) {
+    const response = await getSessionQueueInfoDebugSessionsSessionIdQueueGet({
+      path: { session_id: sessionId }
     });
+    if (response.error) {
+      throw new Error(`Failed to get queue info: ${JSON.stringify(response.error)}`);
+    }
+    return response.data;
   }
-  async getVideoStats() {
-    const stats = await this.getStats();
-    return stats;
-  }
-}
-// src/video/factory.ts
-function createClient2(role, baseUrl = "http://localhost:8000", options = {}) {
-  if (role === "producer") {
-    return new VideoProducer(baseUrl, options);
-  }
-  if (role === "consumer") {
-    return new VideoConsumer(baseUrl, options);
-  }
-  throw new Error(`Invalid role: ${role}. Must be 'producer' or 'consumer'`);
-}
-async function createProducerClient2(baseUrl = "http://localhost:8000", workspaceId, roomId, participantId, options = {}) {
-  const producer = new VideoProducer(baseUrl, options);
-  const roomData = await producer.createRoom(workspaceId, roomId);
-  const connected = await producer.connect(roomData.workspaceId, roomData.roomId, participantId);
-  if (!connected) {
-    throw new Error("Failed to connect as video producer");
-  }
-  return producer;
 }
-async function createConsumerClient2(workspaceId, roomId, baseUrl = "http://localhost:8000", participantId, options = {}) {
-  const consumer = new VideoConsumer(baseUrl, options);
-  const connected = await consumer.connect(workspaceId, roomId, participantId);
-  if (!connected) {
-    throw new Error("Failed to connect as video consumer");
-  }
-  return consumer;
+function createClient(baseUrl) {
+  return new LeRobotInferenceServerClient(baseUrl);
 }
-// src/index.ts
-var VERSION = "1.0.0";
+var LeRobotAIServerClient = LeRobotInferenceServerClient;
 export {
-  exports_video as video,
-  exports_robotics as robotics,
-  VERSION
+  stopInferenceSessionsSessionIdStopPost,
+  startInferenceSessionsSessionIdStartPost,
+  rootGet,
+  restartInferenceSessionsSessionIdRestartPost,
+  listSessionsSessionsGet,
+  listPoliciesPoliciesGet,
+  healthCheckHealthGet,
+  getSystemInfoDebugSystemGet,
+  getSessionStatusSessionsSessionIdGet,
+  getSessionQueueInfoDebugSessionsSessionIdQueueGet,
+  getRecentLogsDebugLogsGet,
+  deleteSessionSessionsSessionIdDelete,
+  debugResetSessionDebugSessionsSessionIdResetPost,
+  createSessionSessionsPost,
+  createClient,
+  client,
+  ValidationErrorSchema,
+  SessionStatusResponseSchema,
+  LeRobotInferenceServerClient,
+  LeRobotAIServerClient,
+  HTTPValidationErrorSchema,
+  CreateSessionResponseSchema,
+  CreateSessionRequestSchema
 };
 
-//# debugId=4A2D211384B624B064756E2164756E21
+//# debugId=2097EAE219935B0E64756E2164756E21
 //# sourceMappingURL=index.js.map

client/src/generated/index.ts

@@ -0,0 +1,4 @@
+// This file is auto-generated by @hey-api/openapi-ts
+export * from './schemas.gen';
+export * from './services.gen';
+export * from './types.gen';

client/src/generated/schemas.gen.ts

@@ -0,0 +1,196 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+export const CreateSessionRequestSchema = {
+    properties: {
+        session_id: {
+            type: 'string',
+            title: 'Session Id'
+        },
+        policy_path: {
+            type: 'string',
+            title: 'Policy Path'
+        },
+        camera_names: {
+            items: {
+                type: 'string'
+            },
+            type: 'array',
+            title: 'Camera Names',
+            default: ['front']
+        },
+        arena_server_url: {
+            type: 'string',
+            title: 'Arena Server Url',
+            default: 'http://localhost:8000'
+        },
+        workspace_id: {
+            anyOf: [
+                {
+                    type: 'string'
+                },
+                {
+                    type: 'null'
+                }
+            ],
+            title: 'Workspace Id'
+        },
+        policy_type: {
+            type: 'string',
+            title: 'Policy Type',
+            default: 'act'
+        },
+        language_instruction: {
+            anyOf: [
+                {
+                    type: 'string'
+                },
+                {
+                    type: 'null'
+                }
+            ],
+            title: 'Language Instruction'
+        }
+    },
+    type: 'object',
+    required: ['session_id', 'policy_path'],
+    title: 'CreateSessionRequest'
+} as const;
+
+export const CreateSessionResponseSchema = {
+    properties: {
+        workspace_id: {
+            type: 'string',
+            title: 'Workspace Id'
+        },
+        camera_room_ids: {
+            additionalProperties: {
+                type: 'string'
+            },
+            type: 'object',
+            title: 'Camera Room Ids'
+        },
+        joint_input_room_id: {
+            type: 'string',
+            title: 'Joint Input Room Id'
+        },
+        joint_output_room_id: {
+            type: 'string',
+            title: 'Joint Output Room Id'
+        }
+    },
+    type: 'object',
+    required: ['workspace_id', 'camera_room_ids', 'joint_input_room_id', 'joint_output_room_id'],
+    title: 'CreateSessionResponse'
+} as const;
+
+export const HTTPValidationErrorSchema = {
+    properties: {
+        detail: {
+            items: {
+                '$ref': '#/components/schemas/ValidationError'
+            },
+            type: 'array',
+            title: 'Detail'
+        }
+    },
+    type: 'object',
+    title: 'HTTPValidationError'
+} as const;
+
+export const SessionStatusResponseSchema = {
+    properties: {
+        session_id: {
+            type: 'string',
+            title: 'Session Id'
+        },
+        status: {
+            type: 'string',
+            title: 'Status'
+        },
+        policy_path: {
+            type: 'string',
+            title: 'Policy Path'
+        },
+        policy_type: {
+            type: 'string',
+            title: 'Policy Type'
+        },
+        camera_names: {
+            items: {
+                type: 'string'
+            },
+            type: 'array',
+            title: 'Camera Names'
+        },
+        workspace_id: {
+            type: 'string',
+            title: 'Workspace Id'
+        },
+        rooms: {
+            additionalProperties: true,
+            type: 'object',
+            title: 'Rooms'
+        },
+        stats: {
+            additionalProperties: true,
+            type: 'object',
+            title: 'Stats'
+        },
+        inference_stats: {
+            anyOf: [
+                {
+                    additionalProperties: true,
+                    type: 'object'
+                },
+                {
+                    type: 'null'
+                }
+            ],
+            title: 'Inference Stats'
+        },
+        error_message: {
+            anyOf: [
+                {
+                    type: 'string'
+                },
+                {
+                    type: 'null'
+                }
+            ],
+            title: 'Error Message'
+        }
+    },
+    type: 'object',
+    required: ['session_id', 'status', 'policy_path', 'policy_type', 'camera_names', 'workspace_id', 'rooms', 'stats'],
+    title: 'SessionStatusResponse'
+} as const;
+
+export const ValidationErrorSchema = {
+    properties: {
+        loc: {
+            items: {
+                anyOf: [
+                    {
+                        type: 'string'
+                    },
+                    {
+                        type: 'integer'
+                    }
+                ]
+            },
+            type: 'array',
+            title: 'Location'
+        },
+        msg: {
+            type: 'string',
+            title: 'Message'
+        },
+        type: {
+            type: 'string',
+            title: 'Error Type'
+        }
+    },
+    type: 'object',
+    required: ['loc', 'msg', 'type'],
+    title: 'ValidationError'
+} as const;

client/src/generated/services.gen.ts

@@ -0,0 +1,164 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import { createClient, createConfig, type Options } from '@hey-api/client-fetch';
+import type { RootGetError, RootGetResponse, HealthCheckHealthGetError, HealthCheckHealthGetResponse, ListPoliciesPoliciesGetError, ListPoliciesPoliciesGetResponse, ListSessionsSessionsGetError, ListSessionsSessionsGetResponse, CreateSessionSessionsPostData, CreateSessionSessionsPostError, CreateSessionSessionsPostResponse, GetSessionStatusSessionsSessionIdGetData, GetSessionStatusSessionsSessionIdGetError, GetSessionStatusSessionsSessionIdGetResponse, DeleteSessionSessionsSessionIdDeleteData, DeleteSessionSessionsSessionIdDeleteError, DeleteSessionSessionsSessionIdDeleteResponse, StartInferenceSessionsSessionIdStartPostData, StartInferenceSessionsSessionIdStartPostError, StartInferenceSessionsSessionIdStartPostResponse, StopInferenceSessionsSessionIdStopPostData, StopInferenceSessionsSessionIdStopPostError, StopInferenceSessionsSessionIdStopPostResponse, RestartInferenceSessionsSessionIdRestartPostData, RestartInferenceSessionsSessionIdRestartPostError, RestartInferenceSessionsSessionIdRestartPostResponse, GetSystemInfoDebugSystemGetError, GetSystemInfoDebugSystemGetResponse, GetRecentLogsDebugLogsGetError, GetRecentLogsDebugLogsGetResponse, DebugResetSessionDebugSessionsSessionIdResetPostData, DebugResetSessionDebugSessionsSessionIdResetPostError, DebugResetSessionDebugSessionsSessionIdResetPostResponse, GetSessionQueueInfoDebugSessionsSessionIdQueueGetData, GetSessionQueueInfoDebugSessionsSessionIdQueueGetError, GetSessionQueueInfoDebugSessionsSessionIdQueueGetResponse } from './types.gen';
+
+export const client = createClient(createConfig());
+
+/**
+ * Root
+ * Health check endpoint.
+ */
+export const rootGet = <ThrowOnError extends boolean = false>(options?: Options<unknown, ThrowOnError>) => {
+    return (options?.client ?? client).get<RootGetResponse, RootGetError, ThrowOnError>({
+        ...options,
+        url: '/'
+    });
+};
+
+/**
+ * Health Check
+ * Detailed health check.
+ */
+export const healthCheckHealthGet = <ThrowOnError extends boolean = false>(options?: Options<unknown, ThrowOnError>) => {
+    return (options?.client ?? client).get<HealthCheckHealthGetResponse, HealthCheckHealthGetError, ThrowOnError>({
+        ...options,
+        url: '/health'
+    });
+};
+
+/**
+ * List Policies
+ * List supported policy types.
+ */
+export const listPoliciesPoliciesGet = <ThrowOnError extends boolean = false>(options?: Options<unknown, ThrowOnError>) => {
+    return (options?.client ?? client).get<ListPoliciesPoliciesGetResponse, ListPoliciesPoliciesGetError, ThrowOnError>({
+        ...options,
+        url: '/policies'
+    });
+};
+
+/**
+ * List Sessions
+ * List all sessions.
+ */
+export const listSessionsSessionsGet = <ThrowOnError extends boolean = false>(options?: Options<unknown, ThrowOnError>) => {
+    return (options?.client ?? client).get<ListSessionsSessionsGetResponse, ListSessionsSessionsGetError, ThrowOnError>({
+        ...options,
+        url: '/sessions'
+    });
+};
+
+/**
+ * Create Session
+ * Create a new inference session.
+ *
+ * If workspace_id is provided, all rooms will be created in that workspace.
+ * If workspace_id is not provided, a new workspace will be generated automatically.
+ * All rooms for a session (cameras + joints) are always created in the same workspace.
+ */
+export const createSessionSessionsPost = <ThrowOnError extends boolean = false>(options: Options<CreateSessionSessionsPostData, ThrowOnError>) => {
+    return (options?.client ?? client).post<CreateSessionSessionsPostResponse, CreateSessionSessionsPostError, ThrowOnError>({
+        ...options,
+        url: '/sessions'
+    });
+};
+
+/**
+ * Get Session Status
+ * Get status of a specific session.
+ */
+export const getSessionStatusSessionsSessionIdGet = <ThrowOnError extends boolean = false>(options: Options<GetSessionStatusSessionsSessionIdGetData, ThrowOnError>) => {
+    return (options?.client ?? client).get<GetSessionStatusSessionsSessionIdGetResponse, GetSessionStatusSessionsSessionIdGetError, ThrowOnError>({
+        ...options,
+        url: '/sessions/{session_id}'
+    });
+};
+
+/**
+ * Delete Session
+ * Delete a session.
+ */
+export const deleteSessionSessionsSessionIdDelete = <ThrowOnError extends boolean = false>(options: Options<DeleteSessionSessionsSessionIdDeleteData, ThrowOnError>) => {
+    return (options?.client ?? client).delete<DeleteSessionSessionsSessionIdDeleteResponse, DeleteSessionSessionsSessionIdDeleteError, ThrowOnError>({
+        ...options,
+        url: '/sessions/{session_id}'
+    });
+};
+
+/**
+ * Start Inference
+ * Start inference for a session.
+ */
+export const startInferenceSessionsSessionIdStartPost = <ThrowOnError extends boolean = false>(options: Options<StartInferenceSessionsSessionIdStartPostData, ThrowOnError>) => {
+    return (options?.client ?? client).post<StartInferenceSessionsSessionIdStartPostResponse, StartInferenceSessionsSessionIdStartPostError, ThrowOnError>({
+        ...options,
+        url: '/sessions/{session_id}/start'
+    });
+};
+
+/**
+ * Stop Inference
+ * Stop inference for a session.
+ */
+export const stopInferenceSessionsSessionIdStopPost = <ThrowOnError extends boolean = false>(options: Options<StopInferenceSessionsSessionIdStopPostData, ThrowOnError>) => {
+    return (options?.client ?? client).post<StopInferenceSessionsSessionIdStopPostResponse, StopInferenceSessionsSessionIdStopPostError, ThrowOnError>({
+        ...options,
+        url: '/sessions/{session_id}/stop'
+    });
+};
+
+/**
+ * Restart Inference
+ * Restart inference for a session.
+ */
+export const restartInferenceSessionsSessionIdRestartPost = <ThrowOnError extends boolean = false>(options: Options<RestartInferenceSessionsSessionIdRestartPostData, ThrowOnError>) => {
+    return (options?.client ?? client).post<RestartInferenceSessionsSessionIdRestartPostResponse, RestartInferenceSessionsSessionIdRestartPostError, ThrowOnError>({
+        ...options,
+        url: '/sessions/{session_id}/restart'
+    });
+};
+
+/**
+ * Get System Info
+ * Get system information for debugging.
+ */
+export const getSystemInfoDebugSystemGet = <ThrowOnError extends boolean = false>(options?: Options<unknown, ThrowOnError>) => {
+    return (options?.client ?? client).get<GetSystemInfoDebugSystemGetResponse, GetSystemInfoDebugSystemGetError, ThrowOnError>({
+        ...options,
+        url: '/debug/system'
+    });
+};
+
+/**
+ * Get Recent Logs
+ * Get recent log entries for debugging.
+ */
+export const getRecentLogsDebugLogsGet = <ThrowOnError extends boolean = false>(options?: Options<unknown, ThrowOnError>) => {
+    return (options?.client ?? client).get<GetRecentLogsDebugLogsGetResponse, GetRecentLogsDebugLogsGetError, ThrowOnError>({
+        ...options,
+        url: '/debug/logs'
+    });
+};
+
+/**
+ * Debug Reset Session
+ * Reset a session's internal state for debugging.
+ */
+export const debugResetSessionDebugSessionsSessionIdResetPost = <ThrowOnError extends boolean = false>(options: Options<DebugResetSessionDebugSessionsSessionIdResetPostData, ThrowOnError>) => {
+    return (options?.client ?? client).post<DebugResetSessionDebugSessionsSessionIdResetPostResponse, DebugResetSessionDebugSessionsSessionIdResetPostError, ThrowOnError>({
+        ...options,
+        url: '/debug/sessions/{session_id}/reset'
+    });
+};
+
+/**
+ * Get Session Queue Info
+ * Get detailed information about a session's action queue.
+ */
+export const getSessionQueueInfoDebugSessionsSessionIdQueueGet = <ThrowOnError extends boolean = false>(options: Options<GetSessionQueueInfoDebugSessionsSessionIdQueueGetData, ThrowOnError>) => {
+    return (options?.client ?? client).get<GetSessionQueueInfoDebugSessionsSessionIdQueueGetResponse, GetSessionQueueInfoDebugSessionsSessionIdQueueGetError, ThrowOnError>({
+        ...options,
+        url: '/debug/sessions/{session_id}/queue'
+    });
+};

client/src/generated/types.gen.ts

@@ -0,0 +1,151 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+export type CreateSessionRequest = {
+    session_id: string;
+    policy_path: string;
+    camera_names?: Array<(string)>;
+    arena_server_url?: string;
+    workspace_id?: (string | null);
+    policy_type?: string;
+    language_instruction?: (string | null);
+};
+
+export type CreateSessionResponse = {
+    workspace_id: string;
+    camera_room_ids: {
+        [key: string]: (string);
+    };
+    joint_input_room_id: string;
+    joint_output_room_id: string;
+};
+
+export type HTTPValidationError = {
+    detail?: Array<ValidationError>;
+};
+
+export type SessionStatusResponse = {
+    session_id: string;
+    status: string;
+    policy_path: string;
+    policy_type: string;
+    camera_names: Array<(string)>;
+    workspace_id: string;
+    rooms: {
+        [key: string]: unknown;
+    };
+    stats: {
+        [key: string]: unknown;
+    };
+    inference_stats?: ({
+    [key: string]: unknown;
+} | null);
+    error_message?: (string | null);
+};
+
+export type ValidationError = {
+    loc: Array<(string | number)>;
+    msg: string;
+    type: string;
+};
+
+export type RootGetResponse = (unknown);
+
+export type RootGetError = unknown;
+
+export type HealthCheckHealthGetResponse = (unknown);
+
+export type HealthCheckHealthGetError = unknown;
+
+export type ListPoliciesPoliciesGetResponse = (unknown);
+
+export type ListPoliciesPoliciesGetError = unknown;
+
+export type ListSessionsSessionsGetResponse = (Array<SessionStatusResponse>);
+
+export type ListSessionsSessionsGetError = unknown;
+
+export type CreateSessionSessionsPostData = {
+    body: CreateSessionRequest;
+};
+
+export type CreateSessionSessionsPostResponse = (CreateSessionResponse);
+
+export type CreateSessionSessionsPostError = (HTTPValidationError);
+
+export type GetSessionStatusSessionsSessionIdGetData = {
+    path: {
+        session_id: string;
+    };
+};
+
+export type GetSessionStatusSessionsSessionIdGetResponse = (SessionStatusResponse);
+
+export type GetSessionStatusSessionsSessionIdGetError = (HTTPValidationError);
+
+export type DeleteSessionSessionsSessionIdDeleteData = {
+    path: {
+        session_id: string;
+    };
+};
+
+export type DeleteSessionSessionsSessionIdDeleteResponse = (unknown);
+
+export type DeleteSessionSessionsSessionIdDeleteError = (HTTPValidationError);
+
+export type StartInferenceSessionsSessionIdStartPostData = {
+    path: {
+        session_id: string;
+    };
+};
+
+export type StartInferenceSessionsSessionIdStartPostResponse = (unknown);
+
+export type StartInferenceSessionsSessionIdStartPostError = (HTTPValidationError);
+
+export type StopInferenceSessionsSessionIdStopPostData = {
+    path: {
+        session_id: string;
+    };
+};
+
+export type StopInferenceSessionsSessionIdStopPostResponse = (unknown);
+
+export type StopInferenceSessionsSessionIdStopPostError = (HTTPValidationError);
+
+export type RestartInferenceSessionsSessionIdRestartPostData = {
+    path: {
+        session_id: string;
+    };
+};
+
+export type RestartInferenceSessionsSessionIdRestartPostResponse = (unknown);
+
+export type RestartInferenceSessionsSessionIdRestartPostError = (HTTPValidationError);
+
+export type GetSystemInfoDebugSystemGetResponse = (unknown);
+
+export type GetSystemInfoDebugSystemGetError = unknown;
+
+export type GetRecentLogsDebugLogsGetResponse = (unknown);
+
+export type GetRecentLogsDebugLogsGetError = unknown;
+
+export type DebugResetSessionDebugSessionsSessionIdResetPostData = {
+    path: {
+        session_id: string;
+    };
+};
+
+export type DebugResetSessionDebugSessionsSessionIdResetPostResponse = (unknown);
+
+export type DebugResetSessionDebugSessionsSessionIdResetPostError = (HTTPValidationError);
+
+export type GetSessionQueueInfoDebugSessionsSessionIdQueueGetData = {
+    path: {
+        session_id: string;
+    };
+};
+
+export type GetSessionQueueInfoDebugSessionsSessionIdQueueGetResponse = (unknown);
+
+export type GetSessionQueueInfoDebugSessionsSessionIdQueueGetError = (HTTPValidationError);

src/inference_server.egg-info/PKG-INFO

@@ -14,7 +14,7 @@ Requires-Dist: httpx>=0.28.1
 Requires-Dist: huggingface-hub>=0.32.4
 Requires-Dist: imageio[ffmpeg]>=2.37.0
 Requires-Dist: lerobot
-Requires-Dist: robohub-transport-server-client
+Requires-Dist: robothub-transport-server-client
 Requires-Dist: numpy>=1.26.4
 Requires-Dist: opencv-python>=4.11.0.86
 Requires-Dist: opencv-python-headless>=4.11.0.86

src/inference_server.egg-info/requires.txt

@@ -8,7 +8,7 @@ httpx>=0.28.1
 huggingface-hub>=0.32.4
 imageio[ffmpeg]>=2.37.0
 lerobot
-robohub-transport-server-client
+robothub-transport-server-client
 numpy>=1.26.4
 opencv-python>=4.11.0.86
 opencv-python-headless>=4.11.0.86