@abloatai/transaction 0.37.1 → 0.39.0

package/src/schema/select.ts

@@ -80,9 +80,39 @@ export function selectModels<S extends SchemaRecord, K extends keyof S & string>
     // subset still points at the original full schema rather than an intermediate
     // one. `schemaHash` ignores this field, so re-projecting stays deterministic.
     sourceSchemaHash: schema.sourceSchemaHash ?? schemaHash(schema),
+    // What was dropped, unioned with what the source had already dropped, so a
+    // subset-of-a-subset still names every model of the original full schema
+    // that this client cannot reach. Clients turn these names into throwing
+    // accessors — see `omittedModelError`.
+    omittedModels: [
+      ...new Set([
+        ...(schema.omittedModels ?? []),
+        ...Object.keys(schema.models).filter((k) => !keep.has(k)),
+      ]),
+    ].sort(),
   };
 }
 
+/**
+ * The error a client raises when a caller reaches for a model its schema
+ * projection left out.
+ *
+ * Defined beside the projection because the two are one contract: what
+ * `selectModels` records in `omittedModels`, a client answers with this error.
+ * Without it the access reads as `undefined` and the caller crashes one
+ * property later with a bare TypeError that never names the model or the fix —
+ * which is exactly what happens when an app compiles against the full source
+ * schema but runs a projection, the one misuse the type system cannot see.
+ */
+export function omittedModelError(model: string): AbloValidationError {
+  return new AbloValidationError(
+    `The ${model} model is not in this client's schema. ` +
+      `The schema is a projection that leaves ${model} out, so this client cannot read or write it. ` +
+      `Add '${model}' to the projection's model list to use it here.`,
+    { code: 'model_not_in_schema', param: model },
+  );
+}
+
 /**
  * `omitModels` is `selectModels` from the other side: keep every model EXCEPT
  * the named ones. Use it when an app is the general case and a separate app

package/src/server/commit.ts

@@ -16,7 +16,6 @@
 import type { ParticipantKind, ConfirmationState } from '../log/syncDeltaRow.js';
 import type { ParticipantRef } from '../wire/delta.js';
 import type { CommitExecutionResultInput } from '../wire/commit.js';
-import type { Environment } from '../environment.js';
 import type { ReadDependency, TrackDependency } from '../coordination/schema.js';
 
 export interface CommitContext {
@@ -27,21 +26,15 @@ export interface CommitContext {
    */
   participantKind: ParticipantKind;
   organizationId: string;
+  /** Immutable branch selected by the authenticated credential. */
+  branchId: string;
   /**
    * Project scope used to route source-mode storage. When omitted, the commit
    * targets the organization's default project.
    */
   projectId?: string;
-  /** Exact sandbox plane derived from the authenticated key, when present. */
-  sandboxId?: string;
   /** Optional external account scope forwarded to storage resolvers. */
   accountScope?: string;
-  /**
-   * The environment this commit runs in. Source-mode adapters forward it to the
-   * customer's handlers so that sandbox and production traffic can reach distinct
-   * customer-owned stores.
-   */
-  environment?: Environment;
   /**
    * The sync groups this participant subscribes to, taken from the connection
    * upgrade or the capability token. Each is appended to every delta's `sync_groups`
@@ -50,12 +43,6 @@ export interface CommitContext {
    * commit fans out to just the organization and user groups.
    */
   syncGroups?: readonly string[];
