apps 0.0.1-beta.3 → 0.0.1-beta.31

package/js/{chunk-SATWJKN6.js → chunk-FBBXFFFJ.js}

@@ -1,6 +1,6 @@
 import {
   Schema_exports
-} from "./chunk-FW5HBOIK.js";
+} from "./chunk-EXGKN554.js";
 
 // src/contracts/schema.ts
 var JsonValue = Schema_exports.Json;

package/js/{chunk-JN55AYQH.js → chunk-FULRJSWU.js}

@@ -1,29 +1,51 @@
 import {
-  parseDatabaseSchema,
   promiseTable
-} from "./chunk-PLCMJREA.js";
+} from "./chunk-5JVNM3CQ.js";
 import {
+  declaredOperations,
   fromPromise,
-  nativeOperation
-} from "./chunk-PYUYJRSK.js";
+  nativeOperation,
+  nativeRouter
+} from "./chunk-5XJR4XGW.js";
 import {
   ScheduleTiming
-} from "./chunk-MYYEW3RA.js";
+} from "./chunk-N72RKJ5E.js";
+import {
+  DatabaseSchema
+} from "./chunk-UMCMZFXW.js";
 import {
   decoderOf,
   isSchema,
   storageFieldOf
-} from "./chunk-WFSQXYUT.js";
+} from "./chunk-NPGRURDG.js";
 import {
   AppStorageUnavailable
-} from "./chunk-FZJOYIZO.js";
+} from "./chunk-6KG4DZD7.js";
 import {
   JsonValue
-} from "./chunk-SATWJKN6.js";
+} from "./chunk-FBBXFFFJ.js";
 import {
   Effect_exports,
   Schema_exports
-} from "./chunk-FW5HBOIK.js";
+} from "./chunk-EXGKN554.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");
@@ -48,8 +70,12 @@ var nativeWorkflow = (value) => {
 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) {
-  if ("tools" in definition) throw new Error("Use queries and mutations instead of tools");
+  rejectCatalogs(definition);
   const webhooks = definition.webhooks === void 0 ? {} : {
     webhooks: Object.fromEntries(
       Object.entries(definition.webhooks).map(([name, webhook]) => [
@@ -65,42 +91,42 @@ function adaptDefinition(definition) {
       ])
     )
   };
-  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 declared2 = nativeWorkflow(value);
+        if (declared2 === void 0) throw new Error("Invalid workflow declaration");
+        return [name, declared2];
       })
     )
   };
-  const data = {
-    ...definition.queries === void 0 ? {} : { queries: operations("query", definition.queries) },
-    ...definition.mutations === void 0 ? {} : { mutations: operations("mutation", definition.mutations) }
-  };
+  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 matches = Object.entries(definition.mutations ?? {}).filter(
-          ([, operation]) => operation === schedule.operation
+        const target = nativeOperation(schedule.operation);
+        const match = declared.find(
+          ({ operation }) => operation === target && operation.kind === "mutation"
         );
-        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");
+        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: `mutations.${match[0]}`
+            tool: match.name
           }
         ];
       })
@@ -115,6 +141,7 @@ function adaptDefinition(definition) {
   };
 }
 var defineApp = (requirements, definition) => {
+  if (typeof definition !== "function") rejectCatalogs(definition);
   const evaluate = typeof definition === "function" ? definition : async () => definition;
   const factory = fromPromise(evaluate);
   const native = {
@@ -152,7 +179,7 @@ var serialize = (tables) => {
       }
     ])
   );
