apps 0.0.1-beta.0

package/js/openapi.js

@@ -0,0 +1,246 @@
+import {
+  protocolOperations
+} from "./chunk-LOKGDT6B.js";
+import "./chunk-C24KEZXR.js";
+import {
+  FetchHttpClient_exports
+} from "./chunk-VFUZI3NY.js";
+import {
+  HttpClientRequest_exports,
+  HttpClient_exports
+} from "./chunk-W7Q5EOTS.js";
+import {
+  jsonSchemaDecoder
+} from "./chunk-BPEFS4YF.js";
+import {
+  HttpUrl,
+  JsonObject
+} from "./chunk-36DNRFZQ.js";
+import {
+  Effect_exports,
+  Schema_exports
+} from "./chunk-2OTCEKL2.js";
+import "./chunk-MLKGABMK.js";
+
+// src/contracts/openapi.ts
+var RequestParameter = Schema_exports.Struct({
+  name: Schema_exports.String,
+  in: Schema_exports.Literals(["path", "query", "header"]),
+  style: Schema_exports.String,
+  explode: Schema_exports.Boolean
+});
+var OpenapiOperation = Schema_exports.Struct({
+  name: Schema_exports.NonEmptyString,
+  description: Schema_exports.String,
+  method: Schema_exports.Literals(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]),
+  path: Schema_exports.String,
+  baseUrl: HttpUrl,
+  parameters: Schema_exports.Array(RequestParameter),
+  body: Schema_exports.Literals(["json", "base64", "none"]),
+  /** Streams remain in the metadata but cannot run through a single-result tool call. */
+  streaming: Schema_exports.optionalKey(Schema_exports.Literal(true)),
+  security: Schema_exports.Array(Schema_exports.Array(Schema_exports.String)),
+  input: JsonObject,
+  outputSchema: Schema_exports.optionalKey(JsonObject)
+});
+var CredentialBinding = Schema_exports.Struct({
+  scheme: Schema_exports.String,
+  field: Schema_exports.String,
+  in: Schema_exports.Literals(["header", "query"]),
+  name: Schema_exports.String,
+  prefix: Schema_exports.String
+});
+var OpenapiAccount = Schema_exports.Struct({
+  method: Schema_exports.String,
+  fields: Schema_exports.Record(Schema_exports.String, Schema_exports.Unknown)
+});
+var OpenapiToolsOptions = Schema_exports.Struct({
+  operations: Schema_exports.Array(OpenapiOperation),
+  methods: Schema_exports.Record(Schema_exports.String, Schema_exports.Array(CredentialBinding)),
+  oauth: Schema_exports.Array(Schema_exports.String),
+  account: Schema_exports.optional(OpenapiAccount),
+  signal: Schema_exports.optional(Schema_exports.instanceOf(AbortSignal)),
+  fetch: Schema_exports.optional(
+    Schema_exports.declare((value) => typeof value === "function")
+  )
+});
+var OpenapiError = class extends Schema_exports.TaggedError()("OpenapiError", {
+  reason: Schema_exports.Literals(["invalid_definition", "invalid_input", "request"]),
+  status: Schema_exports.optional(Schema_exports.Number)
+}) {
+};
+
+// src/implementation/openapi-request.ts
+var object = Schema_exports.decodeUnknownSync(Schema_exports.Record(Schema_exports.String, Schema_exports.Unknown));
+function scalar(value) {
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  throw new Error("This parameter requires scalar values");
+}
+function pairs(value) {
+  return Object.entries(object(value)).map(([key, item]) => [key, scalar(item)]);
+}
+function simple(value, explode, encode) {
+  const token = (value2) => encode ? encodeURIComponent(scalar(value2)) : scalar(value2);
+  if (Array.isArray(value)) return value.map(token).join(",");
+  if (typeof value === "object" && value !== null)
+    return pairs(value).map(([key, item]) => token(key) + (explode ? "=" : ",") + token(item)).join(",");
+  return token(value);
+}
+function createRequest(config) {
+  const { methods, oauth } = config;
+  function schemes(method) {
+    if (method === void 0) return [];
+    if (oauth.includes(method)) return [method];
+    const bindings = Object.hasOwn(methods, method) ? methods[method] : void 0;
+    return bindings?.map((binding) => binding.scheme) ?? [];
+  }
+  function selectedSecurity(op, method) {
+    if (op.streaming === true) return void 0;
+    if (!op.security.length) return [];
+    const supported = schemes(method);
+    return op.security.find((keys) => keys.every((key) => supported.includes(key)));
+  }
+  const call = (op, input, account) => Effect_exports.scoped(
+    Effect_exports.gen(function* () {
+      const prepared = yield* Effect_exports.try({
+        try: () => {
+          const args = object(input);
+          const security = selectedSecurity(op, account?.method);
+          if (security === void 0)
+            throw new Error("The selected account cannot call this tool");
+          let path = op.path;
+          const query = new URLSearchParams();
+          const headers = new Headers();
+          for (const p of op.parameters) {
+            const group = args[p.in === "header" ? "headers" : p.in];
+            const value = group === void 0 ? void 0 : object(group)[p.name];
+            if (value === void 0) continue;
+            if (p.in === "path")
+              path = path.replaceAll("{" + p.name + "}", simple(value, p.explode, true));
+            else if (p.in === "header") headers.set(p.name, simple(value, p.explode, false));
+            else if (p.style === "deepObject") {
+              for (const [key, item] of pairs(value))
+                query.append(p.name + "[" + key + "]", item);
+            } else if (Array.isArray(value)) {
+              if (p.explode && p.style === "form")
+                for (const item of value) query.append(p.name, scalar(item));
+              else
+                query.append(
+                  p.name,
+                  value.map(scalar).join(
+                    p.style === "spaceDelimited" ? " " : p.style === "pipeDelimited" ? "|" : ","
+                  )
+                );
+            } else if (typeof value === "object" && value !== null) {
+              if (p.style !== "form") throw new Error("Unsupported object parameter style");
+              if (p.explode) for (const [key, item] of pairs(value)) query.append(key, item);
+              else query.append(p.name, pairs(value).flat().join(","));
+            } else query.append(p.name, scalar(value));
+          }
+          if (/{[^}]+}/.test(path)) throw new Error("A required path parameter is missing");
+          const url = new URL(op.baseUrl + path);
+          if (account && Object.hasOwn(methods, account.method)) {
+            for (const binding of methods[account.method] ?? []) {
+              if (!security.includes(binding.scheme)) continue;
+              const credential = binding.prefix + scalar(account.fields[binding.field]);
+              if (binding.in === "header") headers.set(binding.name, credential);
+              else query.set(binding.name, credential);
+            }
+          } else if (account && oauth.includes(account.method) && security.includes(account.method)) {
+            headers.set("Authorization", "Bearer " + scalar(account.fields.access_token));
+          }
+          url.search = query.toString();
+          let body;
+          if (args.body !== void 0) {
+            if (op.body === "json") {
+              headers.set("Content-Type", "application/json");
+              body = JSON.stringify(args.body);
+            } else if (op.body === "base64") {
+              headers.set("Content-Type", "application/octet-stream");
+              body = Uint8Array.from(atob(scalar(args.body)), (char) => char.charCodeAt(0));
+            }
+          }
+          return { url, headers, body, method: op.method };
+        },
+        catch: () => new OpenapiError({ reason: "invalid_input" })
+      });
+      const client = yield* HttpClient_exports.HttpClient;
+      const request = yield* Effect_exports.try({
+        try: () => HttpClientRequest_exports.fromWeb(
+          new Request(prepared.url, {
+            method: prepared.method,
+            headers: prepared.headers,
+            ...prepared.body === void 0 ? {} : { body: prepared.body }
+          })
+        ),
+        catch: () => new OpenapiError({ reason: "invalid_input" })
+      });
+      const response = yield* HttpClient_exports.withScope(client).execute(request);
+      if (response.status < 200 || response.status >= 300)
+        return yield* new OpenapiError({ reason: "request", status: response.status });
+      if (response.status === 204 || prepared.method === "HEAD") return null;
+      return yield* (response.headers["content-type"]?.includes("json") ? response.json : response.text).pipe(Effect_exports.withSpan("provider.http.response.read"));
+    })
+  ).pipe(
+    Effect_exports.withSpan("provider.openapi.call", {
+      attributes: { "executor.tool.name": op.name, "http.request.method": op.method }
+    }),
+    Effect_exports.provideService(FetchHttpClient_exports.RequestInit, { redirect: "manual" }),
+    Effect_exports.provide(FetchHttpClient_exports.layer),
+    Effect_exports.mapError(
+      (error) => error instanceof OpenapiError ? error : new OpenapiError({ reason: "request" })
+    )
+  );
+  return {
+    available: (op, method) => selectedSecurity(op, method) !== void 0,
+    call
+  };
+}
+
+// src/implementation/openapi.ts
+var openapiToolsEffect = (options) => Effect_exports.gen(function* () {
+  const config = yield* Schema_exports.decodeUnknownEffect(OpenapiToolsOptions)(options).pipe(
+    Effect_exports.mapError(() => new OpenapiError({ reason: "invalid_definition" }))
+  );
+  const request = createRequest(config);
+  const entries = yield* Effect_exports.forEach(
+    config.operations.filter((op) => request.available(op, config.account?.method)),
+    (op) => Effect_exports.gen(function* () {
+      const input = yield* jsonSchemaDecoder(op.input).pipe(
+        Effect_exports.mapError(() => new OpenapiError({ reason: "invalid_definition" }))
+      );
+      const tool = {
+        description: op.description,
+        readOnly: ["GET", "HEAD", "OPTIONS"].includes(op.method),
+        input,
+        ...op.outputSchema === void 0 ? {} : { outputSchema: op.outputSchema },
+        run: (_context, value) => Schema_exports.decodeUnknownEffect(input)(value).pipe(
+          Effect_exports.mapError(() => new OpenapiError({ reason: "invalid_input" })),
+          Effect_exports.flatMap(
+            (parsed) => request.call(op, parsed, config.account).pipe(
+              Effect_exports.provideService(
+                FetchHttpClient_exports.Fetch,
+                config.fetch ?? globalThis.fetch
+              )
+            )
+          )
+        )
+      };
+      return [op.name, tool];
+    })
+  );
+  return Object.fromEntries(entries);
+});
+
+// src/openapi.ts
+var openapiOperations = (options, kinds = {}) => Effect_exports.runPromise(
+  openapiToolsEffect(options).pipe(
+    Effect_exports.map((operations) => protocolOperations(operations, kinds))
+  ),
+  options.signal === void 0 ? {} : { signal: options.signal }
+);
+export {
+  OpenapiError,
+  openapiOperations
+};

