apps 0.0.1-beta.8 → 0.0.1-beta.81

package/js/{chunk-72JNVHPK.js → chunk-4NFSABEA.js}

@@ -1,11 +1,11 @@
 import {
   fixedRouter
-} from "./chunk-FL2QR3XW.js";
+} from "./chunk-HJG4RBYM.js";
 import {
   nativeOperation,
   operationDeclaration,
   routerDeclaration
-} from "./chunk-Z5M2LQOZ.js";
+} from "./chunk-OY47QPQY.js";
 
 // src/implementation/protocol-operations.ts
 var protocolOperations = (operations, kinds = {}) => {
@@ -18,10 +18,11 @@ var protocolOperations = (operations, kinds = {}) => {
       ...operation.annotations === void 0 ? {} : { annotations: operation.annotations },
       ...operation._meta === void 0 ? {} : { _meta: operation._meta },
       input: operation.input,
+      ...operation.output === void 0 ? {} : { output: operation.output },
       run: operation.run
     };
     const output = Object.getOwnPropertyDescriptor(operation, "outputSchema");
-    const withOutput = (target) => output === void 0 || output.get === void 0 && output.value === void 0 ? target : Object.defineProperty(target, "outputSchema", { ...output, enumerable: true });
+    const withOutput = (target) => operation.output !== void 0 || output === void 0 || output.get === void 0 && output.value === void 0 ? target : Object.defineProperty(target, "outputSchema", { ...output, enumerable: true });
     declared[name] = operationDeclaration(withOutput({ ...native, kind }));
   }
   return declared;

package/js/chunk-5FHWNLCI.js

@@ -0,0 +1,88 @@
+import {
+  Predicate_exports
+} from "./chunk-IFJU5SYQ.js";
+
+// ../utils/src/recorded-message.ts
+var RecordedMessage = /* @__PURE__ */ Symbol.for("@executor-js/utils/RecordedMessage");
+var recordedMessage = (error) => {
+  if (Predicate_exports.hasProperty(error, RecordedMessage)) {
+    const message = error[RecordedMessage];
+    return typeof message === "string" ? message : void 0;
+  }
+  return protocolErrorMessage(error) ?? sqlErrorMessage(error);
+};
+var jsonRpcMeanings = {
+  [-32700]: "Parse error",
+  [-32600]: "Invalid request",
+  [-32601]: "Method not found",
+  [-32602]: "Invalid params",
+  [-32603]: "Internal error",
+  [-32002]: "Resource not found"
+};
+var protocolErrorMessage = (error) => {
+  if (!Predicate_exports.isTagged(error, "ProtocolError") || !Predicate_exports.hasProperty(error, "code") || typeof error.code !== "number" || !Predicate_exports.hasProperty(error, "message") || !Predicate_exports.isString(error.message))
+    return void 0;
+  const code = error.code;
+  const refusal = /^Tool '.*' not found$/s.test(error.message) ? ": the requested tool does not exist" : error.message.startsWith("Invalid parameters for tool '") ? ": the tool's arguments failed validation" : "";
+  const meaning = jsonRpcMeanings[code];
+  const kind = meaning === void 0 ? "JSON-RPC error with an unlisted code" : `${meaning} (${code})`;
+  return kind + refusal;
+};
+var sqlReasons = /* @__PURE__ */ new Set([
+  "ConnectionError",
+  "AuthenticationError",
+  "AuthorizationError",
+  "SqlSyntaxError",
+  "UniqueViolation",
+  "ConstraintError",
+  "DeadlockError",
+  "SerializationError",
+  "LockTimeoutError",
+  "StatementTimeoutError",
+  "UnknownError"
+]);
+var sqlMessages = new Set(
+  [
+    "A pipelined query completed out of order",
+    "Connection closed",
+    "Connection closed during startup",
+    "Connection is closed",
+    "Connection timed out",
+    "Failed to connect",
+    "Failed to decode row",
+    "Failed to encode query",
+    "Failed to negotiate TLS",
+    "Failed to parse SSLRequest error response",
+    "Failed to parse server messages",
+    "Failed to parse server response",
+    "Failed to write query",
+    "Failed to write query batch",
+    "Invalid SSLRequest response",
+    "MD5 authentication failed",
+    "No password configured",
+    "Protocol desync",
+    "Query cancellation timed out",
+    "Query failed",
+    "SCRAM authentication failed",
+    "SCRAM exchange did not complete",
+    "SCRAM server verification failed",
+    "Server refused TLS",
+    "Socket error",
+    "Stream cancellation timed out",
+    "The server reported an error",
+    "Unsupported authentication method"
+  ].map((message) => `PgConnection: ${message}`)
+);
+var sqlErrorMessage = (error) => {
+  if (!Predicate_exports.isTagged(error, "SqlError") || !Predicate_exports.hasProperty(error, "reason"))
+    return void 0;
+  const reason = error.reason;
+  const kind = Predicate_exports.hasProperty(reason, "_tag") && Predicate_exports.isString(reason._tag) && sqlReasons.has(reason._tag) ? reason._tag : "an unlisted kind";
+  const message = Predicate_exports.hasProperty(reason, "message") && Predicate_exports.isString(reason.message) && sqlMessages.has(reason.message) ? `: ${reason.message}` : "";
+  return `The database failed (${kind})${message}`;
+};
+
+export {
+  RecordedMessage,
+  recordedMessage
+};

