apps 0.0.1-beta.0

package/js/chunk-WIDTG42X.js

@@ -0,0 +1,171 @@
+import {
+  adaptMcpTools,
+  mcpClient,
+  mcpJsonSchemaValidator
+} from "./chunk-KWTCHVLT.js";
+import {
+  McpError,
+  McpToolsOptions,
+  defaultMcpClientLimits
+} from "./chunk-22WRQZT7.js";
+import {
+  captureTelemetry
+} from "./chunk-OWD2YICM.js";
+import {
+  FetchHttpClient_exports
+} from "./chunk-VFUZI3NY.js";
+import {
+  HttpClientRequest_exports,
+  HttpClient_exports
+} from "./chunk-W7Q5EOTS.js";
+import {
+  Effect_exports,
+  Redacted_exports,
+  Schema_exports,
+  Stream_exports
+} from "./chunk-2OTCEKL2.js";
+
+// src/implementation/mcp.ts
+import { UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { ErrorCode, McpError as ProtocolError } from "@modelcontextprotocol/sdk/types.js";
+import { SSEClientTransport, SseError } from "@modelcontextprotocol/sdk/client/sse.js";
+import {
+  StreamableHTTPClientTransport,
+  StreamableHTTPError
+} from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+var failure = (phase, error) => {
+  const status = error instanceof UnauthorizedError ? 401 : error instanceof StreamableHTTPError || error instanceof SseError ? error.code : void 0;
+  return new McpError({
+    phase,
+    reason: error instanceof ProtocolError && error.code === ErrorCode.RequestTimeout ? "timeout" : status === 401 || status === 403 ? "unauthorized" : "request",
+    ...status === void 0 ? {} : { status }
+  });
+};
+var transportFetch = (connection, telemetry) => (url, init) => Effect_exports.runPromiseWith(telemetry.context)(
+  Effect_exports.gen(function* () {
+    const target = yield* Effect_exports.try({
+      try: () => new URL(url),
+      catch: () => failure("transport", void 0)
+    });
+    if (target.origin !== connection.url.origin || target.username || target.password)
+      return yield* failure("transport", void 0);
+    const headers = new Headers(Redacted_exports.value(connection.headers));
+    new Headers(init?.headers).forEach((value, name) => headers.set(name, value));
+    const request = yield* Effect_exports.try({
+      try: () => HttpClientRequest_exports.fromWeb(new Request(target, { ...init, headers })),
+      catch: () => failure("transport", void 0)
+    });
+    const client = yield* HttpClient_exports.HttpClient;
+    const response = yield* client.execute(request);
+    return new Response(
+      [204, 205, 304].includes(response.status) ? null : Stream_exports.toReadableStream(response.stream),
+      {
+        status: response.status,
+        headers: response.headers
+      }
+    );
+  }).pipe(
+    Effect_exports.provide(FetchHttpClient_exports.layer),
+    Effect_exports.provideService(FetchHttpClient_exports.RequestInit, { redirect: "manual" }),
+    Effect_exports.provideService(
+      FetchHttpClient_exports.Fetch,
+      (url2, options) => globalThis.fetch(url2, {
+        ...options,
+        signal: AbortSignal.any([
+          ...options?.signal ? [options.signal] : [],
+          ...init?.signal ? [init.signal] : []
+        ])
+      })
+    ),
+    Effect_exports.mapError(() => failure("transport", void 0))
+  ),
+  init?.signal ? { signal: init.signal } : {}
+);
+function withClient(connection, mode, use) {
+  const attempt = (kind) => Effect_exports.scoped(
+    Effect_exports.gen(function* () {
+      const telemetry = yield* captureTelemetry;
+      const { client, transport } = yield* Effect_exports.acquireRelease(
+        Effect_exports.sync(() => {
+          const fetch = transportFetch(connection, telemetry);
+          return {
+            client: new Client(
+              { name: "executor-apps", version: "0.1.0" },
+              {
+                jsonSchemaValidator: mcpJsonSchemaValidator,
+                capabilities: mode === "call" ? { elicitation: { form: {} } } : {}
+              }
+            ),
+            transport: kind === "http" ? new StreamableHTTPClientTransport(connection.url, {
+              fetch,
+              reconnectionOptions: {
+                maxRetries: 0,
+                initialReconnectionDelay: 1e3,
+                maxReconnectionDelay: 1e3,
+                reconnectionDelayGrowFactor: 1
+              }
+            }) : new SSEClientTransport(connection.url, { fetch })
+          };
+        }),
+        ({ client: client2, transport: transport2 }) => Effect_exports.gen(function* () {
+          if (transport2 instanceof StreamableHTTPClientTransport && transport2.sessionId !== void 0) {
+            yield* Effect_exports.tryPromise(() => transport2.terminateSession()).pipe(
+              Effect_exports.timeout(defaultMcpClientLimits.cleanupTimeoutMs),
+              Effect_exports.ignore
+            );
+          }
+          yield* Effect_exports.tryPromise(() => client2.close()).pipe(
+            Effect_exports.timeout(defaultMcpClientLimits.cleanupTimeoutMs),
+            Effect_exports.ignore
+          );
+        }).pipe(Effect_exports.withSpan("provider.mcp.close"))
+      );
+      const wire = transport;
+      yield* Effect_exports.tryPromise({
+        try: (signal) => client.connect(wire, { signal, timeout: connection.timeoutMs }),
+        catch: (error) => failure("connect", error)
+      }).pipe(Effect_exports.timeout(connection.timeoutMs), Effect_exports.withSpan("provider.mcp.connect"));
+      return yield* use(client);
+    })
+  ).pipe(
+    Effect_exports.withSpan("provider.mcp.session", {
+      attributes: {
+        "mcp.transport": kind,
+        "mcp.operation": mode,
+        "server.address": connection.url.hostname
+      }
+    })
+  );
+  return attempt("http").pipe(
+    // Fallback is only for negotiation. Tool calls are never automatically replayed.
+    Effect_exports.catch(
+      (error) => Schema_exports.is(McpError)(error) && error.phase === "connect" && (error.status === 404 || error.status === 405) ? attempt("sse") : Effect_exports.fail(error)
+    ),
+    (operation) => mode === "discover" ? operation.pipe(Effect_exports.timeout(connection.timeoutMs)) : operation,
+    Effect_exports.catchTag(
+      "TimeoutError",
+      () => Effect_exports.fail(new McpError({ phase: "transport", reason: "timeout" }))
+    )
+  );
+}
+var mcpToolsEffect = (input) => Effect_exports.gen(function* () {
+  const options = yield* Schema_exports.decodeUnknownEffect(McpToolsOptions)(input).pipe(
+    Effect_exports.mapError(() => new McpError({ phase: "connect", reason: "invalid_input" }))
+  );
+  const url = new URL(options.url);
+  if (url.username || url.password || url.hash)
+    return yield* new McpError({ phase: "connect", reason: "invalid_input" });
+  const connection = {
+    url,
+    headers: Redacted_exports.make({ ...options.headers }),
+    timeoutMs: options.timeoutMs ?? defaultMcpClientLimits.timeoutMs
+  };
+  return yield* adaptMcpTools(
+    mcpClient((mode, use) => withClient(connection, mode, use), connection.timeoutMs, failure)
+  );
+});
+
+export {
+  mcpToolsEffect
+};

package/js/chunk-X3YBZCJW.js

@@ -0,0 +1,246 @@
+import {
+  parseDatabaseSchema,
+  promiseTable
+} from "./chunk-R6JMJSVT.js";
+import {
+  nativeOperation
+} from "./chunk-C24KEZXR.js";
+import {
+  ScheduleTiming
+} from "./chunk-HP7E42X6.js";
+import {
+  decoderOf,
+  isSchema,
+  storageFieldOf
+} from "./chunk-BPEFS4YF.js";
+import {
+  AppStorageUnavailable
+} from "./chunk-EP6AEUZO.js";
+import {
+  JsonValue
+} from "./chunk-36DNRFZQ.js";
+import {
+  Effect_exports,
+  Schema_exports
+} from "./chunk-2OTCEKL2.js";
+
+// src/implementation/authoring.ts
+var NativeCallback = /* @__PURE__ */ Symbol("apps.NativeCallback");
+var fromPromise = (callback) => (...args) => {
+  if (NativeCallback in callback) {
+    const native = callback[NativeCallback];
+    return native(...args);
+  }
+  return Effect_exports.tryPromise({ try: () => callback(...args), catch: (error) => error });
+};
+var toPromise = (operation, signal) => {
+  const native = (...args) => Effect_exports.suspend(() => {
+    if (signal === void 0) return operation(...args);
+    if (signal.aborted) return Effect_exports.interrupt;
+    const cancelled = Effect_exports.callback((resume) => {
+      if (signal.aborted) {
+        resume(Effect_exports.interrupt);
+        return;
+      }
+      const abort = () => resume(Effect_exports.interrupt);
+      signal.addEventListener("abort", abort, { once: true });
+      return Effect_exports.sync(() => signal.removeEventListener("abort", abort));
+    });
+    return Effect_exports.raceFirst(
+      cancelled,
+      Effect_exports.suspend(() => operation(...args))
+    );
+  });
+  return Object.assign((...args) => Effect_exports.runPromise(native(...args)), {
+    [NativeCallback]: native
+  });
+};
+
+// src/implementation/workflows.ts
+var NativeWorkflow = /* @__PURE__ */ Symbol("apps.Workflow");
+var workflow = (options, run) => ({
+  [NativeWorkflow]: {
+    input: decoderOf(options.input),
+    ...options.output === void 0 ? {} : { output: decoderOf(options.output) },
+    ...options.description === void 0 ? {} : { description: options.description },
+    run: (context, input) => Effect_exports.tryPromise({
+      // SAFETY: defineApp checks required context; the host supplies the pinned run's capabilities.
+      try: () => run(context, input),
+      catch: (error) => error
+    })
+  }
+});
+var nativeWorkflow = (value) => {
+  if (typeof value !== "object" || value === null || !(NativeWorkflow in value)) return void 0;
+  return value[NativeWorkflow];
+};
+
+// src/implementation/app.ts
+var InternalApp = /* @__PURE__ */ Symbol("apps.App");
+var isApp = (value) => typeof value === "object" && value !== null && InternalApp in value;
+var toEffectApp = (app) => app[InternalApp];
+function adaptDefinition(definition) {
+  if ("tools" in definition) throw new Error("Use queries and mutations instead of tools");
+  const webhooks = definition.webhooks === void 0 ? {} : {
+    webhooks: Object.fromEntries(
+      Object.entries(definition.webhooks).map(([name, webhook]) => [
+        name,
+        {
+          ...webhook,
+          ...webhook.register === void 0 ? {} : { register: fromPromise(webhook.register) },
+          handle: fromPromise(webhook.handle),
+          ...webhook.unregister === void 0 ? {} : { unregister: fromPromise(webhook.unregister) },
+          ..."config" in webhook && isSchema(webhook.config) ? { config: decoderOf(webhook.config) } : {},
+          ..."state" in webhook && isSchema(webhook.state) ? { state: decoderOf(webhook.state) } : {}
+        }
+      ])
+    )
+  };
+  const operations = (kind, catalog) => Object.fromEntries(
+    Object.entries(catalog).map(([name, value]) => {
+      const operation = nativeOperation(value);
+      if (operation === void 0 || operation.kind !== kind)
+        throw new Error("Invalid app data operation");
+      return [name, operation];
+    })
+  );
+  const workflows = definition.workflows === void 0 ? {} : {
+    workflows: Object.fromEntries(
+      Object.entries(definition.workflows).map(([name, value]) => {
+        const declared = nativeWorkflow(value);
+        if (declared === void 0) throw new Error("Invalid workflow declaration");
+        return [name, declared];
+      })
+    )
+  };
+  const data = {
+    ...definition.queries === void 0 ? {} : { queries: operations("query", definition.queries) },
+    ...definition.mutations === void 0 ? {} : { mutations: operations("mutation", definition.mutations) }
+  };
+  const schedules = definition.schedules === void 0 ? {} : {
+    schedules: Object.fromEntries(
+      Object.entries(definition.schedules).map(([name, schedule]) => {
+        const matches = Object.entries(definition.mutations ?? {}).filter(
+          ([, operation]) => operation === schedule.operation
+        );
+        const match = matches[0];
+        if (match === void 0 || matches.length !== 1)
+          throw new Error("A schedule must reference exactly one named mutation in this app");
+        return [
+          name,
+          {
+            timing: Schema_exports.decodeUnknownSync(ScheduleTiming)(schedule.timing),
+            input: Schema_exports.decodeUnknownSync(JsonValue)(schedule.input),
+            tool: `mutations.${match[0]}`
+          }
+        ];
+      })
+    )
+  };
+  return {
+    ...definition,
+    ...webhooks,
+    ...workflows,
+    ...data,
+    ...schedules
+  };
+}
+var defineApp = (requirements, definition) => {
+  const evaluate = typeof definition === "function" ? definition : async () => definition;
+  const factory = fromPromise(evaluate);
+  const native = {
+    accounts: requirements.accounts,
+    ...requirements.database === void 0 ? {} : { database: requirements.database },
+    evaluate: (context) => factory(context).pipe(Effect_exports.map((value) => adaptDefinition(value)))
+  };
+  return {
+    [InternalApp]: native,
+    accounts: native.accounts,
+    evaluate: (context) => Effect_exports.runPromise(factory(context))
+  };
+};
+
+// src/implementation/storage.ts
+var table = (fields) => tableWithIndexes(fields, []);
+var tableWithIndexes = (fields, indexes) => ({
+  fields,
+  indexes,
+  index: (name, fieldsInIndex) => tableWithIndexes(fields, [...indexes, { name, fields: fieldsInIndex }])
+});
+var serialize = (tables) => {
+  const definitions = Object.fromEntries(
+    Object.entries(tables).map(([name, table2]) => [
+      name,
+      {
+        fields: Object.fromEntries(
+          Object.entries(table2.fields).map(([fieldName, schema]) => {
+            const field = storageFieldOf(schema);
+            if (field === void 0) throw new Error("Database columns must use a scalar schema");
+            return [fieldName, field];
+          })
+        ),
+        indexes: table2.indexes
+      }
+    ])
+  );
+  return Effect_exports.runSync(parseDatabaseSchema(definitions));
+};
+var authorDatabase = (tables, session, signal, writable) => {
+  return Object.fromEntries(
+    Object.entries(tables).map(([name, table2]) => {
+      const api = promiseTable(session, name, signal);
+      const parseFields = (input, partial) => {
+        const values = Schema_exports.decodeUnknownSync(
+          Schema_exports.Record(Schema_exports.String, Schema_exports.Unknown)
+        )(input);
+        const fields = {};
+        for (const [key, value] of Object.entries(values)) {
+          if (value === void 0) continue;
+          const field = Object.hasOwn(table2.fields, key) ? table2.fields[key] : void 0;
+          if (field === void 0) throw new Error("Unknown database column");
+          const definition = storageFieldOf(field);
+          fields[key] = value === null && definition?.optional ? null : field.parse(value);
+        }
+        if (!partial) {
+          for (const [key, field] of Object.entries(table2.fields))
+            if (!Object.hasOwn(fields, key)) {
+              const value = field.parse(void 0);
+              if (value !== void 0) fields[key] = value;
+            }
+        }
+        return fields;
+      };
+      const read = { get: api.get, withIndex: api.withIndex };
+      return [
+        name,
+        writable ? {
+          ...read,
+          insert: (value) => api.insert(parseFields(value, false)),
+          update: (id, value) => api.update(id, parseFields(value, true)),
+          delete: api.delete
+        } : read
+      ];
+    })
+  );
+};
+var defineDatabase = (tables) => ({
+  schema: serialize(tables),
+  tables
+});
+var unavailableStorage = {
+  read: () => Effect_exports.fail(new AppStorageUnavailable()),
+  mutate: () => Effect_exports.fail(new AppStorageUnavailable())
+};
+
+export {
+  fromPromise,
+  toPromise,
+  workflow,
+  isApp,
+  toEffectApp,
+  defineApp,
+  table,
+  authorDatabase,
+  defineDatabase,
+  unavailableStorage
+};