apps 0.0.1-beta.0

package/js/contracts.js

@@ -0,0 +1,163 @@
+import {
+  DeclaredAuthMethod,
+  DeclaredProvider,
+  DeclaredRequirements,
+  HostAccountsInvalid,
+  HostCallError,
+  HostDataError,
+  HostDeclarationInvalid,
+  HostError,
+  HostEvaluationFailed,
+  HostInputInvalid,
+  HostInspectError,
+  HostOperationFailed,
+  HostOperationNotFound,
+  HostOutputInvalid,
+  HostRequest,
+  HostRequestInvalid,
+  HostRequirementsError,
+  HostResponse,
+  HostToolApprovalRequired,
+  HostToolBlocked,
+  HostToolNotFound,
+  HostToolPolicyFailed,
+  HostedTool,
+  HostedWebhook,
+  ManualWebhookDescriptor,
+  ManualWebhookSetup,
+  McpClientLimits,
+  OperationToolPrefixes,
+  ResolvedAccount,
+  ResolvedAccounts,
+  ToolResultObservation,
+  TrustedToolApproval,
+  WebhookCommand,
+  WebhookRequestData,
+  WebhookResponseData,
+  WebhookTransportLimits,
+  defaultMcpClientLimits,
+  defaultWebhookTransportLimits
+} from "./chunk-22WRQZT7.js";
+import {
+  ApprovalElicitation,
+  ApprovalResponse,
+  CalendarSchedule,
+  ElicitationFailed,
+  ElicitationLimits,
+  ElicitationReply,
+  ElicitationResponse,
+  FormElicitation,
+  HostedWorkflow,
+  Interval,
+  NonRetryableError,
+  OAuthClientAuth,
+  OAuthSecretClientAuth,
+  OperationSchedule,
+  ScheduleTiming,
+  WorkflowCommand,
+  WorkflowControlCommand,
+  WorkflowDuration,
+  WorkflowFailure,
+  WorkflowName,
+  WorkflowReplay,
+  WorkflowRpcCommand,
+  WorkflowRpcResult,
+  WorkflowRun,
+  WorkflowRunId,
+  WorkflowRunPage,
+  WorkflowStepOptions,
+  WorkflowValue,
+  approvalElicitation,
+  defaultElicitationLimits,
+  minimumIntervalMilliseconds,
+  workflowDurationMillis
+} from "./chunk-HP7E42X6.js";
+import "./chunk-7JXHF5IF.js";
+import {
+  AppStorageError,
+  AppStorageUnavailable,
+  StorageName
+} from "./chunk-EP6AEUZO.js";
+import {
+  AccountId,
+  HttpUrl
+} from "./chunk-36DNRFZQ.js";
+import "./chunk-2OTCEKL2.js";
+import "./chunk-MLKGABMK.js";
+export {
+  AccountId,
+  AppStorageError,
+  AppStorageUnavailable,
+  ApprovalElicitation,
+  ApprovalResponse,
+  CalendarSchedule,
+  DeclaredAuthMethod,
+  DeclaredProvider,
+  DeclaredRequirements,
+  ElicitationFailed,
+  ElicitationLimits,
+  ElicitationReply,
+  ElicitationResponse,
+  FormElicitation,
+  HostAccountsInvalid,
+  HostCallError,
+  HostDataError,
+  HostDeclarationInvalid,
+  HostError,
+  HostEvaluationFailed,
+  HostInputInvalid,
+  HostInspectError,
+  HostOperationFailed,
+  HostOperationNotFound,
+  HostOutputInvalid,
+  HostRequest,
+  HostRequestInvalid,
+  HostRequirementsError,
+  HostResponse,
+  HostToolApprovalRequired,
+  HostToolBlocked,
+  HostToolNotFound,
+  HostToolPolicyFailed,
+  HostedTool,
+  HostedWebhook,
+  HostedWorkflow,
+  HttpUrl,
+  Interval,
+  ManualWebhookDescriptor,
+  ManualWebhookSetup,
+  McpClientLimits,
+  NonRetryableError,
+  OAuthClientAuth,
+  OAuthSecretClientAuth,
+  OperationSchedule,
+  OperationToolPrefixes,
+  ResolvedAccount,
+  ResolvedAccounts,
+  ScheduleTiming,
+  StorageName,
+  ToolResultObservation,
+  TrustedToolApproval,
+  WebhookCommand,
+  WebhookRequestData,
+  WebhookResponseData,
+  WebhookTransportLimits,
+  WorkflowCommand,
+  WorkflowControlCommand,
+  WorkflowDuration,
+  WorkflowFailure,
+  WorkflowName,
+  WorkflowReplay,
+  WorkflowRpcCommand,
+  WorkflowRpcResult,
+  WorkflowRun,
+  WorkflowRunId,
+  WorkflowRunPage,
+  WorkflowStepOptions,
+  WorkflowValue,
+  approvalElicitation,
+  defaultElicitationLimits,
+  defaultMcpClientLimits,
+  defaultWebhookTransportLimits,
+  minimumIntervalMilliseconds,
+  workflowDurationMillis
+};

