@abloatai/ablo 0.27.0 → 0.29.0

package/dist/adapters/inMemoryStorage.js

@@ -22,10 +22,23 @@ export class InMemoryObjectStore {
             this.indexes.set(name, new Map());
         }
     }
-    async put(record) {
+    add(record) {
         const id = record.id;
         if (!id)
-            return;
+            throw new TypeError('In-memory record must carry an id');
+        if (this.data.has(id)) {
+            const error = new Error(`Record already exists: ${id}`);
+            error.name = 'ConstraintError';
+            throw error;
+        }
+        this.data.set(id, { ...record });
+        this.addToIndexes(id, record);
+        return Promise.resolve();
+    }
+    put(record) {
+        const id = record.id;
+        if (!id)
+            return Promise.resolve();
         // Remove from old index entries if updating
         const existing = this.data.get(id);
         if (existing) {
@@ -33,24 +46,26 @@ export class InMemoryObjectStore {
         }
         this.data.set(id, { ...record });
         this.addToIndexes(id, record);
+        return Promise.resolve();
     }
-    async get(id) {
-        return this.data.get(id);
+    get(id) {
+        return Promise.resolve(this.data.get(id));
     }
-    async getAll() {
-        return [...this.data.values()];
+    getAll() {
+        return Promise.resolve([...this.data.values()]);
     }
-    async delete(id) {
+    delete(id) {
         const existing = this.data.get(id);
         if (existing) {
             this.removeFromIndexes(id, existing);
             this.data.delete(id);
         }
+        return Promise.resolve();
     }
-    async getAllFromIndex(indexName, value) {
+    getAllFromIndex(indexName, value) {
         const index = this.indexes.get(indexName);
         if (!index)
-            return [];
+            return Promise.resolve([]);
         // The in-memory index stores values as strings (it doesn't support
         // the full IDB key range — Date / BufferSource / arrays). For the
         // overwhelmingly-common case of string FK ids, coercing through
@@ -58,16 +73,17 @@ export class InMemoryObjectStore {
         // shared `ObjectStoreContract` signature.
         const ids = index.get(String(value));
         if (!ids)
-            return [];
-        return [...ids]
+            return Promise.resolve([]);
+        return Promise.resolve([...ids]
             .map((id) => this.data.get(id))
-            .filter((r) => r != null);
+            .filter((r) => r != null));
     }
-    async clear() {
+    clear() {
         this.data.clear();
         for (const index of this.indexes.values()) {
             index.clear();
         }
+        return Promise.resolve();
     }
     /** No-op — in-memory stores don't need closing. */
     markAsClosing() { }

package/dist/ai-sdk/coordinatedTool.d.ts

@@ -58,7 +58,9 @@
  *   first-in-first-out, which would require a persistent connection.
  */
 import type { z } from 'zod';
-import type { ModelOperations } from '../client/createModelProxy.js';
+import type { ClaimParams, ModelRetrieveParams, ModelUpdateParams } from '../client/createModelProxy.js';
+import type { ModelUpdater, ContentionOptions } from '../client/functionalUpdate.js';
+import type { HeldClaim } from '../types/streams.js';
 export type CoordinationStrategy = 'merge' | 'claim' | 'queue';
 /** The structured result the tool hands back to the model (or the caller). */
 export interface CoordinatedWriteResult<T> {
@@ -105,4 +107,15 @@ export interface CoordinatedToolOptions<TInput, T> {
         timeoutMs?: number;
     };
 }
-export declare function coordinatedTool<TInput, T = Record<string, unknown>, CreateInput = Partial<T>>(model: ModelOperations<T, CreateInput>, options: CoordinatedToolOptions<TInput, T>): import("ai").Tool<TInput, CoordinatedWriteResult<T>>;
+/**
+ * The small model port this helper needs. Both typed transports implement this
+ * exact contract; local-cache methods, wire receipts, and transport lifecycle
+ * deliberately stay out of an AI tool's dependency surface.
+ */
+export interface CoordinatedModel<T> {
+    retrieve(params: ModelRetrieveParams): Promise<T | undefined>;
+    update(params: ModelUpdateParams<T>): Promise<T>;
+    update(id: string, updater: ModelUpdater<T>, options?: ContentionOptions): Promise<T | undefined>;
+    claim(params: ClaimParams<T>): Promise<HeldClaim<T>>;
+}
+export declare function coordinatedTool<TInput, T = Record<string, unknown>>(model: CoordinatedModel<T>, options: CoordinatedToolOptions<TInput, T>): import("ai").Tool<TInput, CoordinatedWriteResult<T>>;

package/dist/auth/schemas.d.ts

@@ -27,6 +27,12 @@ export declare const IdentityResolveResponseSchema: z.ZodObject<{
     }>;
     participantId: z.ZodString;
     accountScope: z.ZodString;
+    projectId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    environment: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        production: "production";
+        sandbox: "sandbox";
+    }>>>;
+    sandboxId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     syncGroups: z.ZodArray<z.ZodString>;
     userMeta: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 }, z.core.$loose>;

package/dist/auth/schemas.js

@@ -25,6 +25,13 @@ export const IdentityResolveResponseSchema = z
     participantKind: AuthParticipantKindSchema,
     participantId: z.string().min(1),
     accountScope: z.string().min(1),
+    // The rest of the plane this credential resolves to. `nullish` (optional +
+    // nullable) so a server too old to send them still parses, and a human
+    // session — which carries no such scope — validates with them absent.
+    // `projectId` equals the org id for the org-default project.
+    projectId: z.string().min(1).nullish(),
+    environment: z.enum(['sandbox', 'production']).nullish(),
+    sandboxId: z.string().min(1).nullish(),
     syncGroups: z.array(z.string()),
     userMeta: z.record(z.string(), z.unknown()),
 })