-  /**
-   * When true, the commit does not add `org:<organizationId>` to a delta's sync
-   * groups. Set this for sandbox writes, so that live organization subscribers do
-   * not receive test-environment changes.
-   */
-  omitOrgSyncGroup?: boolean;
   /**
    * The participant on whose authority the actor acted. For a direct human commit
    * this equals the actor; for an agent commit it is the human at the root of the

package/src/source/adapter.ts

@@ -1,11 +1,13 @@
 /**
  * The canonical interface every data-source backend implements, together with the bridge
  * that wires an implementation into the `dataSource()` HTTP handler. This package
- * defines the contract and ships adapters for three object-relational mappers —
+ * defines the contract and ships PostgreSQL bindings for three object-relational mappers —
  * {@link prismaDataSource}, {@link drizzleDataSource}, and {@link kyselyDataSource} —
  * each verified by shared mutation checks plus endpoint-only outbox checks. The
  * direct Kysely wrapper runs only the shared mutation contract. You can also
- * write your own.
+ * write your own through the `defineDatabaseAdapter` factory. PostgreSQL, the ORM
+ * binding, and WAL/outbox observation are recorded as separate profile axes;
+ * an ORM name never implies database portability.
  *
  * An endpoint adapter reads and writes your database, and it owns the transactional
  * outbox and idempotency bookkeeping as well, so you never write those by hand.
@@ -29,6 +31,7 @@ import type {
   EventsPage,
   Migration,
 } from './contract.js';
+import type { DatabaseAdapterProfile } from './adapterProfile.js';
 
 /**
  * A single row keyed by the schema's field names (for example `operatorId`), not
@@ -57,6 +60,8 @@ export interface AdapterCommitResult {
  * transaction id is never used as that namespace.
  */
 export interface MutationAdapter {
+  /** Database, binding, and observation are separate, explicit axes. */
+  readonly profile: DatabaseAdapterProfile;
   readonly capabilities: AdapterCapabilities;
   /** Infrastructure migrations required by this wrapper's advertised capabilities. */
   migrations(): readonly Migration[];

package/src/source/adapterFactory.ts

@@ -0,0 +1,60 @@
+/**
+ * Normalizes and validates a database adapter declaration.
+ *
+ * Database integrations should return through this function rather than
+ * assembling an object directly. It is the single place that relates database,
+ * binding, observation, and advertised guarantees.
+ */
+
+import { AbloValidationError } from '../errors.js';
+import type { MutationAdapter } from './adapter.js';
+import { databaseAdapterProfileSchema } from './adapterProfile.js';
+
+export function defineDatabaseAdapter<T extends MutationAdapter>(
+  adapter: T,
+): T {
+  const profile = databaseAdapterProfileSchema.parse(adapter.profile);
+  const { capabilities } = adapter;
+
+  if (!capabilities.transactions) {
+    throw new AbloValidationError(
+      `Database adapter "${profile.id}" cannot provide Ablo commits without atomic transactions`,
+      { code: 'source_adapter_misconfigured' },
+    );
+  }
+
+  if (
+    capabilities.postgresWalEcho === true &&
+    profile.database !== 'postgresql'
+  ) {
+    throw new AbloValidationError(
+      `Database adapter "${profile.id}" advertises a PostgreSQL WAL marker on ${profile.database}`,
+      { code: 'source_adapter_misconfigured' },
+    );
+  }
+
+  if (profile.observation.kind === 'postgres-wal') {
+    if (
+      profile.database !== 'postgresql' ||
+      capabilities.postgresWalEcho !== true ||
+      capabilities.outboxEvents
+    ) {
+      throw new AbloValidationError(
+        `Database adapter "${profile.id}" has an invalid PostgreSQL WAL capability combination`,
+        { code: 'source_adapter_misconfigured' },
+      );
+    }
+  }
+
+  if (
+    profile.observation.kind === 'transactional-outbox' &&
+    !capabilities.outboxEvents
+  ) {
+    throw new AbloValidationError(
+      `Database adapter "${profile.id}" declares an outbox observation profile without outbox events`,
+      { code: 'source_adapter_misconfigured' },
+    );
+  }
+
+  return { ...adapter, profile } as T;
+}

package/src/source/adapterProfile.ts

@@ -0,0 +1,75 @@
+/**
+ * The three independent axes of a customer-database adapter.
+ *
+ * An ORM binding is not a database, and a database is not an observation
+ * strategy. Keeping them separate prevents a Prisma or Kysely adapter from
+ * looking portable while depending on PostgreSQL SQL or WAL underneath.
+ */
+
+import { z } from 'zod';
+
+export const databaseKindSchema = z.enum(['postgresql', 'memory']);
+export type DatabaseKind = z.infer<typeof databaseKindSchema>;
+
+export const adapterBindingSchema = z.enum([
+  'prisma',
+  'drizzle',
+  'kysely',
+  'memory',
+  'custom',
+]);
+export type AdapterBinding = z.infer<typeof adapterBindingSchema>;
+
+export const observationProfileSchema = z.discriminatedUnion('kind', [
+  z.strictObject({
+    kind: z.literal('transactional-outbox'),
+    externalWrites: z.boolean(),
+  }),
+  z.strictObject({
+    kind: z.literal('postgres-wal'),
+    externalWrites: z.literal(true),
+  }),
+]);
+export type ObservationProfile = z.infer<typeof observationProfileSchema>;
+
+export const databaseAdapterProfileSchema = z.strictObject({
+  id: z.string().min(1),
+  database: databaseKindSchema,
+  binding: adapterBindingSchema,
+  observation: observationProfileSchema,
+});
+export type DatabaseAdapterProfile = z.infer<
+  typeof databaseAdapterProfileSchema
+>;
+
+export type PostgresBinding = Extract<
+  AdapterBinding,
+  'prisma' | 'drizzle' | 'kysely' | 'custom'
+>;
+
+export function postgresAdapterProfile(
+  binding: PostgresBinding,
+  observation: 'transactional-outbox' | 'postgres-wal',
+): DatabaseAdapterProfile {
+  return {
+    id: `postgresql-${binding}-${observation}`,
+    database: 'postgresql',
+    binding,
+    observation:
+      observation === 'postgres-wal'
+        ? { kind: 'postgres-wal', externalWrites: true }
+        : { kind: 'transactional-outbox', externalWrites: false },
+  };
+}
+
+export function memoryAdapterProfile(): DatabaseAdapterProfile {
+  return {
+    id: 'memory-native-transactional-outbox',
+    database: 'memory',
+    binding: 'memory',
+    observation: {
+      kind: 'transactional-outbox',
+      externalWrites: false,
+    },
+  };
+}

package/src/source/adapters/drizzle.ts

@@ -42,6 +42,8 @@ import type {
   DataSourceAdapter,
   Row,
 } from '../adapter.js';
+import { defineDatabaseAdapter } from '../adapterFactory.js';
+import { postgresAdapterProfile } from '../adapterProfile.js';
 import type { ChangeSet, EventsPage, Migration, Operation } from '../contract.js';
 import { outboxEventSchema } from '../contract.js';
 import { adapterTableMigrations } from '../migrations.js';
@@ -188,7 +190,8 @@ export function drizzleDataSource<S extends SchemaRecord>(
     return updated[0] ? toFields(mc, updated[0]) : { id, ...input };
   };
 
-  return {
+  return defineDatabaseAdapter({
+    profile: postgresAdapterProfile('drizzle', 'transactional-outbox'),
     capabilities: {
       transactions: true,
       propose: false,
@@ -287,5 +290,5 @@ export function drizzleDataSource<S extends SchemaRecord>(
       );
       return { events, nextCursor: events.at(-1)?.cursor ?? null };
     },
-  };
+  });
 }