-  return Effect_exports.runSync(parseDatabaseSchema(definitions));
+  return Schema_exports.decodeUnknownSync(DatabaseSchema)(definitions);
 };
 var authorDatabase = (tables, session, signal, writable) => {
   return Object.fromEntries(
@@ -202,6 +229,8 @@ var unavailableStorage = {
 };
 
 export {
+  ResponseStatusError,
+  ResponseDecodeError,
   workflow,
   isApp,
   toEffectApp,

package/js/{chunk-HDTGZWP2.js → chunk-GG566OOE.js}

@@ -1,37 +1,52 @@
 import {
   adaptMcpTools,
+  answeredError,
   mcpClient,
   mcpJsonSchemaValidator
-} from "./chunk-RN2MXB4R.js";
+} from "./chunk-3FJYVAE4.js";
+import {
+  failOnNetworkRefusal
+} from "./chunk-RULZPNGP.js";
 import {
   accountProviderError,
-  httpProviderError
-} from "./chunk-ZJWDMTE3.js";
+  bodyUpstreamError,
+  httpProviderError,
+  providerErrorDetail
+} from "./chunk-4OKYLVU4.js";
 import {
+  McpCredentialsUnverified,
   McpError,
+  McpHealthInput,
   McpToolsOptions,
-  defaultMcpClientLimits
-} from "./chunk-MYYEW3RA.js";
+  NetworkRefused,
+  defaultMcpClientLimits,
+  mcpHealthReserveMs
+} from "./chunk-N72RKJ5E.js";
 import {
   ProviderError
-} from "./chunk-W7D7WVSY.js";
+} from "./chunk-5DLG2FVN.js";
 import {
   captureTelemetry
-} from "./chunk-ZCAMUXSG.js";
+} from "./chunk-ETLILMHY.js";
 import {
   FetchHttpClient_exports
-} from "./chunk-HDJH3RPR.js";
+} from "./chunk-MFHUR5SB.js";
 import {
   HttpClientRequest_exports,
   HttpClient_exports
-} from "./chunk-QKHR7BMF.js";
+} from "./chunk-CJY5X26R.js";
 import {
+  Clock_exports,
   Deferred_exports,
   Effect_exports,
+  Match_exports,
+  Option_exports,
+  Predicate_exports,
   Redacted_exports,
+  Ref_exports,
   Schema_exports,
   Stream_exports
-} from "./chunk-FW5HBOIK.js";
+} from "./chunk-EXGKN554.js";
 
 // src/implementation/mcp.ts
 import { UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js";
@@ -46,18 +61,45 @@ import {
   StreamableHTTPClientTransport,
   StreamableHTTPError
 } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+var unreadable = (error) => error instanceof SyntaxError || error instanceof Error && Predicate_exports.hasProperty(error, "issues") && Array.isArray(error.issues);
 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;
+  if (Schema_exports.is(ProviderError)(error) || Schema_exports.is(McpError)(error) || Schema_exports.is(NetworkRefused)(error))
+    return error;
+  const code = error instanceof UnauthorizedError ? 401 : error instanceof StreamableHTTPError || error instanceof SseError ? error.code : void 0;
+  if (code !== void 0 && code >= 300 && code <= 599)
+    return httpProviderError(code) ?? new McpError({ phase, reason: "request", status: code });
+  const upstream = answeredError(error);
   return new McpError({
     phase,
-    reason: error instanceof ProtocolError && error.code === ErrorCode.RequestTimeout ? "timeout" : "request",
-    ...status === void 0 ? {} : { status }
+    reason: code !== void 0 || unreadable(error) ? "invalid_response" : error instanceof ProtocolError && error.code === ErrorCode.RequestTimeout ? "timeout" : "request",
+    ...upstream === void 0 ? {} : { upstream }
   });
 };
