apps 0.0.1-beta.5 → 0.0.1-beta.55

package/js/chunk-67EVWIGJ.js

@@ -1,224 +0,0 @@
-import {
-  adaptMcpTools,
-  mcpClient,
-  mcpJsonSchemaValidator
-} from "./chunk-UDDE5KOR.js";
-import {
-  accountProviderError,
-  httpProviderError
-} from "./chunk-G7T27IWB.js";
-import {
-  McpError,
-  McpToolsOptions,
-  defaultMcpClientLimits
-} from "./chunk-DQAZTA4I.js";
-import {
-  ProviderError
-} from "./chunk-SB3V4YVR.js";
-import {
-  captureTelemetry
-} from "./chunk-RJDDBDSN.js";
-import {
-  FetchHttpClient_exports
-} from "./chunk-57RKNWL2.js";
-import {
-  HttpClientRequest_exports,
-  HttpClient_exports
-} from "./chunk-UK573G7W.js";
-import {
-  Deferred_exports,
-  Effect_exports,
-  Redacted_exports,
-  Schema_exports,
-  Stream_exports
-} from "./chunk-CDL5PM2Q.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,
-  ToolListChangedNotificationSchema
-} 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) => {
-  if (Schema_exports.is(ProviderError)(error) || Schema_exports.is(McpError)(error)) return error;
-  const status = error instanceof UnauthorizedError ? 401 : error instanceof StreamableHTTPError || error instanceof SseError ? error.code : void 0;
-  const provider = status === void 0 ? void 0 : httpProviderError(status);
-  if (provider !== void 0) return provider;
-  return new McpError({
-    phase,
-    reason: error instanceof ProtocolError && error.code === ErrorCode.RequestTimeout ? "timeout" : "request",
-    ...status === void 0 ? {} : { status }
-  });
-};
-var transportFetch = (connection, telemetry, rejected) => (url, init) => Effect_exports.runPromiseWith(telemetry.context)(
-  Effect_exports.gen(function* () {
-    const target = yield* Effect_exports.try({
-      try: () => new URL(url),
-      catch: () => new McpError({ phase: "transport", reason: "invalid_response" })
-    });
-    if (connection.url.username || connection.url.password)
-      return yield* new McpError({ phase: "transport", reason: "invalid_input" });
-    if (target.origin !== connection.url.origin || target.username || target.password)
-      return yield* new McpError({ phase: "transport", reason: "invalid_response" });
-    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);
-    const provider = httpProviderError(response.status, response.headers);
-    if (provider !== void 0) {
-      yield* Deferred_exports.fail(rejected, provider);
-      return yield* provider;
-    }
-    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((error) => failure("transport", error))
-  ),
-  init?.signal ? { signal: init.signal } : {}
-);
-function withClient(connection, mode, use, changed) {
-  const attempt = (kind) => Effect_exports.scoped(
-    Effect_exports.gen(function* () {
-      const telemetry = yield* captureTelemetry;
-      const rejected = yield* Deferred_exports.make();
-      const pending = /* @__PURE__ */ new Set();
-      const { client, transport } = yield* Effect_exports.acquireRelease(
-        Effect_exports.sync(() => {
-          const fetch = transportFetch(connection, telemetry, rejected);
-          const client2 = new Client(
-            { name: "executor-apps", version: "0.1.0" },
-            {
-              jsonSchemaValidator: mcpJsonSchemaValidator,
-              capabilities: mode === "call" ? { elicitation: { form: {} } } : {}
-            }
-          );
-          if (changed !== void 0) {
-            client2.setNotificationHandler(ToolListChangedNotificationSchema, () => {
-              const task = Effect_exports.runPromiseWith(telemetry.context)(
-                changed.pipe(
-                  Effect_exports.timeout("5 seconds"),
-                  Effect_exports.catchCause(() => Effect_exports.logWarning("MCP catalog invalidation failed"))
-                )
-              );
-              pending.add(task);
-              return task.finally(() => pending.delete(task));
-            });
-          }
-          return {
-            client: client2,
-            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* () {
-          client2.removeNotificationHandler("notifications/tools/list_changed");
-          yield* Effect_exports.promise(async () => {
-            await Promise.allSettled(pending);
-          });
-          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.raceFirst(Deferred_exports.await(rejected)),
-        Effect_exports.timeout(connection.timeoutMs),
-        Effect_exports.withSpan("provider.mcp.connect")
-      );
-      return yield* use(client).pipe(Effect_exports.raceFirst(Deferred_exports.await(rejected)));
-    })
-  ).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 mcpClientEffect = (input, changed) => 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 mcpClient(
-    (mode, use) => withClient(connection, mode, use, changed).pipe(
-      Effect_exports.mapError(
-        (error) => options.accountId === void 0 ? error : accountProviderError(error, options.accountId)
-      )
-    ),
-    connection.timeoutMs,
-    failure
-  );
-});
-var mcpToolsEffect = (input) => mcpClientEffect(input).pipe(Effect_exports.flatMap(adaptMcpTools));
-
-export {
-  mcpClientEffect,
-  mcpToolsEffect
-};

package/js/chunk-C3VAOK5B.js

@@ -1,215 +0,0 @@
-import {
-  promiseTable
-} from "./chunk-ZQINWV4W.js";
-import {
-  fromPromise,
-  nativeOperation
-} from "./chunk-3XKZDQLM.js";
-import {
-  ScheduleTiming
-} from "./chunk-DQAZTA4I.js";
-import {
-  DatabaseSchema
-} from "./chunk-N7YDVXYJ.js";
-import {
-  decoderOf,
-  isSchema,
-  storageFieldOf
-} from "./chunk-FWQC6I3C.js";
-import {
-  AppStorageUnavailable
-} from "./chunk-PZB6T6KU.js";
-import {
-  JsonValue
-} from "./chunk-27F7W2LG.js";
-import {
-  Effect_exports,
-  Schema_exports
-} from "./chunk-CDL5PM2Q.js";
-
-// 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 Schema_exports.decodeUnknownSync(DatabaseSchema)(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 {
-  workflow,
-  isApp,
-  toEffectApp,
-  defineApp,
-  table,
-  authorDatabase,
-  defineDatabase,
-  unavailableStorage
-};