@dxos/functions 0.8.4-main.dedc0f3 → 0.8.4-main.dfabb4ec29

package/README.md

@@ -27,11 +27,9 @@ import { FunctionContext } from '@dxos/functions';
 
 export default (event: any, context: FunctionContext) => {
   const identity = context.client.halo.identity.get();
-  return context
-    .status(200)
-    .succeed({ 
-      message: `Hello ${identity?.profile?.displayName}` 
-    });
+  return context.status(200).succeed({
+    message: `Hello ${identity?.profile?.displayName}`,
+  });
 };
 ```
 
@@ -69,7 +67,7 @@ nodemon -w ./src -e ts --exec $(git rev-parse --show-toplevel)/packages/devtools
 > NOTE: The port (7001) must match the one in config.
 
 ```bash
-curl http://localhost:7001/dev/hello -X POST -H 'Content-Type: application/json' -w '\n' --data '{ "message": "Hello World!" }' 
+curl http://localhost:7001/dev/hello -X POST -H 'Content-Type: application/json' -w '\n' --data '{ "message": "Hello World!" }'
 ```
 
 ## DXOS Resources

package/dist/lib/neutral/index.mjs

@@ -0,0 +1,593 @@
+// src/services/credentials.ts
+import * as HttpClient from "@effect/platform/HttpClient";
+import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Redacted from "effect/Redacted";
+import { Credential } from "@dxos/compute";
+import { Query } from "@dxos/echo";
+import { Database } from "@dxos/echo";
+import { AccessToken } from "@dxos/types";
+var ConfiguredCredentialsService = class {
+  credentials;
+  constructor(credentials = []) {
+    this.credentials = credentials;
+  }
+  addCredentials(credentials) {
+    this.credentials.push(...credentials);
+    return this;
+  }
+  async queryCredentials(query) {
+    return this.credentials.filter((credential) => credential.service === query.service);
+  }
+  async getCredential(query) {
+    const credential = this.credentials.find((credential2) => credential2.service === query.service);
+    if (!credential) {
+      throw new Error(`Credential not found for service: ${query.service}`);
+    }
+    return credential;
+  }
+};
+var withAuthorization = (token, kind) => HttpClient.mapRequest((request) => {
+  const authorization = kind ? `${kind} ${token}` : token;
+  return HttpClientRequest.setHeader(request, "Authorization", authorization);
+});
+var configuredCredentialsLayer = (credentials) => Layer.succeed(Credential.CredentialsService, new ConfiguredCredentialsService(credentials));
+var credentialsLayerConfig = (credentials) => Layer.effect(Credential.CredentialsService, Effect.gen(function* () {
+  const serviceCredentials = yield* Effect.forEach(credentials, ({ service, apiKey }) => Effect.gen(function* () {
+    return {
+      service,
+      apiKey: Redacted.value(yield* apiKey)
+    };
+  }));
+  return new ConfiguredCredentialsService(serviceCredentials);
+}));
+var credentialsLayerFromDatabase = ({ caching = false } = {}) => Layer.effect(Credential.CredentialsService, Effect.gen(function* () {
+  const dbService = yield* Database.Service;
+  const cache = /* @__PURE__ */ new Map();
+  const queryCredentials = async (query) => {
+    const cacheKey = JSON.stringify(query);
+    if (caching && cache.has(cacheKey)) {
+      return cache.get(cacheKey);
+    }
+    const accessTokens = await dbService.db.query(Query.type(AccessToken.AccessToken)).run();
+    const credentials = accessTokens.filter((accessToken) => accessToken.source === query.service).map((accessToken) => ({
+      service: accessToken.source,
+      apiKey: accessToken.token
+    }));
+    if (caching) {
+      cache.set(cacheKey, credentials);
+    }
+    return credentials;
+  };
+  return {
+    getCredential: async (query) => {
+      const credentials = await queryCredentials(query);
+      if (credentials.length === 0) {
+        throw new Error(`Credential not found for service: ${query.service}`);
+      }
+      return credentials[0];
+    },
+    queryCredentials: async (query) => {
+      return queryCredentials(query);
+    }
+  };
+}));
+
+// src/services/function-invocation-service.ts
+import * as Context from "effect/Context";
+import * as Effect2 from "effect/Effect";
+import * as Layer2 from "effect/Layer";
+var FunctionInvocationService = class _FunctionInvocationService extends Context.Tag("@dxos/functions/FunctionInvocationService")() {
+  static layerNotAvailable = Layer2.succeed(_FunctionInvocationService, {
+    invokeFunction: () => Effect2.die("FunctionInvocationService is not avaialble."),
+    resolveFunction: () => Effect2.die("FunctionInvocationService is not available.")
+  });
+  static invokeFunction = (functionDef, input) => Effect2.serviceFunctionEffect(_FunctionInvocationService, (service) => service.invokeFunction)(functionDef, input);
+  static resolveFunction = (key) => Effect2.serviceFunctionEffect(_FunctionInvocationService, (service) => service.resolveFunction)(key);
+};
+
+// src/services/queues.ts
+import { ContextQueueService, QueueService, feedServiceFromQueueServiceLayer } from "@dxos/echo-db";
+
+// src/services/tracing.ts
+var MESSAGE_PROPERTY_TOOL_CALL_ID = "toolCallId";
+
+// src/types/url.ts
+var FUNCTIONS_META_KEY = "org.dxos.service.function";
+var FUNCTIONS_PRESET_META_KEY = "org.dxos.service.function-preset";
+var getUserFunctionIdInMetadata = (meta) => {
+  return meta.keys.find((key) => key.source === FUNCTIONS_META_KEY)?.id;
+};
+var setUserFunctionIdInMetadata = (meta, functionId) => {
+  const key = meta.keys.find((key2) => key2.source === FUNCTIONS_META_KEY);
+  if (key) {
+    if (key.id !== functionId) {
+      throw new Error("Metadata mismatch");
+    }
+  } else {
+    meta.keys.push({
+      source: FUNCTIONS_META_KEY,
+      id: functionId
+    });
+  }
+};
+
+// src/protocol/protocol.ts
+import * as AnthropicClient from "@effect/ai-anthropic/AnthropicClient";
+import * as Effect4 from "effect/Effect";
+import * as Layer4 from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
+import { AiModelResolver, AiService, OpaqueToolkit } from "@dxos/ai";
+import { AnthropicResolver } from "@dxos/ai/resolvers";
+import { FunctionError, InvalidOperationInputError, InvalidOperationOutputError, Operation, OperationRegistry, Trace } from "@dxos/compute";
+import { LifecycleState, Resource } from "@dxos/context";
+import { Database as Database2, Feed, JsonSchema, Ref } from "@dxos/echo";
+import { createFeedServiceLayer, EchoClient } from "@dxos/echo-db";
+import { refFromEncodedReference } from "@dxos/echo/internal";
+import { runAndForwardErrors } from "@dxos/effect";
+import { assertState, failedInvariant, invariant } from "@dxos/invariant";
+import { PublicKey } from "@dxos/keys";
+import { log as log2 } from "@dxos/log";
+import { ErrorCodec as ErrorCodec2 } from "@dxos/protocols";
+
+// src/protocol/functions-ai-http-client.ts
+import * as Headers from "@effect/platform/Headers";
+import * as HttpClient2 from "@effect/platform/HttpClient";
+import * as HttpClientError from "@effect/platform/HttpClientError";
+import * as HttpClientResponse from "@effect/platform/HttpClientResponse";
+import * as Effect3 from "effect/Effect";
+import * as FiberRef from "effect/FiberRef";
+import * as Layer3 from "effect/Layer";
+import * as Stream from "effect/Stream";
+import { FunctionsAiMemoizationMissError, FunctionsAiUpstreamError } from "@dxos/compute";
+import { log } from "@dxos/log";
+import { ErrorCodec } from "@dxos/protocols";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/compute/functions/src/protocol/functions-ai-http-client.ts";
+var requestInitTagKey = "@effect/platform/FetchHttpClient/FetchOptions";
+var FunctionsAiHttpClient = class _FunctionsAiHttpClient {
+  static make = (service) => HttpClient2.make((request, url, signal, fiber) => {
+    const context = fiber.getFiberRef(FiberRef.currentContext);
+    const options = context.unsafeMap.get(requestInitTagKey) ?? {};
+    const headers = options.headers ? Headers.merge(Headers.fromInput(options.headers), request.headers) : request.headers;
+    const send = (body) => Effect3.tryPromise({
+      try: () => service.fetch(new Request(url, {
+        ...options,
+        method: request.method,
+        headers,
+        body
+      })),
+      catch: (cause) => {
+        log.error("Failed to fetch", {
+          errorSerialized: ErrorCodec.encode(cause)
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 31, S: this });
+        return new HttpClientError.RequestError({
+          request,
+          reason: "Transport",
+          cause
+        });
+      }
+    }).pipe(Effect3.flatMap((response) => (
+      // Inspect the body before handing the response to `@effect/ai` so that structured
+      // upstream errors surface as typed defects (`FunctionsAiUpstreamError` and friends)
+      // rather than as the generic `HttpResponseError` from `@effect/ai/AiError`.
+      Effect3.flatMap(Effect3.promise(() => parseUpstreamError(response)), (typedError) => typedError ? Effect3.die(typedError) : Effect3.succeed(HttpClientResponse.fromWeb(request, response)))
+    )));
+    switch (request.body._tag) {
+      case "Raw":
+      case "Uint8Array":
+        return send(request.body.body);
+      case "FormData":
+        return send(request.body.formData);
+      case "Stream":
+        return Stream.toReadableStreamEffect(request.body.stream).pipe(Effect3.flatMap(send));
+    }
+    return send(void 0);
+  });
+  static layer = (service) => Layer3.succeed(HttpClient2.HttpClient, _FunctionsAiHttpClient.make(service));
+};
+var parseUpstreamError = async (response) => {
+  if (response.ok) {
+    return void 0;
+  }
+  const contentType = response.headers.get("content-type") ?? "";
+  if (!contentType.toLowerCase().includes("application/json")) {
+    return void 0;
+  }
+  let body;
+  try {
+    body = await response.clone().json();
+  } catch {
+    return void 0;
+  }
+  if (!body || body.type !== "error" || typeof body.error !== "object" || body.error === null) {
+    return void 0;
+  }
+  const inner = body.error;
+  const message = inner.message ?? `Upstream AI service responded with HTTP ${response.status}`;
+  if (inner.type === "memoization_miss" && typeof inner.cacheKey === "string") {
+    return new FunctionsAiMemoizationMissError({
+      message,
+      context: {
+        cacheKey: inner.cacheKey,
+        status: response.status
+      }
+    });
+  }
+  return new FunctionsAiUpstreamError({
+    message,
+    context: {
+      type: inner.type,
+      status: response.status,
+      ...inner.cacheKey ? {
+        cacheKey: inner.cacheKey
+      } : {}
+    }
+  });
+};
+
+// src/protocol/protocol.ts
+var __dxlog_file2 = "/__w/dxos/dxos/packages/core/compute/functions/src/protocol/protocol.ts";
+function _ts_add_disposable_resource(env, value2, async) {
+  if (value2 !== null && value2 !== void 0) {
+    if (typeof value2 !== "object" && typeof value2 !== "function") throw new TypeError("Object expected.");
+    var dispose, inner;
+    if (async) {
+      if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+      dispose = value2[Symbol.asyncDispose];
+    }
+    if (dispose === void 0) {
+      if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+      dispose = value2[Symbol.dispose];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    env.stack.push({
+      value: value2,
+      dispose,
+      async
+    });
+  } else if (async) {
+    env.stack.push({
+      async: true
+    });
+  }
+  return value2;
+}
+function _ts_dispose_resources(env) {
+  var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+  };
+  return (_ts_dispose_resources = function _ts_dispose_resources2(env2) {
+    function fail(e) {
+      env2.error = env2.hasError ? new _SuppressedError(e, env2.error, "An error was suppressed during disposal.") : e;
+      env2.hasError = true;
+    }
+    var r, s = 0;
+    function next() {
+      while (r = env2.stack.pop()) {
+        try {
+          if (!r.async && s === 1) return s = 0, env2.stack.push(r), Promise.resolve().then(next);
+          if (r.dispose) {
+            var result = r.dispose.call(r.value);
+            if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+              fail(e);
+              return next();
+            });
+          } else s |= 1;
+        } catch (e) {
+          fail(e);
+        }
+      }
+      if (s === 1) return env2.hasError ? Promise.reject(env2.error) : Promise.resolve();
+      if (env2.hasError) throw env2.error;
+    }
+    return next();
+  })(env);
+}
+var wrapFunctionHandler = (func, opts = {}) => {
+  if (!Operation.isOperationWithHandler(func)) {
+    throw new TypeError("Expected operation with handler");
+  }
+  const serviceTags = func.services.map((service) => service.key);
+  return {
+    meta: {
+      key: func.meta.key,
+      name: func.meta.name,
+      description: func.meta.description,
+      inputSchema: JsonSchema.toJsonSchema(func.input),
+      outputSchema: func.output === void 0 ? void 0 : JsonSchema.toJsonSchema(func.output),
+      services: func.services.map((service) => service.key)
+    },
+    handler: async ({ data, context }) => {
+      if ((serviceTags.includes(Database2.Service.key) || serviceTags.includes(QueueService.key) || serviceTags.includes(Feed.FeedService.key)) && (!context.services.dataService || !context.services.queryService)) {
+        throw new FunctionError({
+          message: "Services not provided: dataService, queryService"
+        });
+      }
+      try {
+        const env = {
+          stack: [],
+          error: void 0,
+          hasError: false
+        };
+        try {
+          if (!SchemaAST.isAnyKeyword(func.input.ast)) {
+            try {
+              Schema.validateSync(func.input, {
+                onExcessProperty: "error"
+              })(data);
+            } catch (error) {
+              throw new InvalidOperationInputError({
+                message: `Operation input did not match schema (${func.meta.key}): ${error.message}`,
+                cause: error
+              });
+            }
+          }
+          const funcContext = _ts_add_disposable_resource(env, await new FunctionContext(context, opts).open(), true);
+          const types = [
+            ...opts.types ?? [],
+            ...func.types ?? []
+          ];
+          if (types.length > 0) {
+            invariant(funcContext.db, "Database is required for functions with types", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 137, S: void 0, A: ["funcContext.db", "'Database is required for functions with types'"] });
+            await funcContext.db.graph.schemaRegistry.register(types);
+          }
+          const dataWithDecodedRefs = funcContext.db && !SchemaAST.isAnyKeyword(func.input.ast) ? decodeRefsFromSchema(func.input.ast, data, funcContext.db) : data;
+          let result = await func.handler(dataWithDecodedRefs);
+          if (Effect4.isEffect(result)) {
+            result = await runAndForwardErrors(result.pipe(Effect4.orDie, Effect4.provide(funcContext.createLayer())));
+          }
+          if (func.output && !SchemaAST.isAnyKeyword(func.output.ast)) {
+            try {
+              Schema.validateSync(func.output, {
+                onExcessProperty: "error"
+              })(result);
+            } catch (error) {
+              throw new InvalidOperationOutputError({
+                message: `Operation output did not match schema (${func.meta.key}): ${error.message}`,
+                cause: error
+              });
+            }
+          }
+          return result;
+        } catch (e) {
+          env.error = e;
+          env.hasError = true;
+        } finally {
+          const result = _ts_dispose_resources(env);
+          if (result) await result;
+        }
+      } catch (error) {
+        throw error;
+      }
+    }
+  };
+};
+var FunctionContext = class extends Resource {
+  context;
+  client;
+  db;
+  queues;
+  opts;
+  constructor(context, opts) {
+    super();
+    this.context = context;
+    this.opts = opts;
+    if (context.services.dataService && context.services.queryService) {
+      this.client = new EchoClient().connectToService({
+        dataService: context.services.dataService,
+        queryService: context.services.queryService,
+        queueService: context.services.queueService
+      });
+    }
+  }
+  async _open() {
+    await this.client?.open();
+    this.db = this.client && this.context.spaceId ? this.client.constructDatabase({
+      spaceId: this.context.spaceId ?? failedInvariant(),
+      spaceKey: PublicKey.fromHex(this.context.spaceKey ?? failedInvariant("spaceKey missing in context")),
+      reactiveSchemaQuery: false,
+      preloadSchemaOnOpen: false
+    }) : void 0;
+    await this.db?.setSpaceRoot(this.context.spaceRootUrl ?? failedInvariant("spaceRootUrl missing in context"));
+    await this.db?.open();
+    this.queues = this.client && this.context.spaceId ? this.client.constructQueueFactory(this.context.spaceId) : void 0;
+  }
+  async _close() {
+    await this.db?.close();
+    await this.client?.close();
+  }
+  createLayer() {
+    assertState(this._lifecycleState === LifecycleState.OPEN, "FunctionContext is not open");
+    const dbLayer = this.db ? Database2.layer(this.db) : Database2.notAvailable;
+    const queuesLayer = this.queues ? QueueService.layer(this.queues) : QueueService.notAvailable;
+    const feedLayer = this.queues ? createFeedServiceLayer(this.queues) : Feed.notAvailable;
+    const credentials = dbLayer ? credentialsLayerFromDatabase({
+      caching: true
+    }).pipe(Layer4.provide(dbLayer)) : configuredCredentialsLayer([]);
+    const aiLayer = this.context.services.functionsAiService ? InternalAiServiceLayer(this.context.services.functionsAiService) : AiService.notAvailable;
+    const operationServiceLayer = this.context.services.functionsService ? makeOperationServiceLayer(this.context.services.functionsService) : unavailableOperationServiceLayer;
+    const operationRegistryLayer = this.context.services.functionsService ? makeOperationRegistryLayer(this.context.services.functionsService, this.context.spaceId) : emptyOperationRegistryLayer;
+    const traceWriterLayer = this.context.services.traceService ? makeTraceWriterLayer(this.context.services.traceService) : Trace.writerLayerNoop;
+    log2("Creating function context layer", {
+      traceService: !!this.context.services.traceService,
+      functionsService: !!this.context.services.functionsService,
+      functionsAiService: !!this.context.services.functionsAiService,
+      spaceId: this.context.spaceId,
+      spaceRootUrl: this.context.spaceRootUrl,
+      toolkits: this.opts.toolkits?.length ?? 0,
+      types: this.opts.types?.length ?? 0
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 220, S: this });
+    return Layer4.mergeAll(
+      dbLayer,
+      queuesLayer,
+      feedLayer,
+      credentials,
+      operationServiceLayer,
+      operationRegistryLayer,
+      aiLayer,
+      OpaqueToolkit.providerLayer(OpaqueToolkit.merge(...this.opts.toolkits ?? [])),
+      traceWriterLayer,
+      // `FunctionInvocationService` is deprecated; new code should yield `Operation.Service`.
+      // The cloudflare wrapper provides only the unavailable layer to satisfy the (still-present)
+      // type union — handlers that yield it will die at invocation time.
+      FunctionInvocationService.layerNotAvailable
+    );
+  }
+};
+var makeTraceWriterLayer = (traceService) => Layer4.succeed(Trace.TraceService, {
+  write: (eventType, payload) => {
+    log2("Writing trace event", {
+      eventType: eventType.key
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 240, S: void 0 });
+    traceService.write([
+      {
+        key: eventType.key,
+        isEphemeral: eventType.isEphemeral,
+        data: payload
+      }
+    ]);
+  }
+});
+var InternalAiServiceLayer = (functionsAiService) => AiModelResolver.AiModelResolver.buildAiService.pipe(Layer4.provide(AnthropicResolver.make().pipe(Layer4.provide(AnthropicClient.layer({
+  // Note: It doesn't matter what is base url here, it will be proxied to ai gateway in edge.
+  apiUrl: "http://internal/provider/anthropic"
+}).pipe(Layer4.provide(FunctionsAiHttpClient.layer(functionsAiService)))))));
+var makeOperationServiceLayer = (functionsService) => {
+  const invokeRemote = async (op, input, options) => {
+    invariant(op.meta.deployedId, `Operation '${op.meta.key}' has no deployedId; cannot invoke remotely.`, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 264, S: void 0, A: ["op.meta.deployedId", "`Operation '${op.meta.key}' has no deployedId; cannot invoke remotely.`"] });
+    const result = await functionsService.invoke(op.meta.deployedId, input, {
+      spaceId: options?.spaceId
+    });
+    if (result._kind === "success") {
+      return {
+        data: result.data
+      };
+    }
+    return {
+      error: ErrorCodec2.decode(result.error)
+    };
+  };
+  return Layer4.succeed(Operation.Service, {
+    invoke: (op, input, options) => Effect4.tryPromise(() => invokeRemote(op, input, options)).pipe(Effect4.orDie, Effect4.flatMap((outcome) => outcome.error ? Effect4.die(outcome.error) : Effect4.succeed(outcome.data))),
+    schedule: (op, input) => Effect4.sync(() => {
+      invariant(op.meta.deployedId, `Operation '${op.meta.key}' has no deployedId; cannot schedule remotely.`, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 280, S: void 0, A: ["op.meta.deployedId", "`Operation '${op.meta.key}' has no deployedId; cannot schedule remotely.`"] });
+      void functionsService.invoke(op.meta.deployedId, input).catch(() => {
+      });
+    }),
+    invokePromise: (op, input, options) => invokeRemote(op, input, options).catch((error) => ({
+      error: error instanceof Error ? error : new Error(String(error))
+    }))
+  });
+};
+var unavailableOperationServiceLayer = Layer4.succeed(Operation.Service, {
+  invoke: () => Effect4.die("Operation.Service is not available: missing functionsService in EDGE context."),
+  schedule: () => Effect4.die("Operation.Service is not available: missing functionsService in EDGE context."),
+  invokePromise: async () => ({
+    error: new Error("Operation.Service is not available: missing functionsService in EDGE context.")
+  })
+});
+var makeOperationRegistryLayer = (functionsService, spaceId) => Layer4.succeed(OperationRegistry.Service, {
+  resolve: (key) => Effect4.gen(function* () {
+    const records = yield* Effect4.tryPromise(() => functionsService.query({
+      spaceId
+    })).pipe(Effect4.orDie);
+    const match = records.find((record) => record.key === key);
+    return match ? Option.some(Operation.deserialize(match)) : Option.none();
+  })
+});
+var emptyOperationRegistryLayer = Layer4.succeed(OperationRegistry.Service, {
+  resolve: () => Effect4.succeed(Option.none())
+});
+var decodeRefsFromSchema = (ast, value2, db) => {
+  if (value2 == null) {
+    return value2;
+  }
+  const encoded = SchemaAST.encodedBoundAST(ast);
+  if (Ref.isRefType(encoded)) {
+    if (Ref.isRef(value2)) {
+      return value2;
+    }
+    if (typeof value2 === "object" && value2 !== null && typeof value2["/"] === "string") {
+      const resolver = db.graph.createRefResolver({
+        context: {
+          space: db.spaceId
+        }
+      });
+      return refFromEncodedReference(value2, resolver);
+    }
+    return value2;
+  }
+  switch (encoded._tag) {
+    case "TypeLiteral": {
+      if (typeof value2 !== "object" || value2 === null || Array.isArray(value2)) {
+        return value2;
+      }
+      const result = {
+        ...value2
+      };
+      for (const prop of SchemaAST.getPropertySignatures(encoded)) {
+        const key = prop.name.toString();
+        if (key in result) {
+          result[key] = decodeRefsFromSchema(prop.type, result[key], db);
+        }
+      }
+      return result;
+    }
+    case "TupleType": {
+      if (!Array.isArray(value2)) {
+        return value2;
+      }
+      if (encoded.elements.length === 0 && encoded.rest.length === 1) {
+        const elementType = encoded.rest[0].type;
+        return value2.map((item) => decodeRefsFromSchema(elementType, item, db));
+      }
+      return value2;
+    }
+    case "Union": {
+      const nonUndefined = encoded.types.filter((t) => !SchemaAST.isUndefinedKeyword(t));
+      if (nonUndefined.length === 1) {
+        return decodeRefsFromSchema(nonUndefined[0], value2, db);
+      }
+      return value2;
+    }
+    case "Suspend": {
+      return decodeRefsFromSchema(encoded.f(), value2, db);
+    }
+    case "Refinement": {
+      return decodeRefsFromSchema(encoded.from, value2, db);
+    }
+    default: {
+      return value2;
+    }
+  }
+};
+export {
+  ConfiguredCredentialsService,
+  ContextQueueService,
+  FUNCTIONS_META_KEY,
+  FUNCTIONS_PRESET_META_KEY,
+  FunctionInvocationService,
+  MESSAGE_PROPERTY_TOOL_CALL_ID,
+  QueueService,
+  configuredCredentialsLayer,
+  credentialsLayerConfig,
+  credentialsLayerFromDatabase,
+  feedServiceFromQueueServiceLayer,
+  getUserFunctionIdInMetadata,
+  setUserFunctionIdInMetadata,
+  withAuthorization,
+  wrapFunctionHandler
+};
+//# sourceMappingURL=index.mjs.map