@vibexp/api-client 0.8.0 → 0.9.0

package/dist/schema.d.ts

@@ -1322,35 +1322,6 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/bo/v1/embeddings/backfill": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        get?: never;
-        put?: never;
-        /**
-         * Regenerate embeddings
-         * @description Republishes the `.created` event for embeddable entities (prompts,
-         *     artifacts, memories, blueprints, and feed items) so the embedding pipeline
-         *     regenerates vectors under the currently configured embedding model. This is
-         *     the operational step after an embedding model or dimension change. The
-         *     operation is idempotent (the pipeline uses delete-then-insert per entity).
-         *
-         *     The scope is explicit: the request body must set exactly one of `all` or a
-         *     non-empty `entity_types`. Set `missing_only` to limit the run to entities
-         *     that lack an embedding for the configured model. This endpoint is for
-         *     administrative purposes only and requires the back office admin API key.
-         */
-        post: operations["backfillEmbeddings"];
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
     "/api/v1/{team_id}/integrations/github/status": {
         parameters: {
             query?: never;
@@ -2708,6 +2679,34 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/{team_id}/embedding-providers/coverage": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Team whose embedding coverage is reported. */
+                team_id: string;
+            };
+            cookie?: never;
+        };
+        /**
+         * Get embedding coverage
+         * @description Returns derived, team-scoped embedding coverage per entity type under the
+         *     team's active provider model: how many entities exist (`total`), how many
+         *     have an embedding (`embedded`), how many are still pending, and the
+         *     embedded percentage. Counts are computed from existing rows — there is no
+         *     per-entity state. When the team has no active provider, the response
+         *     reports every type as all-pending (0%) rather than an error.
+         */
+        get: operations["getEmbeddingCoverage"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/{team_id}/embedding-providers/{id}": {
         parameters: {
             query?: never;
@@ -2745,6 +2744,40 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/{team_id}/embedding-providers/{id}/reprocess": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Team that owns the embedding provider(s). */
+                team_id: string;
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Reprocess missing embeddings
+         * @description Re-drives embedding generation for the team's entities that are still
+         *     missing an embedding, through the concurrency-bounded embedding path so a
+         *     large run never fans out beyond the provider's configured concurrency. It
+         *     is the sanctioned replacement for the removed back-office backfill
+         *     endpoint.
+         *
+         *     The provider `{id}` is validated and authorized, but the work is
+         *     team-scoped: an embedding provider is per-team, so reprocess enqueues the
+         *     team's entity set (generated via the team's active provider). It returns
+         *     202 immediately and runs in the background; generation is idempotent
+         *     (delete-then-insert per entity) and a per-team in-flight guard makes
+         *     repeat calls safe (no double fan-out).
+         */
+        post: operations["reprocessEmbeddingProvider"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/{team_id}/embedding-providers/validate": {
         parameters: {
             query?: never;
@@ -2803,6 +2836,31 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/{team_id}/settings/embedding-providers/coverage": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Team whose embedding coverage is reported. */
+                team_id: string;
+            };
+            cookie?: never;
+        };
+        /**
+         * Get embedding coverage (Settings)
+         * @description Returns derived, team-scoped embedding coverage per entity type under the
+         *     team's active provider model (settings route). See `getEmbeddingCoverage`
+         *     for the payload semantics.
+         */
+        get: operations["getEmbeddingCoverageSettings"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/{team_id}/settings/embedding-providers/{id}": {
         parameters: {
             query?: never;
@@ -2841,6 +2899,35 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/{team_id}/settings/embedding-providers/{id}/reprocess": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Team that owns the embedding provider(s). */
+                team_id: string;
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Reprocess missing embeddings (Settings)
+         * @description Re-drives embedding generation for the team's entities that are still
+         *     missing an embedding, through the concurrency-bounded embedding path
+         *     (settings route). The provider `{id}` is validated and authorized, but the
+         *     work is team-scoped: an embedding provider is per-team, so reprocess
+         *     enqueues the team's entity set. It returns 202 immediately and runs in the
+         *     background; generation is idempotent and a per-team in-flight guard makes
+         *     repeat calls safe.
+         */
+        post: operations["reprocessEmbeddingProviderSettings"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/{team_id}/settings/embedding-providers/validate": {
         parameters: {
             query?: never;
@@ -4108,6 +4195,11 @@ export interface components {
              * @example 200
              */
             chunk_overlap: number;
+            /**
+             * @description Maximum number of simultaneous embedding requests VibeXP issues to this provider. Keep at 1 for single-threaded providers.
+             * @example 1
+             */
+            concurrency: number;
             /** @example false */
             is_default: boolean;
             /**
@@ -4152,6 +4244,11 @@ export interface components {
              * @example 200
              */
             chunk_overlap?: number;
+            /**
+             * @description Optional max simultaneous embedding requests to this provider; defaults to 1 when omitted.
+             * @example 1
+             */
+            concurrency?: number;
             /** @example false */
             is_default?: boolean;
             /**
@@ -4170,6 +4267,7 @@ export interface components {
             model?: string;
             chunk_size?: number;
             chunk_overlap?: number;
+            concurrency?: number;
             is_default?: boolean;
             /** Format: uri */
             base_url?: string;
@@ -4222,6 +4320,53 @@ export interface components {
                 error_details?: string;
             };
         };
+        /** @description Embedding coverage for a single entity type: how many entities exist, how many have an embedding under the team's active model, how many are still pending, and the embedded percentage. */
+        EmbeddingCoverageItem: {
+            /**
+             * @description The embeddable entity type this row reports on.
+             * @example prompt
+             * @enum {string}
+             */
+            entity_type: "prompt" | "artifact" | "memory" | "blueprint" | "feed_item";
+            /**
+             * Format: int64
+             * @description Total embeddable entities of this type owned by the team.
+             * @example 120
+             */
+            total: number;
+            /**
+             * Format: int64
+             * @description Entities of this type that already have an embedding under the team's active model.
+             * @example 90
+             */
+            embedded: number;
+            /**
+             * Format: int64
+             * @description Entities still missing an embedding (total − embedded).
+             * @example 30
+             */
+            pending: number;
+            /**
+             * @description Rounded percentage of entities embedded (embedded / total * 100); 0 when there are no entities of this type.
+             * @example 75
+             */
+            embedded_percent: number;
+        };
+        /** @description Derived, team-scoped embedding coverage per entity type under the team's active provider model. Counts are computed from existing rows (no per-entity state); a non-decreasing pending count is the signal that embedding is stuck. When the team has no active provider, has_active_provider is false, active_model is null, and every type reports all entities as pending (0%). */
+        EmbeddingCoverageResponse: {
+            /**
+             * @description Whether the team has an active embedding provider configured.
+             * @example true
+             */
+            has_active_provider: boolean;
+            /**
+             * @description The active provider's embedding model the embedded counts are measured against, or null when no provider is configured.
+             * @example text-embedding-3-small
+             */
+            active_model: string | null;
+            /** @description One entry per embeddable entity type, in a stable order. */
+            coverage: components["schemas"]["EmbeddingCoverageItem"][];
+        };
         ResourceUsageItem: {
             /**
              * @description Type of resource (e.g., prompt, memory, artifact)
@@ -6117,63 +6262,6 @@ export interface components {
             /** @description Total number of agent executions run by user */
             total_agent_executions_run?: number;
         };
-        /** @description Configuration for an embedding backfill run. The scope is explicit: set exactly one of `all` or a non-empty `entity_types`. Sending neither, or both, is rejected with a 400. */
-        EmbeddingBackfillRequest: {
-            /**
-             * @description Backfill every supported entity type. Mutually exclusive with `entity_types`.
-             * @default false
-             */
-            all: boolean;
-            /**
-             * @description Restrict the run to these entity types. Mutually exclusive with `all`.
-             * @example [
-             *       "prompt",
-             *       "artifact"
-             *     ]
-             */
-            entity_types?: ("prompt" | "artifact" | "memory" | "blueprint" | "feed_item")[];
-            /**
-             * @description When true, only publish for entities that do not already have an embedding for the currently configured model. Honored by `dry_run`.
-             * @default false
-             */
-            missing_only: boolean;
-            /**
-             * @description When true, count the entities that would be republished without publishing any event.
-             * @default false
-             */
-            dry_run: boolean;
-        };
-        /** @description Per-entity-type outcome of a backfill run. */
-        EmbeddingBackfillTypeResult: {
-            /** @example prompt */
-            entity_type: string;
-            /**
-             * @description Number of source entities seen for this type.
-             * @example 42
-             */
-            total: number;
-            /**
-             * @description Number of `.created` events successfully republished (0 on a dry run).
-             * @example 42
-             */
-            published: number;
-            /**
-             * @description Number of entities whose event publish failed (log-and-continue).
-             * @example 0
-             */
-            failed: number;
-        };
-        /** @description Aggregated result of an embedding backfill run. */
-        EmbeddingBackfillResult: {
-            dry_run: boolean;
-            results: components["schemas"]["EmbeddingBackfillTypeResult"][];
-            /** @example 42 */
-            total_seen: number;
-            /** @example 42 */
-            total_published: number;
-            /** @example 0 */
-            total_failed: number;
-        };
         /** @description Usage and growth data response */
         UsageAndGrowthResponse: {
             /** @description Weekly usage metrics */
@@ -12023,57 +12111,6 @@ export interface operations {
             };
         };
     };
-    backfillEmbeddings: {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        requestBody: {
-            content: {
-                "application/json": components["schemas"]["EmbeddingBackfillRequest"];
-            };
-        };
-        responses: {
-            /** @description Backfill completed; per-entity-type and aggregate counts returned. */
-            200: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": components["schemas"]["EmbeddingBackfillResult"];
-                };
-            };
-            /** @description Invalid request body, no scope (`all` and `entity_types` both empty), an ambiguous scope (both `all` and `entity_types` set), or an unsupported entity type was requested. */
-            400: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/problem+json": components["schemas"]["ErrorResponse"];
-                };
-            };
-            /** @description Unauthorized - Missing or invalid back office admin API key */
-            401: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/problem+json": components["schemas"]["ErrorResponse"];
-                };
-            };
-            /** @description Internal server error */
-            500: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/problem+json": components["schemas"]["ErrorResponse"];
-                };
-            };
-        };
-    };
     getGitHubStatus: {
         parameters: {
             query?: never;
@@ -16985,6 +17022,47 @@ export interface operations {
             };
         };
     };