package/js/chunk-5WGONRKQ.js

@@ -0,0 +1,426 @@
+import {
+  declaredOperations,
+  nativeOperation,
+  nativeRouter
+} from "./chunk-OY47QPQY.js";
+import {
+  fromPromise,
+  method
+} from "./chunk-W6XCQAXP.js";
+import {
+  EmittedEvent,
+  EventName,
+  Placement,
+  ScheduleTiming,
+  defaultEventLimits,
+  normalizePlacements,
+  placementFields,
+  renderPlacement
+} from "./chunk-NG56RPCA.js";
+import {
+  decoderOf,
+  isSchema,
+  jsonSchemaDocument,
+  schemaArgument
+} from "./chunk-KGCTYL2S.js";
+import {
+  JsonValue
+} from "./chunk-H2CJWXA3.js";
+import {
+  Effect_exports,
+  Result_exports,
+  Schema_exports
+} from "./chunk-IFJU5SYQ.js";
+
+// src/contracts/http.ts
+var ResponseStatusError = class extends Schema_exports.TaggedError()(
+  "ResponseStatusError",
+  { status: Schema_exports.Number }
+) {
+  get message() {
+    return `Request failed with status ${this.status}`;
+  }
+};
+var ResponseDecodeError = class extends Schema_exports.TaggedError()(
+  "ResponseDecodeError",
+  {}
+) {
+  get message() {
+    return "Response body did not match the expected schema";
+  }
+};
+
+// src/implementation/placement.ts
+var misuse = (name) => `${name} is a credential placement, not a string. Build placement values with t\`...\`, such as t\`Bearer \${token}\`, instead of an untagged template literal or string concatenation.`;
+var NotAString = class {
+  #described;
+  constructor(described) {
+    this.#described = described;
+  }
+  [Symbol.toPrimitive]() {
+    throw new TypeError(misuse(this.#described));
+  }
+  toString() {
+    throw new TypeError(misuse(this.#described));
+  }
+  toJSON() {
+    throw new TypeError(misuse(this.#described));
+  }
+};
+var FieldRef = class extends NotAString {
+  field;
+  constructor(field) {
+    super(`The field reference ${JSON.stringify(field)}`);
+    this.field = field;
+  }
+};
+var PlacementValue = class extends NotAString {
+  parts;
+  constructor(parts) {
+    super("A t`...` value");
+    this.parts = parts;
+  }
+};
+var partsOf = (input) => {
+  if (typeof input === "string") return input === "" ? [] : [input];
+  if (input instanceof FieldRef) return [{ field: input.field }];
+  if (input instanceof PlacementValue) return input.parts;
+  throw new TypeError(
+    `A credential placement interpolates text, a field reference, t\`...\` or base64(...), not ${typeof input}.`
+  );
+};
+var joined = (parts) => parts.reduce((all, part) => {
+  const last = all.at(-1);
+  if (typeof part === "string" && typeof last === "string") all[all.length - 1] = last + part;
+  else all.push(part);
+  return all;
+}, []);
+var t = (strings, ...values) => new PlacementValue(
+  joined(
+    strings.flatMap((text, index) => [
+      ...partsOf(text),
+      ...index < values.length ? partsOf(values[index]) : []
+    ])
+  )
+);
+var base64 = (value2) => {
+  const inner = partsOf(value2).map((part) => {
+    if (typeof part === "object" && "base64" in part)
+      throw new TypeError("base64(...) cannot contain another base64(...).");
+    return part;
+  });
+  if (inner.length === 0) throw new TypeError("base64(...) needs a value.");
+  return new PlacementValue([{ base64: inner }]);
+};
+var value = (input) => {
+  const parts = partsOf(input);
+  if (parts.length === 0) throw new TypeError("A credential placement needs a value.");
+  return joined(parts);
+};
+var header = (name, input) => ({
+  in: "header",
+  name: name.toLowerCase(),
+  value: value(input)
+});
+var query = (name, input) => ({
+  in: "query",
+  name,
+  value: value(input)
+});
+var bearer = (token) => header("authorization", t`Bearer ${token}`);
+var basic = (user, password) => header("authorization", t`Basic ${base64(t`${user}:${password}`)}`);
+var declarePlacements = (method2, names, exposure, request) => {
+  const declared = new Set(names);
+  const refs = new Proxy(Object.fromEntries(names.map((name) => [name, new FieldRef(name)])), {
+    get: (target, key) => {
+      if (typeof key === "string" && !declared.has(key))
+        throw new TypeError(
+          `The ${method2} request references "${key}", which is not one of its fields: ${names.join(", ")}.`
+        );
+      return Reflect.get(target, key);
+    }
+  });
+  const returned = request(refs);
+  const placements = Array.isArray(returned) ? returned : [returned];
+  if (placements.length === 0) throw new TypeError(`The ${method2} request declares no placements.`);
+  if (!placements.every(Schema_exports.is(Placement)))
+    throw new TypeError(
+      `The ${method2} request must return header(...) or query(...) placements, or an array of them.`
+    );
+  for (const placement of placements) {
+    const fields = placementFields(placement);
+    for (const field of fields) {
+      if (!declared.has(field))
+        throw new TypeError(
+          `The ${method2} request references "${field}", which is not one of its fields: ${names.join(", ")}.`
+        );
+      if (exposure?.[field] === "raw")
+        throw new TypeError(
+          `The ${method2} request references the raw() field "${field}". App code reads raw fields as real values, so they are never placed; remove raw() or the reference.`
+        );
+    }
+    if (![...fields].some((field) => exposure?.[field] === void 0))
+      throw new TypeError(
+        `The ${method2} request's ${placement.in} ${placement.name} references no secret field. A placement places a secret: reference a field that is not plain() or raw().`
+      );
+  }
+  return normalizePlacements(placements);
+};
+var undeclared = (method2) => `The ${method2} account declares no request. Declare where its credentials go with request, such as request: ({ token }) => bearer(token), to use headers() and url().`;
+var withPlacements = (account, placements) => {
+  const fields = typeof account.fields === "object" && account.fields !== null ? account.fields : {};
+  const render = (placement) => Result_exports.getOrThrowWith(
+    renderPlacement(placement, fields),
+    (error) => new TypeError(error.message)
+  );
+  const declared = () => {
+    if (placements === void 0 || placements.length === 0)
+      throw new TypeError(undeclared(account.method));
+    return placements;
+  };
+  return Object.defineProperties(account, {
+    headers: {
+      enumerable: false,
+      value: () => Object.fromEntries(
+        declared().filter((placement) => placement.in === "header").map((placement) => [placement.name, render(placement)])
+      )
+    },
+    url: {
+      enumerable: false,
+      value: (input) => {
+        const url = new URL(input);
+        for (const placement of declared())
+          if (placement.in === "query") url.searchParams.set(placement.name, render(placement));
+        return url.href;
+      }
+    }
+  });
+};
+
+// src/implementation/workflows.ts
+var NativeWorkflow = /* @__PURE__ */ Symbol("apps.Workflow");
+var workflow = (options, run) => ({
+  [NativeWorkflow]: {
+    input: decoderOf(schemaArgument(options.input, "The workflow input")),
+    ...options.output === void 0 ? {} : { output: decoderOf(schemaArgument(options.output, "The workflow output")) },
+    ...options.description === void 0 ? {} : { description: options.description },
+    // SAFETY: defineApp checks required context; the host supplies the pinned run's capabilities.
+    run: (context, input) => fromPromise(run, "workflow")(context, input)
+  }
+});
+var nativeWorkflow = (value2) => {
+  if (typeof value2 !== "object" || value2 === null || !(NativeWorkflow in value2)) return void 0;
+  return value2[NativeWorkflow];
+};
+
+// src/implementation/events.ts
+var Native = /* @__PURE__ */ Symbol("apps.Event");
+var scalarTypes = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean"]);
+var isScalarSchema = (document) => {
+  const type = document.type;
+  if (typeof type === "string") return scalarTypes.has(type);
+  const choices = Array.isArray(document.enum) ? document.enum : "const" in document ? [document.const] : void 0;
+  return choices !== void 0 && choices.length > 0 && choices.every((value2) => ["string", "number", "boolean"].includes(typeof value2));
+};
+var event = (options) => {
+  const filters = options.filters ?? {};
+  const fieldDecoders = Object.fromEntries(
+    Object.entries(filters).map(([key, field]) => [
+      key,
+      decoderOf(schemaArgument(field, `The event filter ${JSON.stringify(key)}`))
+    ])
+  );
+  for (const [key, decoder] of Object.entries(fieldDecoders)) {
+    const document = Effect_exports.runSync(jsonSchemaDocument(decoder));
+    if (!isScalarSchema(document))
+      throw new TypeError(
+        `The event filter ${JSON.stringify(key)} must be a string, number, boolean or literal`
+      );
+  }
+  return {
+    [Native]: {
+      description: options.description,
+      filters: fieldDecoders,
+      payload: decoderOf(schemaArgument(options.payload, "The event payload"))
+    },
+    description: options.description,
+    filters,
+    payload: options.payload
+  };
+};
+var nativeEvent = (declaration) => typeof declaration === "object" && declaration !== null && Native in declaration ? declaration[Native] : void 0;
+var declaredEvents = (events) => Effect_exports.forEach(
+  Object.entries(events),
+  ([name, declared]) => Effect_exports.gen(function* () {
+    const filters = yield* jsonSchemaDocument(Schema_exports.Struct(declared.filters));
+    const payload = yield* jsonSchemaDocument(declared.payload);
+    return [name, { description: declared.description, filters, payload }];
+  })
+).pipe(Effect_exports.map((entries) => Object.fromEntries(entries)));
+var makeEmitter = (input) => ({
+  emit: (name, data, ...rest) => {
+    const options = rest[0] ?? {};
+    const declared = Object.hasOwn(input.events, name) ? input.events[name] : void 0;
+    if (declared === void 0) throw new TypeError(`This app declares no event named "${name}"`);
+    if (input.emitted.length >= defaultEventLimits.maxEventsPerInvocation)
+      throw new RangeError(
+        `An invocation can emit at most ${defaultEventLimits.maxEventsPerInvocation} events`
+      );
+    const payload = Schema_exports.decodeUnknownSync(declared.payload)(data);
+    const filters = Schema_exports.decodeUnknownSync(Schema_exports.Struct(declared.filters))(
+      options.filters ?? {}
+    );
+    const account = options.account ?? input.sourceAccount ?? (input.accounts.length === 1 ? input.accounts[0] : void 0) ?? null;
+    if (account === null && input.accounts.length > 1)
+      throw new TypeError(
+        "This invocation has several accounts; name the one the event came from with { account }"
+      );
+    if (account !== null && !input.accounts.includes(account))
+      throw new TypeError("The event's account is not one of this invocation's accounts");
+    const occurredAt = options.occurredAt === void 0 ? Date.now() : options.occurredAt instanceof Date ? options.occurredAt.getTime() : options.occurredAt;
+    const occurrence = Schema_exports.decodeUnknownSync(EmittedEvent)({
+      name: Schema_exports.decodeUnknownSync(EventName)(name),
+      id: options.id ?? crypto.randomUUID(),
+      occurredAt,
+      data: payload,
+      filters,
+      account
+    });
+    if (new TextEncoder().encode(JSON.stringify(occurrence.data)).byteLength > defaultEventLimits.maxDataBytes)
+      throw new RangeError(
+        `An event's data can be at most ${defaultEventLimits.maxDataBytes} bytes of JSON; send a summary and a tool to read the rest`
+      );
+    input.emitted.push(occurrence);
+  }
+});
+
+// src/implementation/app.ts
+var InternalApp = /* @__PURE__ */ Symbol("apps.App");
+var isApp = (value2) => typeof value2 === "object" && value2 !== null && InternalApp in value2;
+var toEffectApp = (app) => app[InternalApp];
+function rejectCatalogs(definition) {
+  if ("queries" in definition || "mutations" in definition)
+    throw new Error("Put queries and mutations in a router under tools");
+}
+function adaptDefinition(definition) {
+  rejectCatalogs(definition);
+  const webhooks = definition.webhooks === void 0 ? {} : {
+    // SAFETY: `Required` only where the optional method was just checked to be present.
+    webhooks: Object.fromEntries(
+      Object.entries(definition.webhooks).map(([name, webhook]) => [
+        name,
+        {
+          ...webhook,
+          ...webhook.register === void 0 ? {} : {
+            register: fromPromise(
+              method(webhook, "register"),
+              "webhook"
+            )
+          },
+          handle: fromPromise(method(webhook, "handle"), "webhook"),
+          ...webhook.unregister === void 0 ? {} : {
+            unregister: fromPromise(
+              method(webhook, "unregister"),
+              "webhook"
+            )
+          },
+          ..."config" in webhook && isSchema(webhook.config) ? { config: decoderOf(webhook.config) } : {},
+          ..."state" in webhook && isSchema(webhook.state) ? { state: decoderOf(webhook.state) } : {}
+        }
+      ])
+    )
+  };
+  const workflows = definition.workflows === void 0 ? {} : {
+    workflows: Object.fromEntries(
+      Object.entries(definition.workflows).map(([name, value2]) => {
+        const declared2 = nativeWorkflow(value2);
+        if (declared2 === void 0) throw new Error("Invalid workflow declaration");
+        return [name, declared2];
+      })
+    )
+  };
+  const root = definition.tools === void 0 ? void 0 : nativeRouter(definition.tools);
+  if (definition.tools !== void 0 && root === void 0)
+    throw new Error("tools must be a router");
+  const data = root === void 0 ? {} : { tools: root };
+  const declared = root?.kind === "router" ? declaredOperations(root) : [];
+  const mutations = /* @__PURE__ */ new Set();
+  for (const { operation } of declared) {
+    if (operation.kind !== "mutation") continue;
+    if (mutations.has(operation))
+      throw new Error("A mutation can be mounted at only one path in tools");
+    mutations.add(operation);
+  }
+  const schedules = definition.schedules === void 0 ? {} : {
+    schedules: Object.fromEntries(
+      Object.entries(definition.schedules).map(([name, schedule]) => {
+        const target = nativeOperation(schedule.operation);
+        const match = declared.find(
+          ({ operation }) => operation === target && operation.kind === "mutation"
+        );
+        if (match === void 0)
+          throw new Error("A schedule must reference a mutation in this app's tools");
+        return [
+          name,
+          {
+            timing: Schema_exports.decodeUnknownSync(ScheduleTiming)(schedule.timing),
+            input: Schema_exports.decodeUnknownSync(JsonValue)(schedule.input),
+            tool: match.name
+          }
+        ];
+      })
+    )
+  };
+  return {
+    ...definition,
+    ...webhooks,
+    ...workflows,
+    ...data,
+    ...schedules
+  };
+}
+var defineApp = (requirements, definition) => {
+  if (typeof definition !== "function") rejectCatalogs(definition);
+  const evaluate = typeof definition === "function" ? definition : async () => definition;
+  const factory = fromPromise(evaluate, "factory");
+  const events = requirements.events === void 0 ? void 0 : Object.fromEntries(
+    Object.entries(requirements.events).map(([name, declared]) => {
+      const native2 = nativeEvent(declared);
+      if (native2 === void 0)
+        throw new TypeError(
+          `The event ${JSON.stringify(name)} must be declared with event()`
+        );
+      return [name, native2];
+    })
+  );
+  const native = {
+    accounts: requirements.accounts,
+    ...events === void 0 ? {} : { events },
+    evaluate: (context) => factory(context).pipe(Effect_exports.map((value2) => adaptDefinition(value2)))
+  };
+  return {
+    [InternalApp]: native,
+    accounts: native.accounts,
+    evaluate: (context) => Effect_exports.runPromise(factory(context))
+  };
+};
+
+export {
+  ResponseStatusError,
+  ResponseDecodeError,
+  t,
+  base64,
+  header,
+  query,
+  bearer,
+  basic,
+  declarePlacements,
+  withPlacements,
+  workflow,
+  event,
+  declaredEvents,
+  makeEmitter,
+  isApp,
+  toEffectApp,
+  defineApp
+};