package/src/source/adapters/kysely.ts

@@ -25,6 +25,8 @@ import type {
   MutationAdapter,
   Row,
 } from '../adapter.js';
+import { defineDatabaseAdapter } from '../adapterFactory.js';
+import { postgresAdapterProfile } from '../adapterProfile.js';
 import type { ChangeSet, EventsPage, Migration } from '../contract.js';
 import {
   changeSetSchema,
@@ -199,7 +201,11 @@ export function createKyselyMutationAdapter(
   options: KyselyMutationAdapterOptions = {},
 ): MutationAdapter {
   const markerModelFor = options.markerModelFor ?? ((model: string) => model);
-  return {
+  return defineDatabaseAdapter({
+    profile: postgresAdapterProfile(
+      'kysely',
+      mode === 'direct' ? 'postgres-wal' : 'transactional-outbox',
+    ),
     capabilities: {
       transactions: true,
       propose: false,
@@ -281,7 +287,7 @@ export function createKyselyMutationAdapter(
         return { rows };
       });
     },
-  };
+  });
 }
 
 /** Endpoint wrapper: mutation + ledger + outbox, with an optional marker. */
@@ -295,7 +301,7 @@ export function kyselyDataSource<S extends SchemaRecord>(
     'endpoint',
   );
 
-  return {
+  return defineDatabaseAdapter({
     ...mutation,
     capabilities: { ...mutation.capabilities, outboxEvents: true },
 
@@ -324,7 +330,7 @@ export function kyselyDataSource<S extends SchemaRecord>(
       );
       return { events, nextCursor: events.at(-1)?.cursor ?? null };
     },
-  };
+  });
 }
 
 /** Direct wrapper: mutation + ledger + required logical marker, never outbox. */