+    getEmbeddingCoverage: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Team whose embedding coverage is reported. */
+                team_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Embedding coverage retrieved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["EmbeddingCoverageResponse"];
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Failed to retrieve embedding coverage (`DATABASE_ERROR`) */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
     getEmbeddingProvider: {
         parameters: {
             query?: never;
@@ -17161,6 +17239,58 @@ export interface operations {
             };
         };
     };
+    reprocessEmbeddingProvider: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Team that owns the embedding provider(s). */
+                team_id: string;
+                /** @description Embedding provider ID */
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Reprocess accepted; embeddings are regenerated in the background. */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SuccessResponse"];
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Embedding provider not found (`PROVIDER_NOT_FOUND`) */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Failed to load the provider before reprocess (`DATABASE_ERROR`) */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
     validateEmbeddingProvider: {
         parameters: {
             query?: never;
@@ -17319,6 +17449,47 @@ export interface operations {
             };
         };
     };
+    getEmbeddingCoverageSettings: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Team whose embedding coverage is reported. */
+                team_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Embedding coverage retrieved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["EmbeddingCoverageResponse"];
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Failed to retrieve embedding coverage (`DATABASE_ERROR`) */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
     getEmbeddingProviderSettings: {
         parameters: {
             query?: never;
@@ -17495,6 +17666,58 @@ export interface operations {
             };
         };
     };
+    reprocessEmbeddingProviderSettings: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Team that owns the embedding provider(s). */
+                team_id: string;
+                /** @description Embedding provider ID */
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Reprocess accepted; embeddings are regenerated in the background. */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SuccessResponse"];
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Embedding provider not found (`PROVIDER_NOT_FOUND`) */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Failed to load the provider before reprocess (`DATABASE_ERROR`) */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
     validateEmbeddingProviderSettings: {
         parameters: {
             query?: never;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibexp/api-client",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Typed VibeXP API client generated from the OpenAPI spec (openapi-fetch main entrypoint, axios SDK at ./axios)",
   "license": "MIT",
   "repository": {