@dxos/functions-runtime-cloudflare 0.8.4-main.3c1ae3b → 0.8.4-main.3fbcb4aa9b

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "@dxos/functions-runtime-cloudflare",
-  "version": "0.8.4-main.3c1ae3b",
+  "version": "0.8.4-main.3fbcb4aa9b",
   "description": "Functions runtime for Cloudflare.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dxos/dxos"
+  },
   "license": "MIT",
   "author": "info@dxos.org",
   "sideEffects": false,
@@ -23,23 +27,23 @@
     "src"
   ],
   "dependencies": {
-    "effect": "3.18.3",
-    "@dxos/codec-protobuf": "0.8.4-main.3c1ae3b",
-    "@dxos/context": "0.8.4-main.3c1ae3b",
-    "@dxos/debug": "0.8.4-main.3c1ae3b",
-    "@dxos/echo": "0.8.4-main.3c1ae3b",
-    "@dxos/errors": "0.8.4-main.3c1ae3b",
-    "@dxos/echo-db": "0.8.4-main.3c1ae3b",
-    "@dxos/echo-protocol": "0.8.4-main.3c1ae3b",
-    "@dxos/log": "0.8.4-main.3c1ae3b",
-    "@dxos/protocols": "0.8.4-main.3c1ae3b",
-    "@dxos/keys": "0.8.4-main.3c1ae3b",
-    "@dxos/invariant": "0.8.4-main.3c1ae3b",
-    "@dxos/util": "0.8.4-main.3c1ae3b"
+    "effect": "3.20.0",
+    "@dxos/codec-protobuf": "0.8.4-main.3fbcb4aa9b",
+    "@dxos/echo": "0.8.4-main.3fbcb4aa9b",
+    "@dxos/context": "0.8.4-main.3fbcb4aa9b",
+    "@dxos/echo-db": "0.8.4-main.3fbcb4aa9b",
+    "@dxos/debug": "0.8.4-main.3fbcb4aa9b",
+    "@dxos/echo-protocol": "0.8.4-main.3fbcb4aa9b",
+    "@dxos/invariant": "0.8.4-main.3fbcb4aa9b",
+    "@dxos/log": "0.8.4-main.3fbcb4aa9b",
+    "@dxos/util": "0.8.4-main.3fbcb4aa9b",
+    "@dxos/errors": "0.8.4-main.3fbcb4aa9b",
+    "@dxos/keys": "0.8.4-main.3fbcb4aa9b",
+    "@dxos/protocols": "0.8.4-main.3fbcb4aa9b"
   },
   "devDependencies": {
-    "@cloudflare/workers-types": "4.20251202.0",
-    "@dxos/types": "0.8.4-main.3c1ae3b"
+    "@cloudflare/workers-types": "^4.20260302.0",
+    "@dxos/types": "0.8.4-main.3fbcb4aa9b"
   },
   "publishConfig": {
     "access": "public"

package/src/functions-client.ts

@@ -14,6 +14,7 @@ import { SpaceProxy } from './space-proxy';
 type Services = {
   dataService: EdgeFunctionEnv.DataService;
   queueService: EdgeFunctionEnv.QueueService;
+  functionsAiService: EdgeFunctionEnv.FunctionsAiService;
 };
 
 /**
@@ -23,7 +24,7 @@ type Services = {
 export class FunctionsClient extends Resource {
   private readonly _serviceContainer;
   private readonly _echoClient;
-  private readonly _executionContext: EdgeFunctionEnv.ExecutionContext = {};
+  private readonly _executionContext: EdgeFunctionEnv.TraceContext = {};
 
   private readonly _spaces = new Map<SpaceId, SpaceProxy>();
 
@@ -31,7 +32,12 @@ export class FunctionsClient extends Resource {
     super();
     invariant(typeof services.dataService !== 'undefined', 'DataService is required');
     invariant(typeof services.queueService !== 'undefined', 'QueueService is required');
-    this._serviceContainer = new ServiceContainer(this._executionContext, services.dataService, services.queueService);
+    this._serviceContainer = new ServiceContainer(
+      this._executionContext,
+      services.dataService,
+      services.queueService,
+      services.functionsAiService,
+    );
     this._echoClient = new EchoClient({});
   }
 
@@ -69,6 +75,7 @@ export const createClientFromEnv = async (env: any): Promise<FunctionsClient> =>
   const client = new FunctionsClient({
     dataService: env.DATA_SERVICE,
     queueService: env.QUEUE_SERVICE,
+    functionsAiService: env.FUNCTIONS_AI_SERVICE,
   });
   await client.open();
   return client;

package/src/internal/data-service-impl.ts

@@ -12,6 +12,8 @@ import { log } from '@dxos/log';
 import { type EdgeFunctionEnv } from '@dxos/protocols';
 import type {
   BatchedDocumentUpdates,
+  CreateDocumentRequest,
+  CreateDocumentResponse,
   DataService as DataServiceProto,
   GetDocumentHeadsRequest,
   GetDocumentHeadsResponse,
@@ -22,11 +24,13 @@ import type {
   UpdateSubscriptionRequest,
 } from '@dxos/protocols/proto/dxos/echo/service';
 
+import { copyUint8Array } from './utils';
+
 export class DataServiceImpl implements DataServiceProto {
   private dataSubscriptions = new Map<string, { spaceId: SpaceId; next: (msg: BatchedDocumentUpdates) => void }>();
 
   constructor(
-    private _executionContext: EdgeFunctionEnv.ExecutionContext,
+    private _executionContext: EdgeFunctionEnv.TraceContext,
     private _dataService: EdgeFunctionEnv.DataService,
   ) {}
 
@@ -41,7 +45,7 @@ export class DataServiceImpl implements DataServiceProto {
     });
   }
 
-  async updateSubscription({ subscriptionId, addIds, removeIds }: UpdateSubscriptionRequest): Promise<void> {
+  async updateSubscription({ subscriptionId, addIds }: UpdateSubscriptionRequest): Promise<void> {
     const sub =
       this.dataSubscriptions.get(subscriptionId) ??
       raise(
@@ -55,17 +59,32 @@ export class DataServiceImpl implements DataServiceProto {
       log.info('request documents', { count: addIds.length });
       // TODO(dmaretskyi): Batch.
       for (const documentId of addIds) {
-        const document = await this._dataService.getDocument(this._executionContext, sub.spaceId, documentId);
+        using document = await this._dataService.getDocument(this._executionContext, sub.spaceId, documentId);
         log.info('document loaded', { documentId, spaceId: sub.spaceId, found: !!document });
         if (!document) {
           log.warn('not found', { documentId });
           continue;
         }
-        sub.next({ updates: [{ documentId, mutation: document.data }] });
+        sub.next({
+          updates: [
+            {
+              documentId,
+              // Copy returned object to avoid hanging RPC stub
+              // See https://developers.cloudflare.com/workers/runtime-apis/rpc/lifecycle/
+              mutation: copyUint8Array(document.data),
+            },
+          ],
+        });
       }
     }
   }
 
+  async createDocument({ spaceId, initialValue }: CreateDocumentRequest): Promise<CreateDocumentResponse> {
+    invariant(SpaceId.isValid(spaceId));
+    using response = await this._dataService.createDocument(this._executionContext, spaceId, initialValue);
+    return { documentId: response.documentId };
+  }
+
   async update({ updates, subscriptionId }: UpdateRequest): Promise<void> {
     const sub =
       this.dataSubscriptions.get(subscriptionId) ??
@@ -93,31 +112,30 @@ export class DataServiceImpl implements DataServiceProto {
     // No-op.
   }
 
-  subscribeSpaceSyncState(request: GetSpaceSyncStateRequest, options?: RequestOptions): Stream<SpaceSyncState> {
+  subscribeSpaceSyncState(_request: GetSpaceSyncStateRequest, _options?: RequestOptions): Stream<SpaceSyncState> {
     throw new NotImplementedError({
       message: 'subscribeSpaceSyncState is not implemented.',
     });
   }
 
-  async getDocumentHeads({ documentIds }: GetDocumentHeadsRequest): Promise<GetDocumentHeadsResponse> {
+  async getDocumentHeads({ documentIds: _documentIds }: GetDocumentHeadsRequest): Promise<GetDocumentHeadsResponse> {
     throw new NotImplementedError({
       message: 'getDocumentHeads is not implemented.',
     });
   }
 
-  async reIndexHeads({ documentIds }: ReIndexHeadsRequest): Promise<void> {
+  async reIndexHeads({ documentIds: _documentIds }: ReIndexHeadsRequest): Promise<void> {
     throw new NotImplementedError({
       message: 'reIndexHeads is not implemented.',
     });
   }
 
   async updateIndexes(): Promise<void> {
-    throw new NotImplementedError({
-      message: 'updateIndexes is not implemented.',
-    });
+    log.error('updateIndexes is not available in EDGE env.');
+    // No-op.
   }
 
-  async waitUntilHeadsReplicated({ heads }: { heads: any }): Promise<void> {
+  async waitUntilHeadsReplicated({ heads: _heads }: { heads: any }): Promise<void> {
     throw new NotImplementedError({
       message: 'waitUntilHeadsReplicated is not implemented.',
     });

package/src/internal/query-service-impl.ts

@@ -2,67 +2,36 @@
 // Copyright 2024 DXOS.org
 //
 
-import * as Schema from 'effect/Schema';
-
 import { Stream } from '@dxos/codec-protobuf/stream';
-import { QueryAST } from '@dxos/echo-protocol';
 import { NotImplementedError, RuntimeServiceError } from '@dxos/errors';
-import { invariant } from '@dxos/invariant';
-import { PublicKey } from '@dxos/keys';
-import { SpaceId } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { type EdgeFunctionEnv } from '@dxos/protocols';
-import {
-  type QueryRequest,
-  type QueryResponse,
-  type QueryResult as QueryResultProto,
-  type QueryService as QueryServiceProto,
-} from '@dxos/protocols/proto/dxos/echo/query';
-
-import { queryToDataServiceRequest } from './adapter';
+import { type QueryRequest, type QueryResponse, type QueryService } from '@dxos/protocols/proto/dxos/echo/query';
 
-export class QueryServiceImpl implements QueryServiceProto {
+export class QueryServiceImpl implements QueryService {
   private _queryCount = 0;
 
   constructor(
-    private readonly _executionContext: EdgeFunctionEnv.ExecutionContext,
+    private readonly _executionContext: EdgeFunctionEnv.TraceContext,
     private readonly _dataService: EdgeFunctionEnv.DataService,
   ) {}
 
   execQuery(request: QueryRequest): Stream<QueryResponse> {
     log.info('execQuery', { request });
-    const query = QueryAST.Query.pipe(Schema.decodeUnknownSync)(JSON.parse(request.query));
-    const requestedSpaceIds = getTargetSpacesForQuery(query);
-    invariant(requestedSpaceIds.length === 1, 'Only one space is supported');
-    const spaceId = requestedSpaceIds[0];
 
     return Stream.fromPromise<QueryResponse>(
       (async () => {
         try {
           this._queryCount++;
-          log.info('begin query', { spaceId });
-          const queryResponse = await this._dataService.queryDocuments(
-            this._executionContext,
-            queryToDataServiceRequest(query),
-          );
-          log.info('query response', { spaceId, filter: request.filter, resultCount: queryResponse.results.length });
-          return {
-            results: queryResponse.results.map(
-              (object): QueryResultProto => ({
-                id: object.objectId,
-                spaceId,
-                spaceKey: PublicKey.ZERO,
-                documentId: object.document.documentId,
-                rank: 0,
-                documentAutomerge: object.document.data,
-              }),
-            ),
-          } satisfies QueryResponse;
+          log.info('begin query', { request });
+          using queryResponse = await this._dataService.execQuery(this._executionContext, request);
+          log.info('query response', { resultCount: queryResponse.results?.length });
+          return structuredClone(queryResponse);
         } catch (error) {
           log.error('query failed', { err: error });
           throw new RuntimeServiceError({
             message: `Query execution failed (queryCount=${this._queryCount})`,
-            context: { spaceId, filter: request.filter, queryCount: this._queryCount },
+            context: { queryCount: this._queryCount },
             cause: error,
           });
         }
@@ -82,22 +51,3 @@ export class QueryServiceImpl implements QueryServiceProto {
     });
   }
 }
-
-/**
- * Lists spaces this query will select from.
- */
-export const getTargetSpacesForQuery = (query: QueryAST.Query): SpaceId[] => {
-  const spaces = new Set<SpaceId>();
-
-  const visitor = (node: QueryAST.Query) => {
-    if (node.type === 'options') {
-      if (node.options.spaceIds) {
-        for (const spaceId of node.options.spaceIds) {
-          spaces.add(SpaceId.make(spaceId));
-        }
-      }
-    }
-  };
-  QueryAST.visit(query, visitor);
-  return [...spaces];
-};

package/src/internal/queue-service-impl.ts

@@ -2,38 +2,43 @@
 // Copyright 2025 DXOS.org
 //
 
-import { NotImplementedError, RuntimeServiceError } from '@dxos/errors';
-import type { ObjectId, SpaceId } from '@dxos/keys';
-import { type QueueService as QueueServiceProto } from '@dxos/protocols';
-import type { EdgeFunctionEnv, QueryResult, QueueQuery } from '@dxos/protocols';
+import { RuntimeServiceError } from '@dxos/errors';
+import { type EdgeFunctionEnv, type FeedProtocol } from '@dxos/protocols';
 
-export class QueueServiceImpl implements QueueServiceProto {
+export class QueueServiceImpl implements FeedProtocol.QueueService {
   constructor(
-    protected _ctx: EdgeFunctionEnv.ExecutionContext,
+    protected _ctx: EdgeFunctionEnv.TraceContext,
     private readonly _queueService: EdgeFunctionEnv.QueueService,
   ) {}
-  async queryQueue(subspaceTag: string, spaceId: SpaceId, { queueId, ...query }: QueueQuery): Promise<QueryResult> {
+
+  async queryQueue(request: FeedProtocol.QueryQueueRequest): Promise<FeedProtocol.QueryResult> {
     try {
-      const result = await this._queueService.query(this._ctx, `dxn:queue:${subspaceTag}:${spaceId}:${queueId}`, query);
-      return result;
+      using result = await this._queueService.queryQueue(this._ctx, request);
+      // Copy to avoid hanging RPC stub (Workers RPC lifecycle).
+      return {
+        objects: structuredClone(result.objects),
+        nextCursor: result.nextCursor,
+        prevCursor: result.prevCursor,
+      };
     } catch (error) {
+      const { query } = request;
       throw RuntimeServiceError.wrap({
         message: 'Queue query failed.',
-        context: { subspaceTag, spaceId, queueId },
+        context: {
+          subspaceTag: query?.queuesNamespace,
+          spaceId: query?.spaceId,
+          queueId: query?.queueIds?.[0],
+        },
         ifTypeDiffers: true,
       })(error);
     }
   }
 
-  async insertIntoQueue(subspaceTag: string, spaceId: SpaceId, queueId: ObjectId, objects: unknown[]): Promise<void> {
+  async insertIntoQueue(request: FeedProtocol.InsertIntoQueueRequest): Promise<void> {
     try {
-      const result = await this._queueService.append(
-        this._ctx,
-        `dxn:queue:${subspaceTag}:${spaceId}:${queueId}`,
-        objects,
-      );
-      return result;
+      using _ = await this._queueService.insertIntoQueue(this._ctx, request);
     } catch (error) {
+      const { subspaceTag, spaceId, queueId } = request;
       throw RuntimeServiceError.wrap({
         message: 'Queue append failed.',
         context: { subspaceTag, spaceId, queueId },
@@ -42,10 +47,20 @@ export class QueueServiceImpl implements QueueServiceProto {
     }
   }
 
-  deleteFromQueue(subspaceTag: string, spaceId: SpaceId, queueId: ObjectId, _objectIds: ObjectId[]): Promise<void> {
-    throw new NotImplementedError({
-      message: 'Deleting from queue is not supported.',
-      context: { subspaceTag, spaceId, queueId },
-    });
+  async deleteFromQueue(request: FeedProtocol.DeleteFromQueueRequest): Promise<void> {
+    try {
+      using _ = await this._queueService.deleteFromQueue(this._ctx, request);
+    } catch (error) {
+      const { subspaceTag, spaceId, queueId } = request;
+      throw RuntimeServiceError.wrap({
+        message: 'Queue delete failed.',
+        context: { subspaceTag, spaceId, queueId },
+        ifTypeDiffers: true,
+      })(error);
+    }
+  }
+
+  async syncQueue(_: FeedProtocol.SyncQueueRequest): Promise<void> {
+    // No-op in Cloudflare runtime.
   }
 }

package/src/internal/service-container.ts

@@ -2,11 +2,9 @@
 // Copyright 2024 DXOS.org
 //
 
-import type { HasId } from '@dxos/echo/internal';
+import { type AnyEntity } from '@dxos/echo/internal';
 import { type DXN, type SpaceId } from '@dxos/keys';
-import type { QueryResult } from '@dxos/protocols';
-import { type EdgeFunctionEnv } from '@dxos/protocols';
-import { type QueueService as QueueServiceProto } from '@dxos/protocols';
+import { type EdgeFunctionEnv, type FeedProtocol } from '@dxos/protocols';
 import { type QueryService as QueryServiceProto } from '@dxos/protocols/proto/dxos/echo/query';
 import type { DataService as DataServiceProto } from '@dxos/protocols/proto/dxos/echo/service';
 
@@ -19,19 +17,29 @@ import { QueueServiceImpl } from './queue-service-impl';
  */
 export class ServiceContainer {
   constructor(
-    private readonly _executionContext: EdgeFunctionEnv.ExecutionContext,
+    private readonly _executionContext: EdgeFunctionEnv.TraceContext,
     private readonly _dataService: EdgeFunctionEnv.DataService,
     private readonly _queueService: EdgeFunctionEnv.QueueService,
+    private readonly _functionsService: EdgeFunctionEnv.FunctionsAiService,
   ) {}
 
   async getSpaceMeta(spaceId: SpaceId): Promise<EdgeFunctionEnv.SpaceMeta | undefined> {
-    return this._dataService.getSpaceMeta(this._executionContext, spaceId);
+    using result = await this._dataService.getSpaceMeta(this._executionContext, spaceId);
+    // Copy returned object to avoid hanging RPC stub
+    // See https://developers.cloudflare.com/workers/runtime-apis/rpc/lifecycle/
+    return result
+      ? {
+          spaceKey: result.spaceKey,
+          rootDocumentId: result.rootDocumentId,
+        }
+      : undefined;
   }
 
   async createServices(): Promise<{
     dataService: DataServiceProto;
     queryService: QueryServiceProto;
-    queueService: QueueServiceProto;
+    queueService: FeedProtocol.QueueService;
+    functionsAiService: EdgeFunctionEnv.FunctionsAiService;
   }> {
     const dataService = new DataServiceImpl(this._executionContext, this._dataService);
     const queryService = new QueryServiceImpl(this._executionContext, this._dataService);
@@ -41,14 +49,41 @@ export class ServiceContainer {
       dataService,
       queryService,
       queueService,
+      functionsAiService: this._functionsService,
     };
   }
 
-  queryQueue(queue: DXN): Promise<QueryResult> {
-    return this._queueService.query({}, queue.toString(), {});
+  async queryQueue(queue: DXN): Promise<FeedProtocol.QueryResult> {
+    const parts = queue.asQueueDXN();
+    if (!parts) {
+      throw new Error('Invalid queue DXN');
+    }
+    const { subspaceTag, spaceId, queueId } = parts;
+    const result = await this._queueService.queryQueue(this._executionContext, {
+      query: {
+        spaceId,
+        queuesNamespace: subspaceTag,
+        queueIds: [queueId],
+      },
+    });
+    return {
+      objects: structuredClone(result.objects),
+      nextCursor: result.nextCursor ?? null,
+      prevCursor: result.prevCursor ?? null,
+    };
   }
 
-  insertIntoQueue(queue: DXN, objects: HasId[]): Promise<void> {
-    return this._queueService.append({}, queue.toString(), objects);
+  async insertIntoQueue(queue: DXN, objects: AnyEntity[]): Promise<void> {
+    const parts = queue.asQueueDXN();
+    if (!parts) {
+      throw new Error('Invalid queue DXN');
+    }
+    const { subspaceTag, spaceId, queueId } = parts;
+    await this._queueService.insertIntoQueue(this._executionContext, {
+      subspaceTag,
+      spaceId,
+      queueId,
+      objects: objects.map((obj) => JSON.stringify(obj)),
+    });
   }
 }

package/src/internal/utils.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export const copyUint8Array = (value: Uint8Array): Uint8Array => new Uint8Array(value);

package/src/logger.ts

@@ -2,6 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
+/* eslint-disable no-console */
+
 import { LogLevel, type LogProcessor, log, shouldLog } from '@dxos/log';
 
 export const setupFunctionsLogger = () => {
@@ -14,27 +16,29 @@ const functionLogProcessor: LogProcessor = (config, entry) => {
     return;
   }
 
+  const context = entry.computedContext;
+  const error = entry.computedError;
+  const extras = [Object.keys(context).length > 0 ? context : undefined, error].filter((value) => value !== undefined);
+
   switch (entry.level) {
     case LogLevel.DEBUG:
-      console.debug(entry.message, entry.context);
-      break;
     case LogLevel.TRACE:
-      console.debug(entry.message, entry.context);
+      console.debug(entry.message, ...extras);
       break;
     case LogLevel.VERBOSE:
-      console.log(entry.message, entry.context);
+      console.log(entry.message, ...extras);
       break;
     case LogLevel.INFO:
-      console.info(entry.message, entry.context);
+      console.info(entry.message, ...extras);
       break;
     case LogLevel.WARN:
-      console.warn(entry.message, entry.context);
+      console.warn(entry.message, ...extras);
       break;
     case LogLevel.ERROR:
-      console.error(entry.message, entry.context);
+      console.error(entry.message, ...extras);
       break;
     default:
-      console.log(entry.message, entry.context);
+      console.log(entry.message, ...extras);
       break;
   }
 };

package/src/queues-api.ts

@@ -2,20 +2,26 @@
 // Copyright 2025 DXOS.org
 //
 
-import type { HasId } from '@dxos/echo/internal';
+import { type AnyEntity } from '@dxos/echo/internal';
 import type { DXN, SpaceId } from '@dxos/keys';
-import type { QueryResult } from '@dxos/protocols';
+import { log } from '@dxos/log';
 
 import type { ServiceContainer } from './internal';
 
+export interface QueuesQueryResult {
+  objects: AnyEntity[];
+  nextCursor: string | null;
+  prevCursor: string | null;
+}
+
 // TODO(dmaretskyi): Temporary API to get the queues working.
 // TODO(dmaretskyi): To be replaced with integrating queues into echo.
 /**
  * @deprecated
  */
 export interface QueuesAPI {
-  queryQueue(queue: DXN, options?: {}): Promise<QueryResult>;
-  insertIntoQueue(queue: DXN, objects: HasId[]): Promise<void>;
+  queryQueue(queue: DXN, options?: {}): Promise<QueuesQueryResult>;
+  insertIntoQueue(queue: DXN, objects: AnyEntity[]): Promise<void>;
 }
 
 /**
@@ -27,11 +33,24 @@ export class QueuesAPIImpl implements QueuesAPI {
     private readonly _spaceId: SpaceId,
   ) {}
 
-  queryQueue(queue: DXN, options?: {}): Promise<QueryResult> {
-    return this._serviceContainer.queryQueue(queue);
+  async queryQueue(queue: DXN, options?: {}): Promise<QueuesQueryResult> {
+    const result = await this._serviceContainer.queryQueue(queue);
+    const objects = (result.objects ?? []).flatMap((encoded): AnyEntity[] => {
+      try {
+        return [JSON.parse(encoded) as AnyEntity];
+      } catch (err) {
+        log.verbose('queue object JSON parse failed; object ignored', { encoded, error: err });
+        return [];
+      }
+    });
+    return {
+      objects,
+      nextCursor: result.nextCursor ?? null,
+      prevCursor: result.prevCursor ?? null,
+    };
   }
 
-  insertIntoQueue(queue: DXN, objects: HasId[]): Promise<void> {
+  insertIntoQueue(queue: DXN, objects: AnyEntity[]): Promise<void> {
     // TODO(dmaretskyi): Ugly.
     return this._serviceContainer.insertIntoQueue(queue, JSON.parse(JSON.stringify(objects)));
   }

package/src/space-proxy.ts

@@ -3,7 +3,8 @@
 //
 
 import { Resource } from '@dxos/context';
-import { type CoreDatabase, type EchoClient, type EchoDatabase } from '@dxos/echo-db';
+import { type Database } from '@dxos/echo';
+import { type CoreDatabase, type EchoClient, type EchoDatabaseImpl } from '@dxos/echo-db';
 import { invariant } from '@dxos/invariant';
 import { PublicKey, type SpaceId } from '@dxos/keys';
 
@@ -14,7 +15,7 @@ import { type QueuesAPI, QueuesAPIImpl } from './queues-api';
  * @deprecated
  */
 export class SpaceProxy extends Resource {
-  private _db?: EchoDatabase = undefined;
+  private _db?: EchoDatabaseImpl = undefined;
   private _queuesApi: QueuesAPIImpl;
 
   constructor(
@@ -30,7 +31,7 @@ export class SpaceProxy extends Resource {
     return this._id;
   }
 
-  get db(): EchoDatabase {
+  get db(): Database.Database {
     invariant(this._db);
     return this._db;
   }
@@ -60,6 +61,6 @@ export class SpaceProxy extends Resource {
       owningObject: this,
     });
 
-    await this._db.coreDatabase.open({ rootUrl: meta.rootDocumentId });
+    await this._db.coreDatabase.open(this._ctx, { rootUrl: meta.rootDocumentId });
   }
 }

package/src/wrap-handler-for-cloudflare.ts

@@ -22,7 +22,6 @@ export const wrapHandlerForCloudflare = (func: FunctionProtocol.Func): ExportedH
     // TODO(mykola): Wrap in withNewExecutionContext;
     // Meta route is used to get the input schema of the function by the functions service.
     if (request.headers.get(FUNCTION_ROUTE_HEADER) === FunctionRouteValue.Meta) {
-      log.info('>>> meta', { func });
       return handleFunctionMetaCall(func, request);
     }
 
@@ -34,7 +33,7 @@ export const wrapHandlerForCloudflare = (func: FunctionProtocol.Func): ExportedH
         }
       }
 
-      const serviceContainer = new ServiceContainer({}, env.DATA_SERVICE, env.QUEUE_SERVICE);
+      const serviceContainer = new ServiceContainer({}, env.DATA_SERVICE, env.QUEUE_SERVICE, env.FUNCTIONS_AI_SERVICE);
       const context = await createFunctionContext({
         serviceContainer,
         contextSpaceId: spaceId as SpaceId | undefined,
@@ -98,14 +97,14 @@ const handleFunctionMetaCall = (functionDefinition: FunctionProtocol.Func, reque
   });
 };
 
-const createFunctionContext = async ({
+export const createFunctionContext = async ({
   serviceContainer,
   contextSpaceId,
 }: {
   serviceContainer: ServiceContainer;
   contextSpaceId: SpaceId | undefined;
 }): Promise<FunctionProtocol.Context> => {
-  const { dataService, queryService, queueService } = await serviceContainer.createServices();
+  const { dataService, queryService, queueService, functionsAiService } = await serviceContainer.createServices();
 
   let spaceKey: string | undefined;
   let rootUrl: string | undefined;
@@ -124,6 +123,7 @@ const createFunctionContext = async ({
       dataService,
       queryService,
       queueService,
+      functionsAiService,
     },
     spaceId: contextSpaceId,
     spaceKey,