package/js/effect.js

@@ -0,0 +1,44 @@
+import "./chunk-BCSNKUAC.js";
+import {
+  ApprovalDecision,
+  createAppHandler,
+  prepareElicitation
+} from "./chunk-Q2FD5IBM.js";
+import "./chunk-X3YBZCJW.js";
+import "./chunk-R6JMJSVT.js";
+import "./chunk-C24KEZXR.js";
+import {
+  ToolAnnotations
+} from "./chunk-22WRQZT7.js";
+import "./chunk-HP7E42X6.js";
+import "./chunk-7JXHF5IF.js";
+import "./chunk-OWD2YICM.js";
+import "./chunk-VFUZI3NY.js";
+import "./chunk-W7Q5EOTS.js";
+import {
+  compileJsonSchemaDecoder,
+  decoderOf,
+  jsonSchemaDecoder,
+  wrap
+} from "./chunk-BPEFS4YF.js";
+import "./chunk-EP6AEUZO.js";
+import {
+  HttpUrl,
+  JsonObject,
+  ValidationError
+} from "./chunk-36DNRFZQ.js";
+import "./chunk-2OTCEKL2.js";
+import "./chunk-MLKGABMK.js";
+export {
+  ApprovalDecision,
+  HttpUrl,
+  JsonObject,
+  ToolAnnotations,
+  ValidationError,
+  compileJsonSchemaDecoder,
+  createAppHandler,
+  decoderOf,
+  jsonSchemaDecoder,
+  prepareElicitation,
+  wrap
+};

package/js/graphql.js