package/src/source/adapters/memory.ts

@@ -17,6 +17,8 @@ import type {
   DataSourceAdapter,
   Row,
 } from '../adapter.js';
+import { defineDatabaseAdapter } from '../adapterFactory.js';
+import { memoryAdapterProfile } from '../adapterProfile.js';
 import type { ChangeSet, EventsPage, Migration, Operation, OutboxEvent } from '../contract.js';
 import {
   assertSourceIdempotencyIntent,
@@ -81,7 +83,8 @@ export function memoryDataSource(): DataSourceAdapter {
     }
   };
 
-  return {
+  return defineDatabaseAdapter({
+    profile: memoryAdapterProfile(),
     capabilities: {
       transactions: true,
       propose: false,
@@ -150,5 +153,5 @@ export function memoryDataSource(): DataSourceAdapter {
         nextCursor: page.at(-1)?.cursor ?? null,
       };
     },
-  };
+  });
 }

package/src/source/adapters/prisma.ts

@@ -21,6 +21,8 @@ import type {
   DataSourceAdapter,
   Row,
 } from '../adapter.js';
+import { defineDatabaseAdapter } from '../adapterFactory.js';
+import { postgresAdapterProfile } from '../adapterProfile.js';
 import type { ChangeSet, EventsPage, Migration, Operation, OutboxEvent } from '../contract.js';
 import { outboxEventSchema } from '../contract.js';
 import { adapterTableMigrations } from '../migrations.js';
@@ -163,7 +165,8 @@ export function prismaDataSource<S extends SchemaRecord>(
     }
   };
 
-  return {
+  return defineDatabaseAdapter({
+    profile: postgresAdapterProfile('prisma', 'transactional-outbox'),
     capabilities: {
       transactions: true,
       propose: false,
@@ -278,5 +281,5 @@ export function prismaDataSource<S extends SchemaRecord>(
         nextCursor: events.at(-1)?.cursor ?? null,
       };
     },
-  };
+  });
 }

package/src/source/conformance.ts