package/js/operations/approval.js

@@ -0,0 +1,9 @@
+import "../chunk-MLKGABMK.js";
+
+// src/approval.ts
+var always = () => () => "user-approval";
+var never = () => () => "approved";
+export {
+  always,
+  never
+};

package/js/react.js

@@ -0,0 +1,37 @@
+import {
+  AsyncResult_exports,
+  AtomRegistry_exports,
+  queryCommitted
+} from "./chunk-YDR4CPJA.js";
+import "./chunk-D6BKYP2L.js";
+import {
+  Option_exports
+} from "./chunk-2OTCEKL2.js";
+import "./chunk-MLKGABMK.js";
+
+// src/react.ts
+import { useEffect, useLayoutEffect, useState } from "react";
+var useAppQuery = (atom) => {
+  const [state, setState] = useState();
+  useEffect(() => {
+    const registry = AtomRegistry_exports.make();
+    const stop = registry.subscribe(atom, (result2) => setState({ atom, result: result2 }), {
+      immediate: true
+    });
+    return () => {
+      stop();
+      registry.dispose();
+    };
+  }, [atom]);
+  const result = state?.atom === atom ? state.result : AsyncResult_exports.initial();
+  useLayoutEffect(() => queryCommitted(result), [result]);
+  const value = AsyncResult_exports.value(result);
+  return {
+    data: Option_exports.getOrUndefined(value),
+    pending: result._tag === "Initial",
+    error: result._tag === "Failure" ? "Could not load app data." : void 0
+  };
+};
+export {
+  useAppQuery
+};