@@ -0,0 +1,392 @@
+import {
+  protocolOperations
+} from "./chunk-LOKGDT6B.js";
+import "./chunk-BCSNKUAC.js";
+import "./chunk-Q2FD5IBM.js";
+import "./chunk-X3YBZCJW.js";
+import "./chunk-R6JMJSVT.js";
+import "./chunk-C24KEZXR.js";
+import "./chunk-22WRQZT7.js";
+import "./chunk-HP7E42X6.js";
+import "./chunk-7JXHF5IF.js";
+import "./chunk-OWD2YICM.js";
+import {
+  FetchHttpClient_exports
+} from "./chunk-VFUZI3NY.js";
+import {
+  HttpClientRequest_exports,
+  HttpClient_exports
+} from "./chunk-W7Q5EOTS.js";
+import {
+  jsonSchemaDecoder
+} from "./chunk-BPEFS4YF.js";
+import "./chunk-EP6AEUZO.js";
+import {
+  HttpUrl,
+  JsonObject
+} from "./chunk-36DNRFZQ.js";
+import {
+  Effect_exports,
+  Redacted_exports,
+  Schema_exports
+} from "./chunk-2OTCEKL2.js";
+import "./chunk-MLKGABMK.js";
+
+// src/implementation/graphql.ts
+import {
+  getIntrospectionQuery,
+  Kind as Kind2,
+  OperationTypeNode,
+  parse,
+  parseType,
+  print
+} from "graphql";
+
+// src/contracts/graphql.ts
+var GraphqlClientLimits = Schema_exports.Struct({
+  timeoutMs: Schema_exports.Int.check(Schema_exports.isGreaterThan(0)),
+  maxTimeoutMs: Schema_exports.Int.check(Schema_exports.isGreaterThan(0))
+});
+var defaultGraphqlClientLimits = GraphqlClientLimits.make({
+  timeoutMs: 3e4,
+  maxTimeoutMs: 3e5
+});
+var GraphqlToolsOptions = Schema_exports.Struct({
+  url: HttpUrl,
+  headers: Schema_exports.optional(Schema_exports.Record(Schema_exports.String, Schema_exports.String)),
+  signal: Schema_exports.optional(Schema_exports.instanceOf(AbortSignal)),
+  timeoutMs: Schema_exports.optional(
+    Schema_exports.Int.check(
+      Schema_exports.isBetween({ minimum: 1, maximum: defaultGraphqlClientLimits.maxTimeoutMs })
+    )
+  )
+});
+var GraphqlError = class extends Schema_exports.TaggedError()("GraphqlError", {
+  phase: Schema_exports.Literals(["discover", "call"]),
+  reason: Schema_exports.Literals([
+    "request",
+    "unauthorized",
+    "invalid_response",
+    "invalid_input",
+    "timeout",
+    "execution"
+  ]),
+  status: Schema_exports.optional(Schema_exports.Number)
+}) {
+};
+var Name = Schema_exports.String.check(Schema_exports.isPattern(/^[_A-Za-z][_0-9A-Za-z]*$/));
+var Kind = Schema_exports.Literals([
+  "SCALAR",
+  "OBJECT",
+  "INTERFACE",
+  "UNION",
+  "ENUM",
+  "INPUT_OBJECT",
+  "LIST",
+  "NON_NULL"
+]);
+var GraphqlTypeRef = Schema_exports.Struct({
+  kind: Kind,
+  name: Schema_exports.NullOr(Name),
+  ofType: Schema_exports.optional(Schema_exports.NullOr(Schema_exports.suspend(() => GraphqlTypeRef)))
+});
+var Argument = Schema_exports.Struct({
+  name: Name,
+  description: Schema_exports.NullOr(Schema_exports.String),
+  type: GraphqlTypeRef,
+  defaultValue: Schema_exports.NullOr(Schema_exports.String)
+});
+var GraphqlField = Schema_exports.Struct({
+  name: Name,
+  description: Schema_exports.NullOr(Schema_exports.String),
+  args: Schema_exports.Array(Argument),
+  type: GraphqlTypeRef
+});
+var GraphqlIntrospection = Schema_exports.Struct({
+  __schema: Schema_exports.Struct({
+    queryType: Schema_exports.NullOr(Schema_exports.Struct({ name: Name })),
+    mutationType: Schema_exports.NullOr(Schema_exports.Struct({ name: Name })),
+    types: Schema_exports.Array(
+      Schema_exports.Struct({
+        kind: Kind,
+        name: Name,
+        fields: Schema_exports.NullOr(Schema_exports.Array(GraphqlField)),
+        inputFields: Schema_exports.NullOr(Schema_exports.Array(Argument)),
+        enumValues: Schema_exports.NullOr(Schema_exports.Array(Schema_exports.Struct({ name: Name })))
+      })
+    )
+  })
+});
+var GraphqlResponse = Schema_exports.Struct({
+  data: Schema_exports.optional(Schema_exports.NullOr(JsonObject)),
+  errors: Schema_exports.optional(Schema_exports.Array(JsonObject))
+});
+
+// src/implementation/graphql.ts
+function wrapped(type) {
+  if (!type.ofType) throw new GraphqlError({ phase: "discover", reason: "invalid_response" });
+  return type.ofType;
+}
+function named(type) {
+  return type.kind === "LIST" || type.kind === "NON_NULL" ? named(wrapped(type)) : type;
+}
+function typeName(type) {
+  if (type.kind === "NON_NULL") return typeName(wrapped(type)) + "!";
+  if (type.kind === "LIST") return "[" + typeName(wrapped(type)) + "]";
+  if (!type.name) throw new GraphqlError({ phase: "discover", reason: "invalid_response" });
+  return type.name;
+}
+function fieldInput(field, catalog) {
+  const types = new Map(catalog.__schema.types.map((type) => [type.name, type]));
+  const definitions = /* @__PURE__ */ new Map();
+  const convert = (ref) => ref.kind === "NON_NULL" ? nonNull(wrapped(ref)) : { anyOf: [nonNull(ref), { type: "null" }] };
+  const nonNull = (ref) => {
+    if (ref.kind === "LIST") return { type: "array", items: convert(wrapped(ref)) };
+    if (!ref.name) throw new GraphqlError({ phase: "discover", reason: "invalid_response" });
+    const type = types.get(ref.name);
+    if (!type) throw new GraphqlError({ phase: "discover", reason: "invalid_response" });
+    if (type.kind === "ENUM" && type.enumValues)
+      return { type: "string", enum: type.enumValues.map((item) => item.name) };
+    if (type.kind === "INPUT_OBJECT" && type.inputFields) {
+      if (!definitions.has(type.name)) {
+        definitions.set(type.name, {});
+        definitions.set(type.name, argsSchema(type.inputFields));
+      }
+      return { $ref: "#/$defs/" + type.name };
+    }
+    if (type.kind !== "SCALAR")
+      throw new GraphqlError({ phase: "discover", reason: "invalid_response" });
+    switch (type.name) {
+      case "Int":
+        return { type: "integer", minimum: -2147483648, maximum: 2147483647 };
+      case "Float":
+        return { type: "number" };
+      case "Boolean":
+        return { type: "boolean" };
+      case "ID":
+        return { anyOf: [{ type: "string" }, { type: "integer" }] };
+      case "String":
+        return { type: "string" };
+      default:
+        return {};
+    }
+  };
+  const argsSchema = (args) => ({
+    type: "object",
+    additionalProperties: false,
+    properties: Object.fromEntries(
+      args.map((arg) => [
+        arg.name,
+        { ...convert(arg.type), ...arg.description ? { description: arg.description } : {} }
+      ])
+    ),
+    required: args.filter((arg) => arg.type.kind === "NON_NULL" && arg.defaultValue === null).map((arg) => arg.name)
+  });
+  const output = named(field.type);
+  const composite = ["OBJECT", "INTERFACE", "UNION"].includes(output.kind);
+  const leaves = types.get(output.name ?? "")?.fields?.filter((child) => {
+    const type = named(child.type);
+    return (type.kind === "SCALAR" || type.kind === "ENUM") && child.args.every((arg) => arg.type.kind !== "NON_NULL" || arg.defaultValue !== null);
+  }).map((child) => child.name) ?? [];
+  const arguments_ = argsSchema(field.args);
+  return {
+    composite,
+    selection: leaves.length ? leaves.join(" ") : "__typename",
+    schema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        arguments: arguments_,
+        ...composite ? {
+          select: {
+            type: "string",
+            minLength: 1,
+            description: "Fields to return, e.g. id name items { id title }. Omit to select scalar fields."
+          }
+        } : {}
+      },
+      required: field.args.some((arg) => arg.type.kind === "NON_NULL" && arg.defaultValue === null) ? ["arguments"] : [],
+      $defs: Object.fromEntries(definitions)
+    }
+  };
+}
+function selection(text) {
+  const document = parse("query { result { " + text + " } }");
+  const definition = document.definitions[0];
+  if (document.definitions.length !== 1 || definition?.kind !== Kind2.OPERATION_DEFINITION || definition.selectionSet.selections.length !== 1) {
+    throw new GraphqlError({ phase: "call", reason: "invalid_input" });
+  }
+  const field = definition.selectionSet.selections[0];
+  if (field?.kind !== Kind2.FIELD || field.name.value !== "result" || !field.selectionSet)
+    throw new GraphqlError({ phase: "call", reason: "invalid_input" });
+  return field.selectionSet;
+}
+var graphqlToolsEffect = (input) => Effect_exports.gen(function* () {
+  const options = yield* Schema_exports.decodeUnknownEffect(GraphqlToolsOptions)(input).pipe(
+    Effect_exports.mapError(() => new GraphqlError({ phase: "discover", reason: "invalid_input" }))
+  );
+  const url = new URL(options.url);
+  if (url.username || url.password || url.hash)
+    return yield* new GraphqlError({ phase: "discover", reason: "invalid_input" });
+  const headers = Redacted_exports.make({ ...options.headers });
+  const request = (phase, query, variables = {}) => Effect_exports.scoped(
+    Effect_exports.gen(function* () {
+      const client = yield* HttpClient_exports.HttpClient;
+      const response = yield* HttpClient_exports.withScope(client).execute(
+        HttpClientRequest_exports.post(url.href).pipe(
+          HttpClientRequest_exports.setHeaders(Redacted_exports.value(headers)),
+          HttpClientRequest_exports.bodyJsonUnsafe({ query, variables })
+        )
+      );
+      if (response.status < 200 || response.status >= 300)
+        return yield* new GraphqlError({
+          phase,
+          reason: [401, 403].includes(response.status) ? "unauthorized" : "request",
+          status: response.status
+        });
+      const result = yield* response.json.pipe(
+        Effect_exports.withSpan("provider.http.response.read"),
+        Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(GraphqlResponse)),
+        Effect_exports.mapError(() => new GraphqlError({ phase, reason: "invalid_response" }))
+      );
+      if (result.errors?.length)
+        return yield* new GraphqlError({ phase, reason: "execution", status: response.status });
+      if (result.data == null)
+        return yield* new GraphqlError({ phase, reason: "invalid_response" });
+      return result.data;
+    })
+  ).pipe(
+    Effect_exports.withSpan("provider.graphql.request", {
+      attributes: {
+        "executor.operation": phase,
+        "server.address": url.hostname
+      }
+    }),
+    Effect_exports.provideService(FetchHttpClient_exports.RequestInit, { redirect: "manual" }),
+    Effect_exports.provideService(FetchHttpClient_exports.Fetch, globalThis.fetch),
+    Effect_exports.provide(FetchHttpClient_exports.layer),
+    Effect_exports.timeoutOrElse({
+      duration: options.timeoutMs ?? defaultGraphqlClientLimits.timeoutMs,
+      orElse: () => Effect_exports.fail(new GraphqlError({ phase, reason: "timeout" }))
+    }),
+    Effect_exports.mapError(
+      (error) => error instanceof GraphqlError ? error : new GraphqlError({ phase, reason: "request" })
+    )
+  );
+  const catalog = yield* request("discover", getIntrospectionQuery()).pipe(
+    Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(GraphqlIntrospection)),
+    Effect_exports.mapError(
+      (error) => error instanceof GraphqlError ? error : new GraphqlError({ phase: "discover", reason: "invalid_response" })
+    )
+  );
+  const roots = [
+    { kind: OperationTypeNode.QUERY, type: catalog.__schema.queryType },
+    { kind: OperationTypeNode.MUTATION, type: catalog.__schema.mutationType }
+  ].flatMap(
+    ({ kind, type }) => (catalog.__schema.types.find((item) => item.name === type?.name)?.fields ?? []).map(
+      (field) => ({ kind, field })
+    )
+  );
+  const entries = yield* Effect_exports.forEach(
+    roots,
+    ({ kind, field }) => Effect_exports.gen(function* () {
+      const definition = yield* Effect_exports.try({
+        try: () => fieldInput(field, catalog),
+        catch: () => new GraphqlError({ phase: "discover", reason: "invalid_response" })
+      });
+      const decoder = yield* jsonSchemaDecoder(definition.schema).pipe(
+        Effect_exports.mapError(
+          () => new GraphqlError({ phase: "discover", reason: "invalid_response" })
+        )
+      );
+      const name = kind + "_" + field.name;
+      const tool = {
+        description: field.description ?? field.name,
+        readOnly: kind === OperationTypeNode.QUERY,
+        input: decoder,
+        run: (_context, input2) => Effect_exports.gen(function* () {
+          const args = yield* Schema_exports.decodeUnknownEffect(decoder)(input2).pipe(
+            Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(JsonObject)),
+            Effect_exports.mapError(() => new GraphqlError({ phase: "call", reason: "invalid_input" }))
+          );
+          const variables = yield* Schema_exports.decodeUnknownEffect(JsonObject)(
+            args.arguments ?? {}
+          ).pipe(
+            Effect_exports.mapError(() => new GraphqlError({ phase: "call", reason: "invalid_input" }))
+          );
+          const query = yield* Effect_exports.try({
+            try: () => {
+              const used = field.args.filter((arg) => Object.hasOwn(variables, arg.name));
+              return print({
+                kind: Kind2.DOCUMENT,
+                definitions: [
+                  {
+                    kind: Kind2.OPERATION_DEFINITION,
+                    operation: kind,
+                    variableDefinitions: used.map((arg) => ({
+                      kind: Kind2.VARIABLE_DEFINITION,
+                      variable: {
+                        kind: Kind2.VARIABLE,
+                        name: { kind: Kind2.NAME, value: arg.name }
+                      },
+                      type: parseType(typeName(arg.type))
+                    })),
+                    selectionSet: {
+                      kind: Kind2.SELECTION_SET,
+                      selections: [
+                        {
+                          kind: Kind2.FIELD,
+                          name: { kind: Kind2.NAME, value: field.name },
+                          arguments: used.map((arg) => ({
+                            kind: Kind2.ARGUMENT,
+                            name: { kind: Kind2.NAME, value: arg.name },
+                            value: {
+                              kind: Kind2.VARIABLE,
+                              name: { kind: Kind2.NAME, value: arg.name }
+                            }
+                          })),
+                          ...definition.composite ? {
+                            selectionSet: selection(
+                              typeof args.select === "string" ? args.select : definition.selection
+                            )
+                          } : {}
+                        }
+                      ]
+                    }
+                  }
+                ]
+              });
+            },
+            catch: () => new GraphqlError({ phase: "call", reason: "invalid_input" })
+          });
+          const data = yield* request("call", query, variables);
+          const value = Object.hasOwn(data, field.name) ? data[field.name] : void 0;
+          if (value === void 0)
+            return yield* new GraphqlError({ phase: "call", reason: "invalid_response" });
+          return value;
+        }).pipe(
+          Effect_exports.withSpan("provider.graphql.call", {
+            attributes: {
+              "graphql.operation.type": kind,
+              "executor.tool.name": name
+            }
+          })
+        )
+      };
+      return [name, tool];
+    })
+  );
+  return Object.fromEntries(entries);
+});
+
+// src/graphql.ts
+var graphqlOperations = (options, kinds = {}) => Effect_exports.runPromise(
+  graphqlToolsEffect(options).pipe(
+    Effect_exports.map((operations) => protocolOperations(operations, kinds))
+  ),
+  options.signal === void 0 ? {} : { signal: options.signal }
+);
+export {
+  GraphqlError,
+  graphqlOperations
+};