@@ -59,6 +59,16 @@ export function mutationConformanceChecks(
     return options.prepareChange?.(value) ?? value;
   };
   return [
+    {
+      name: 'adapter declares database, binding, and observation independently',
+      run: async () => {
+        const adapter = await make();
+        assert.ok(adapter.profile.id.length > 0);
+        assert.ok(adapter.profile.database.length > 0);
+        assert.ok(adapter.profile.binding.length > 0);
+        assert.ok(adapter.profile.observation.kind.length > 0);
+      },
+    },
     {
       name: 'commit applies a CREATE and returns the canonical row',
       run: async () => {
@@ -174,6 +184,14 @@ export function mutationConformanceChecks(
 /** Guarantees that apply only to endpoint wrappers with an outbox/events feed. */
 export function endpointConformanceChecks(make: MakeAdapter): ConformanceCheck[] {
   return [
+    {
+      name: 'endpoint adapter declares transactional-outbox observation',
+      run: async () => {
+        const adapter = await make();
+        assert.equal(adapter.profile.observation.kind, 'transactional-outbox');
+        assert.equal(adapter.capabilities.outboxEvents, true);
+      },
+    },
     {
       name: 'endpoint replay does not append its correlated outbox event twice',
       run: async () => {

package/src/source/index.ts

@@ -109,6 +109,20 @@ export {
   type AdapterCommitResult,
   type Row as AdapterRow,
 } from './adapter.js';
+export {
+  adapterBindingSchema,
+  databaseAdapterProfileSchema,
+  databaseKindSchema,
+  memoryAdapterProfile,
+  observationProfileSchema,
+  postgresAdapterProfile,
+  type AdapterBinding,
+  type DatabaseAdapterProfile,
+  type DatabaseKind,
+  type ObservationProfile,
+  type PostgresBinding,
+} from './adapterProfile.js';
+export { defineDatabaseAdapter } from './adapterFactory.js';
 export {
   operationSchema,
   operationTypeSchema,

package/src/source/types.ts

@@ -11,7 +11,6 @@
  */
 
 import { AbloValidationError } from '../errors.js';
-import type { Environment } from '../environment.js';
 import type { CommitOperationType, OnStaleMode } from '../coordination/schema.js';
 import type { ParticipantKind } from '../types/participant.js';
 
@@ -88,21 +87,11 @@ export interface SourceRequestContext {
   readonly participantId?: string;
   readonly participantKind?: ParticipantKind;
   readonly organizationId?: string;
-  /** Trusted project plane selected by the authenticating credential. */
+  /** Immutable branch selected by the authenticating credential. */
+  readonly branchId?: string;
+  /** Trusted project selected by the authenticating credential. */
   readonly projectId?: string;
-  /** Trusted sandbox plane selected by the authenticating credential. */
-  readonly sandboxId?: string;
   readonly requiredSyncGroups?: readonly string[];
-  /**
-   * Whether this request runs in production or sandbox mode. Branch your
-   * handlers on it — for example, read and write a separate sandbox database
-   * when `mode === 'sandbox'` — so sandbox traffic exercises the same code
-   * against isolated data. Keeping the two apart is your handler's
-   * responsibility, since your database holds the canonical rows.
-   *
-   * Defaults to `'production'` when omitted.
-   */
-  readonly mode?: Environment;
 }
 
 /**

package/src/syncLog/contract.ts

@@ -1,7 +1,6 @@
 /** Canonical sync-log identity and position contracts shared by client/server. */
 
 import { z } from 'zod';
-import { environmentSchema } from '../environment.js';
 
 export const deltaPositionSchema = z.number().int().nonnegative();
 export type DeltaPosition = z.infer<typeof deltaPositionSchema>;
@@ -21,7 +20,7 @@ export type ReplicationLSN = z.infer<typeof replicationLsnSchema>;
 export const commitDispatchMarkerSchema = z.strictObject({
   kind: z.literal('sync_deltas'),
   organizationId: z.string().min(1),
-  environment: environmentSchema,
+  branchId: z.string().min(1),
   firstSyncId: deltaPositionSchema,
   lastSyncId: deltaPositionSchema,
 }).superRefine((value, ctx) => {

package/src/transport/httpClient.ts

@@ -45,6 +45,7 @@ import type {
   ModelUpdateParams,
 } from '../resources/modelOperations.js';
 import type { Schema, SchemaRecord, InferModel, InferCreate } from '../schema/schema.js';
+import { omittedModelError } from '../schema/select.js';
 import type { ModelUpdater, ContentionOptions } from '../resources/functionalUpdate.js';
 import { AbloConnectionError, AbloValidationError } from '../errors.js';
 
@@ -319,6 +320,7 @@ export function createAbloHttpClient<S extends SchemaRecord>(
     modelTypenames: modelWireNames(schema.models),
   });
   const schemaModels = new Set(Object.keys(schema.models));
+  const omittedModels = new Set(schema.omittedModels ?? []);
   const models = new Map<
     string,
     HttpModelClient<Record<string, unknown>, Record<string, unknown>>
@@ -343,7 +345,12 @@ export function createAbloHttpClient<S extends SchemaRecord>(
       }
       // Only schema models become model accessors. A typo or retired top-level
       // member resolves to undefined instead of manufacturing a plausible client.
-      return schemaModels.has(prop) ? model(prop) : undefined;
+      if (schemaModels.has(prop)) return model(prop);
+      // A model the schema projection left out is neither a typo nor a member:
+      // the caller compiled against the full source schema, so answer with the
+      // error that names the model and the fix rather than `undefined`.
+      if (omittedModels.has(prop)) throw omittedModelError(prop);
+      return undefined;
     },
   });
 

package/src/wire/accountResponses.ts

@@ -63,18 +63,17 @@ export type ProvisionedKey = z.infer<typeof provisionedKeySchema>;
 
 /**
  * What the CLI device flow gets back once a browser approval is exchanged for
- * credentials: the sandbox key `ablo push` authors with, and the restricted
- * production key that only observes.
+ * a project-scoped control-plane management credential. Runtime branch
+ * credentials are minted separately by `ablo dev` / `ablo branch credential`.
  *
- * `project` is the project both keys are scoped to, resolved SERVER-SIDE from
+ * `project` is the project the management credential is scoped to, resolved SERVER-SIDE from
  * the requested slug — null means the organization's default. The server's
  * answer is authoritative because it is what resolved the slug to an id, so the
- * CLI stores keys under the project named here rather than the one it asked
+ * CLI stores the credential under the project named here rather than the one it asked
  * for.
  */
 export const provisionKeyResponseSchema = z.object({
-  test: provisionedKeySchema,
-  live: provisionedKeySchema.optional(),
+  management: provisionedKeySchema,
   organizationId: z.string().optional(),
   organizationSlug: z.string().optional(),
   project: z.object({ id: z.string(), slug: z.string() }).nullable().optional(),

package/src/wire/auth.ts

@@ -11,7 +11,7 @@
  */
 
 import { z } from 'zod';
-import { grantedOperationSchema } from '../auth/capability.js';
+import { capabilityOperationSchema, grantedOperationSchema } from '../auth/capability.js';
 import { syncGroupInputSchema } from '../coordination/schema.js';
 
 /** The participant this session acts as. */
@@ -48,8 +48,25 @@ export const ephemeralKeyRequestSchema = z.object({
   schemaOwnerOrgId: z.string().min(1).optional(),
   /** Narrow the session to these sync groups. */
   syncGroups: z.array(syncGroupInputSchema).readonly().optional(),
-  /** Required least-privilege allowlist. */
-  operations: z.array(grantedOperationSchema).min(1),
+  /**
+   * Least-privilege allowlist, named model by model. For a caller that knows
+   * the schema the session will resolve. Exactly one of this and
+   * {@link ephemeralKeyRequestSchema.shape.activeSchemaOperations} is required.
+   */
+  operations: z.array(grantedOperationSchema).min(1).optional(),
+  /**
+   * The same allowlist expressed as verbs alone, for a caller that CANNOT know
+   * the models: an identity service minting sessions for organizations whose
+   * schemas it does not own has no way to name them, and a grant is checked
+   * against the session's schema at mint time, so naming another schema's
+   * models fails every time.
+   *
+   * The server expands these across the models in the session's active schema
+   * and stores the concrete result, so what lands on the credential is the same
+   * enumerated allowlist as the field above. A verb is granted only where the
+   * model admits it — an immutable model takes `read` and nothing else.
+   */
+  activeSchemaOperations: z.array(capabilityOperationSchema).min(1).optional(),
   /** Lifetime in seconds. Capped by the server's maximum. */
   ttlSeconds: z.number().int().positive().optional(),
   /** A human-readable tag recorded with the key, for debugging. */
@@ -63,6 +80,16 @@ export const ephemeralKeyRequestSchema = z.object({
       'schemaProjectId and schemaOwnerOrgId must be provided together',
     path: ['schemaProjectId'],
   },
+).refine(
+  (request) =>
+    (request.operations === undefined) !== (request.activeSchemaOperations === undefined),
+  {
+    // Exactly one, never both and never neither. Neither would leave the
+    // credential with an empty allowlist, which reads as UNRESTRICTED at the
+    // gate rather than as nothing; both would leave two answers to one question.
+    message: 'provide either operations or activeSchemaOperations, not both',
+    path: ['operations'],
+  },
 );
 export type EphemeralKeyRequest = z.infer<typeof ephemeralKeyRequestSchema>;
 

package/src/wire/delta.ts

@@ -66,6 +66,17 @@ export type SyncDeltaAction = z.infer<typeof syncDeltaActionSchema>;
  * serialized string (used by the group-change frames on `G` and `S` deltas), or
  * `null` on deletes. This is wider than the stored row's payload — which is only a
  * row or null — because the group-change frames encode their payload as a string.
+ *
+ * The record branch costs more than its contract suggests: it walks
+ * `Reflect.ownKeys` and rebuilds the payload into a fresh object on every parse,
+ * so client-side validation scales with a row's field count on a path that runs
+ * once per delta (2.7 microseconds at 23 fields, against 0.15 for a predicate).
+ * Replacing it was tried and reverted, because every faster spelling gives up
+ * something this contract owns: `z.custom` cannot be represented in JSON Schema
+ * and breaks the derived spec, and `z.unknown().refine` derives to an empty
+ * schema and infers `unknown`, which would widen {@link WireDeltaData}. A
+ * predicate must also match this schema's real acceptance, which is
+ * plain-object: `z.record` rejects `Date`, `Map`, and class instances.
  */
 export const wireDeltaDataSchema = z
   .union([z.record(z.string(), z.unknown()), z.string()])

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

@@ -1 +0,0 @@
-{"version":3,"file":"coordinatedTool.d.ts","sourceRoot":"","sources":["../../src/ai-sdk/coordinatedTool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AAGH,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,OAAO,KAAK,EACV,WAAW,EACX,mBAAmB,EACnB,iBAAiB,EAClB,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACxF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAErD,MAAM,MAAM,oBAAoB,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;AAE/D,8EAA8E;AAC9E,MAAM,WAAW,sBAAsB,CAAC,CAAC;IACvC;;;;;OAKG;IACH,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;IAC1C,0CAA0C;IAC1C,GAAG,CAAC,EAAE,CAAC,CAAC;IACR,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iFAAiF;IACjF,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,sBAAsB,CAAC,MAAM,EAAE,CAAC;IAC/C,2CAA2C;IAC3C,WAAW,EAAE,MAAM,CAAC;IACpB,sFAAsF;IACtF,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAC/B,iEAAiE;IACjE,EAAE,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IAC9B;;;;;;OAMG;IACH,KAAK,EAAE,CAAC,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;IACjD,4DAA4D;IAC5D,QAAQ,CAAC,EAAE,oBAAoB,CAAC;IAChC,kHAAkH;IAClH,KAAK,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACjC,kGAAkG;IAClG,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,kFAAkF;IAClF,IAAI,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACpD;AAID;;;;GAIG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC;IACjC,GAAG,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;IACzD,qCAAqC;IACrC,QAAQ,CAAC,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;IAC/D,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IACjD,MAAM,CACJ,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,EACxB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;IAC1B,KAAK,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;CACtD;AAED,wBAAgB,eAAe,CAC7B,MAAM,EACN,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC3B,KAAK,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,sBAAsB,CAAC,MAAM,EAAE,CAAC,CAAC,wDA4EvE"}

package/dist/ai-sdk/coordinatedTool.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"coordinatedTool.js","sourceRoot":"","sources":["../../src/ai-sdk/coordinatedTool.ts"],"names":[],"mappings":"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"}