apps 0.0.1-beta.5 → 0.0.1-beta.54

package/js/chunk-GDYPM7RS.js

@@ -0,0 +1,266 @@
+import {
+  declaredOperations,
+  nativeOperation,
+  nativeRouter
+} from "./chunk-X5U5KIWQ.js";
+import {
+  fromPromise,
+  method
+} from "./chunk-LTDHQJ2Z.js";
+import {
+  EmittedEvent,
+  EventName,
+  ScheduleTiming,
+  defaultEventLimits
+} from "./chunk-JY56GVSV.js";
+import {
+  decoderOf,
+  isSchema,
+  jsonSchemaDocument,
+  schemaArgument
+} from "./chunk-KGCTYL2S.js";
+import {
+  JsonValue
+} from "./chunk-H2CJWXA3.js";
+import {
+  Effect_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/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 = (value) => {
+  if (typeof value !== "object" || value === null || !(NativeWorkflow in value)) return void 0;
+  return value[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((value) => ["string", "number", "boolean"].includes(typeof value));
+};
+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 = (value) => typeof value === "object" && value !== null && InternalApp in value;
+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, value]) => {
+        const declared2 = nativeWorkflow(value);
+        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((value) => adaptDefinition(value)))
+  };
+  return {
+    [InternalApp]: native,
+    accounts: native.accounts,
+    evaluate: (context) => Effect_exports.runPromise(factory(context))
+  };
+};
+
+export {
+  ResponseStatusError,
+  ResponseDecodeError,
+  workflow,
+  event,
+  declaredEvents,
+  makeEmitter,
+  isApp,
+  toEffectApp,
+  defineApp
+};

package/js/{chunk-27F7W2LG.js → chunk-H2CJWXA3.js}

@@ -1,12 +1,12 @@
 import {
   Schema_exports
-} from "./chunk-CDL5PM2Q.js";
+} from "./chunk-IFJU5SYQ.js";
 
 // src/contracts/schema.ts
 var JsonValue = Schema_exports.Json;
 var JsonObject = Schema_exports.Record(Schema_exports.String, JsonValue);
 var AccountId = Schema_exports.String.pipe(
-  Schema_exports.check(Schema_exports.isStartsWith("acc_"), Schema_exports.isMinLength(5)),
+  Schema_exports.check(Schema_exports.isStartingWith("acc_"), Schema_exports.isMinLength(5)),
   Schema_exports.brand("acc")
 );
 var HttpUrl = Schema_exports.String.check(

package/js/{chunk-JU7VHODU.js → chunk-H72MEDMN.js}

@@ -1,6 +1,49 @@
 import {
+  RecordedMessage
+} from "./chunk-5FHWNLCI.js";
+import {
+  SchemaGetter_exports,
   Schema_exports
-} from "./chunk-CDL5PM2Q.js";
+} from "./chunk-IFJU5SYQ.js";
+
+// ../utils/src/api-error.ts
+var MessageField = Schema_exports.String.pipe(
+  Schema_exports.decodeTo(Schema_exports.optionalKey(Schema_exports.String), {
+    decode: SchemaGetter_exports.omit(),
+    encode: SchemaGetter_exports.passthrough()
+  })
+);
+function withFields(definition) {
+  const fields = definition.fields;
+  const message = definition.message;
+  const documentation = typeof message === "string" ? { description: message } : {};
+  const DefinedError = Schema_exports.Error(definition.tag)(
+    Schema_exports.TaggedStruct(definition.tag, { ...fields, message: MessageField }).annotate(
+      documentation
+    ),
+    { httpApiStatus: definition.status, ...documentation }
+  );
+  const recorded = definition.recorded ?? (typeof message === "string" ? () => message : void 0);
+  Object.defineProperties(DefinedError.prototype, {
+    message: {
+      get() {
+        return typeof message === "string" ? message : message(this);
+      }
+    },
+    ...recorded === void 0 ? {} : {
+      [RecordedMessage]: {
+        get() {
+          return recorded(this);
+        }
+      }
+    }
+  });
+  return DefinedError;
+}
+function define(definition) {
+  return "fields" in definition ? withFields(definition) : withFields({ ...definition, fields: {} });
+}
+var ApiError = { define };
 
 // src/contracts/skills.ts
 var SkillFilePath = Schema_exports.NonEmptyString.check(
@@ -45,9 +88,18 @@ var AppSkillSource = Schema_exports.Struct({
     )
   )
 });
-var SkillDefinitionInvalid = class extends Schema_exports.TaggedError()(
-  "SkillDefinitionInvalid",
-  {
+var skillDefinitionFailures = {
+  files: (file) => `The skill files of \u201C${file}\u201D are invalid: each needs a unique relative path, text content and a SKILL.md document.`,
+  directory: (file) => `\u201C${file}\u201D is not a valid skill directory. Skill directory names use lowercase letters and digits separated by single hyphens.`,
+  "missing-document": (file) => `\u201C${file}\u201D is missing.`,
+  frontmatter: (file) => `\u201C${file}\u201D must start with valid YAML frontmatter between --- lines.`,
+  metadata: (file) => `The frontmatter of \u201C${file}\u201D needs a valid name and description within the Agent Skills limits.`,
+  "name-mismatch": (file) => `The name in \u201C${file}\u201D does not match its skill directory.`
+};
+var SkillDefinitionInvalid = ApiError.define({
+  tag: "SkillDefinitionInvalid",
+  status: 400,
+  fields: {
     file: SkillFilePath,
     reason: Schema_exports.Literals([
       "files",
@@ -58,14 +110,14 @@ var SkillDefinitionInvalid = class extends Schema_exports.TaggedError()(
       "name-mismatch"
     ])
   },
-  { httpApiStatus: 400 }
-) {
-};
+  message: ({ file, reason }) => skillDefinitionFailures[reason](file),
+  recorded: ({ reason }) => `The app's skill definition is invalid (${reason})`
+});
 var AppSkills = Schema_exports.Array(AppSkillSource).check(
   Schema_exports.makeFilter((skills) => new Set(skills.map((skill) => skill.name)).size === skills.length)
 );
 var SkillServiceName = Schema_exports.String.check(
-  Schema_exports.isPattern(/^[A-Za-z0-9](?:[A-Za-z0-9 .-]{0,98}[A-Za-z0-9])?$/)
+  Schema_exports.isPattern(/^[A-Za-z0-9](?:[A-Za-z0-9 .-]{0,98}[A-Za-z0-9])?$/u)
 );
 var SkillLoadFailed = class extends Schema_exports.TaggedError()("SkillLoadFailed", {
   reason: Schema_exports.Literals([
@@ -79,14 +131,17 @@ var SkillLoadFailed = class extends Schema_exports.TaggedError()("SkillLoadFaile
   ]),
   // Error instances read an omitted message as "", so an empty message means none was given.
   message: Schema_exports.optional(Schema_exports.String.check(Schema_exports.isMaxLength(500))),
-  status: Schema_exports.optional(Schema_exports.Int.check(Schema_exports.isBetween({ minimum: 100, maximum: 599 })))
+  status: Schema_exports.optional(Schema_exports.Int.check(Schema_exports.isBetween({ minimum: 100, maximum: 599 }))),
+  missing: Schema_exports.optional(Schema_exports.Literals(["repository", "ref"]))
 }) {
 };
 var skillLoadLimits = {
   files: 1e3,
   fileBytes: 2e6,
   totalBytes: 2e7,
-  concurrency: 8
+  concurrency: 8,
+  /** The request that checks whether a kept catalog's publication changed. */
+  checkMillis: 5e3
 };
 
 export {