-var transportFetch = (connection, telemetry, rejected) => (url, init) => Effect_exports.runPromiseWith(telemetry.context)(
+var errorBodyLimits = { maxBytes: 65536, readTimeoutMs: 2e3 };
+var errorBody = (response) => Effect_exports.gen(function* () {
+  const json = /^application\/(?:[\w.-]+\+)?json$/i.test(
+    response.headers["content-type"]?.split(";")[0]?.trim() ?? ""
+  );
+  const length = response.headers["content-length"];
+  if (!json || length !== void 0 && Number(length) > errorBodyLimits.maxBytes)
+    return { body: Stream_exports.toReadableStream(response.stream), upstream: void 0 };
+  const unreadable2 = new McpError({ phase: "transport", reason: "invalid_response" });
+  const read = yield* response.stream.pipe(
+    Stream_exports.mapError(() => unreadable2),
+    Stream_exports.limitBytes(errorBodyLimits.maxBytes, () => Stream_exports.fail(unreadable2)),
+    Stream_exports.decodeText,
+    Stream_exports.mkString,
+    Effect_exports.timeout(errorBodyLimits.readTimeoutMs),
+    Effect_exports.option
+  );
+  if (Option_exports.isNone(read)) return { body: null, upstream: void 0 };
+  const parsed = Schema_exports.decodeUnknownOption(Schema_exports.fromJsonString(Schema_exports.Json))(read.value);
+  return {
+    body: read.value,
+    upstream: Option_exports.isSome(parsed) ? bodyUpstreamError(parsed.value) : void 0
+  };
+});
+var transportFetch = (connection, telemetry, rejected, answered) => (url, init) => Effect_exports.runPromiseWith(telemetry.context)(
   Effect_exports.gen(function* () {
     const target = yield* Effect_exports.try({
       try: () => new URL(url),
@@ -67,26 +109,37 @@ var transportFetch = (connection, telemetry, rejected) => (url, init) => Effect_
       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)
+      try: () => {
+        const headers = new Headers(Redacted_exports.value(connection.headers));
+        new Headers(init?.headers).forEach((value, name) => headers.set(name, value));
+        return HttpClientRequest_exports.fromWeb(new Request(target, { ...init, headers }));
+      },
+      // The provider's headers cannot form an HTTP request, such as a name with a space.
+      catch: () => new McpError({ phase: "transport", reason: "invalid_input" })
     });
     const client = yield* HttpClient_exports.HttpClient;
     const response = yield* client.execute(request);
+    yield* failOnNetworkRefusal(response).pipe(
+      Effect_exports.tapError((refused) => Deferred_exports.fail(rejected, refused))
+    );
+    if (response.status < 400)
+      return new Response(
+        [204, 205, 304].includes(response.status) ? null : Stream_exports.toReadableStream(response.stream),
+        {
+          status: response.status,
+          headers: response.headers
+        }
+      );
+    const { body, upstream } = yield* errorBody(response);
     const provider = httpProviderError(response.status, response.headers);
     if (provider !== void 0) {
-      yield* Deferred_exports.fail(rejected, provider);
-      return yield* provider;
+      const refused = providerErrorDetail(provider, { upstream });
+      yield* Deferred_exports.fail(rejected, refused);
+      return yield* refused;
     }
-    return new Response(
-      [204, 205, 304].includes(response.status) ? null : Stream_exports.toReadableStream(response.stream),
-      {
-        status: response.status,
-        headers: response.headers
-      }
-    );
+    yield* Ref_exports.set(answered, { status: response.status, upstream });
+    return new Response(body, { status: response.status, headers: response.headers });
   }).pipe(
     Effect_exports.provide(FetchHttpClient_exports.layer),
     Effect_exports.provideService(FetchHttpClient_exports.RequestInit, { redirect: "manual" }),
@@ -104,15 +157,30 @@ var transportFetch = (connection, telemetry, rejected) => (url, init) => Effect_
   ),
   init?.signal ? { signal: init.signal } : {}
 );
+var explain = (error, phase, response) => {
+  if (Schema_exports.is(ProviderError)(error)) return providerErrorDetail(error, { phase });
+  if (!Schema_exports.is(McpError)(error) || error.upstream !== void 0 || error.status === void 0 || response?.status !== error.status || response.upstream === void 0)
+    return error;
+  return new McpError({
+    phase: error.phase,
+    reason: error.reason,
+    status: error.status,
+    upstream: response.upstream
+  });
+};
+var explained = (phase, answered) => (error) => Ref_exports.get(answered).pipe(
+  Effect_exports.flatMap((response) => Effect_exports.fail(explain(error, phase, response)))
+);
 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 answered = yield* Ref_exports.make(void 0);
       const pending = /* @__PURE__ */ new Set();
       const { client, transport } = yield* Effect_exports.acquireRelease(
         Effect_exports.sync(() => {
-          const fetch = transportFetch(connection, telemetry, rejected);
+          const fetch = transportFetch(connection, telemetry, rejected, answered);
           const client2 = new Client(
             { name: "executor-apps", version: "0.1.0" },
             {
@@ -168,10 +236,14 @@ function withClient(connection, mode, use, changed) {
         catch: (error) => failure("connect", error)
       }).pipe(
         Effect_exports.raceFirst(Deferred_exports.await(rejected)),
+        Effect_exports.catch(explained("connect", answered)),
         Effect_exports.timeout(connection.timeoutMs),
         Effect_exports.withSpan("provider.mcp.connect")
       );
-      return yield* use(client).pipe(Effect_exports.raceFirst(Deferred_exports.await(rejected)));
+      return yield* use(client).pipe(
+        Effect_exports.raceFirst(Deferred_exports.await(rejected)),
+        Effect_exports.catch(explained(mode, answered))
+      );
     })
   ).pipe(
     Effect_exports.withSpan("provider.mcp.session", {
@@ -216,9 +288,44 @@ var mcpClientEffect = (input, changed) => Effect_exports.gen(function* () {
     failure
   );
 });
+var refusesCredentials = (error) => Schema_exports.is(ProviderError)(error) && Match_exports.value(error.reason).pipe(
+  Match_exports.whenOr("unauthorized", "forbidden", "rejected", () => true),
+  Match_exports.whenOr("rate_limited", "unavailable", () => false),
+  Match_exports.exhaustive
+);
+var mcpHealthEffect = (check, options) => Effect_exports.gen(function* () {
+  const { deadline, timeoutMs, ...parsed } = yield* Schema_exports.decodeUnknownEffect(McpHealthInput)({
+    ...options,
+    accountId: check.account.id,
+    signal: check.signal,
+    deadline: check.deadline
+  }).pipe(Effect_exports.mapError(() => new McpError({ phase: "connect", reason: "invalid_input" })));
+  const end = Math.min(
+    (yield* Clock_exports.currentTimeMillis) + (timeoutMs ?? defaultMcpClientLimits.timeoutMs),
+    deadline === void 0 ? Number.POSITIVE_INFINITY : deadline - mcpHealthReserveMs
+  );
+  const remaining = Effect_exports.flatMap(
+    Clock_exports.currentTimeMillis,
+    (now) => end - now >= 1 ? Effect_exports.succeed(Math.floor(end - now)) : Effect_exports.fail(new McpError({ phase: "transport", reason: "timeout" }))
+  );
+  yield* (yield* mcpClientEffect({ ...parsed, timeoutMs: yield* remaining })).check;
+  return yield* remaining.pipe(
+    Effect_exports.flatMap(
+      (timeoutMs2) => mcpClientEffect({ url: parsed.url, signal: parsed.signal, timeoutMs: timeoutMs2 })
+    ),
+    Effect_exports.flatMap((anonymous) => anonymous.check),
+    Effect_exports.matchEffect({
+      onSuccess: () => Effect_exports.fail(new McpCredentialsUnverified({ anonymous: "answered" })),
+      // Executor's network refused the attempt, so the server never answered it.
+      onFailure: (error) => Schema_exports.is(NetworkRefused)(error) ? Effect_exports.fail(error) : refusesCredentials(error) ? Effect_exports.void : Effect_exports.fail(new McpCredentialsUnverified({ anonymous: error }))
+    }),
+    Effect_exports.withSpan("provider.mcp.anonymous")
+  );
+}).pipe(Effect_exports.withSpan("provider.mcp.health"));
 var mcpToolsEffect = (input) => mcpClientEffect(input).pipe(Effect_exports.flatMap(adaptMcpTools));
 
 export {
   mcpClientEffect,
+  mcpHealthEffect,
   mcpToolsEffect
 };

package/js/chunk-GZ4UHXRT.js

@@ -0,0 +1,92 @@
+import {
+  JsonValue
+} from "./chunk-FBBXFFFJ.js";
+import {
+  HttpApiEndpoint_exports,
+  HttpApiGroup_exports,
+  HttpApiSchema_exports,
+  HttpApi_exports
+} from "./chunk-QYM4STZW.js";
+import {
+  Schema_exports
+} from "./chunk-EXGKN554.js";
+
+// src/contracts/ui.ts
+var UiContext = Schema_exports.Struct({
+  deployment: Schema_exports.NonEmptyString,
+  profile: Schema_exports.optional(Schema_exports.NonEmptyString),
+  expectedProfileRevision: Schema_exports.optional(Schema_exports.Int)
+});
+var UiOperation = Schema_exports.Struct({
+  ...UiContext.fields,
+  name: Schema_exports.NonEmptyString,
+  input: JsonValue
+});
+var UiUnauthorized = class extends Schema_exports.TaggedError()(
+  "UiUnauthorized",
+  {},
+  { httpApiStatus: 401 }
+) {
+};
+var UiForbidden = class extends Schema_exports.TaggedError()(
+  "UiForbidden",
+  {},
+  { httpApiStatus: 403 }
+) {
+};
+var UiDeploymentChanged = class extends Schema_exports.TaggedError()(
+  "UiDeploymentChanged",
+  {},
+  { httpApiStatus: 409 }
+) {
+};
+var UiFailed = class extends Schema_exports.TaggedError()(
+  "UiFailed",
+  {
+    reason: Schema_exports.Literals(["unavailable", "operation_failed", "account_required"])
+  },
+  { httpApiStatus: 422 }
+) {
+};
+var UiSnapshot = Schema_exports.Union([
+  Schema_exports.Struct({
+    type: Schema_exports.Literal("snapshot"),
+    value: JsonValue,
+    trace: Schema_exports.optional(Schema_exports.Unknown)
+  }),
+  Schema_exports.Struct({ type: Schema_exports.Literal("failure"), error: UiFailed }),
+  Schema_exports.Struct({ type: Schema_exports.Literal("heartbeat") })
+]);
+var errors = [UiUnauthorized, UiForbidden, UiDeploymentChanged, UiFailed];
+var AppUiApi = HttpApi_exports.make("app-ui").add(
+  HttpApiGroup_exports.make("ui").add(
+    HttpApiEndpoint_exports.post("query", "/_executor/api/query", {
+      payload: UiOperation,
+      success: JsonValue,
+      error: errors
+    })
+  ).add(
+    HttpApiEndpoint_exports.post("mutate", "/_executor/api/mutate", {
+      payload: UiOperation,
+      success: JsonValue,
+      error: errors
+    })
+  ).add(
+    HttpApiEndpoint_exports.post("subscribe", "/_executor/api/subscribe", {
+      payload: UiOperation,
+      success: HttpApiSchema_exports.StreamSse({ data: UiSnapshot, error: Schema_exports.Union(errors) }),
+      error: errors
+    })
+  )
+);
+
+export {
+  UiContext,
+  UiOperation,
+  UiUnauthorized,
+  UiForbidden,
+  UiDeploymentChanged,
+  UiFailed,
+  UiSnapshot,
+  AppUiApi
+};

package/js/{chunk-YEJOQEII.js → chunk-HW3DPBZR.js}

@@ -1,6 +1,36 @@
 import {
+  SchemaGetter_exports,
   Schema_exports
-} from "./chunk-FW5HBOIK.js";
+} from "./chunk-EXGKN554.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 }
+  );
+  Object.defineProperty(DefinedError.prototype, "message", {
+    get() {
+      return typeof message === "string" ? message : message(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 +75,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,9 +97,8 @@ var SkillDefinitionInvalid = class extends Schema_exports.TaggedError()(
       "name-mismatch"
     ])
   },
-  { httpApiStatus: 400 }
-) {
-};
+  message: ({ file, reason }) => skillDefinitionFailures[reason](file)
+});
 var AppSkills = Schema_exports.Array(AppSkillSource).check(
   Schema_exports.makeFilter((skills) => new Set(skills.map((skill) => skill.name)).size === skills.length)
 );

package/js/{chunk-HDJH3RPR.js → chunk-MFHUR5SB.js}

@@ -4,7 +4,7 @@ import {
   fromWeb,
   layerMergedContext,
   make2 as make
-} from "./chunk-QKHR7BMF.js";
+} from "./chunk-CJY5X26R.js";
 import {
   Reference,
   Service,
@@ -17,7 +17,7 @@ import {
   succeed4 as succeed,
   toReadableStreamEffect,
   tryPromise
-} from "./chunk-FW5HBOIK.js";
+} from "./chunk-EXGKN554.js";
 import {
   __export
 } from "./chunk-CZ7CSFO4.js";