apps 0.0.1-beta.1 → 0.0.1-beta.2

package/js/{chunk-NCYXZN2G.js → chunk-UVL56Z6E.js}

@@ -1,3 +1,41 @@
+import {
+  __export
+} from "./chunk-CZ7CSFO4.js";
+
+// ../../node_modules/.bun/yaml@2.9.1/node_modules/yaml/browser/dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  Alias: () => Alias,
+  CST: () => cst_exports,
+  Composer: () => Composer,
+  Document: () => Document,
+  Lexer: () => Lexer,
+  LineCounter: () => LineCounter,
+  Pair: () => Pair,
+  Parser: () => Parser,
+  Scalar: () => Scalar,
+  Schema: () => Schema,
+  YAMLError: () => YAMLError,
+  YAMLMap: () => YAMLMap,
+  YAMLParseError: () => YAMLParseError,
+  YAMLSeq: () => YAMLSeq,
+  YAMLWarning: () => YAMLWarning,
+  isAlias: () => isAlias,
+  isCollection: () => isCollection,
+  isDocument: () => isDocument,
+  isMap: () => isMap,
+  isNode: () => isNode,
+  isPair: () => isPair,
+  isScalar: () => isScalar,
+  isSeq: () => isSeq,
+  parse: () => parse,
+  parseAllDocuments: () => parseAllDocuments,
+  parseDocument: () => parseDocument,
+  stringify: () => stringify3,
+  visit: () => visit,
+  visitAsync: () => visitAsync
+});
+
 // ../../node_modules/.bun/yaml@2.9.1/node_modules/yaml/browser/dist/nodes/identity.js
 var ALIAS = /* @__PURE__ */ Symbol.for("yaml.alias");
 var DOC = /* @__PURE__ */ Symbol.for("yaml.document");
@@ -4632,30 +4670,251 @@ ${end.comment}` : end.comment;
   }
 };
 
-// ../../node_modules/.bun/yaml@2.9.1/node_modules/yaml/browser/dist/parse/line-counter.js
-var LineCounter = class {
-  constructor() {
-    this.lineStarts = [];
-    this.addNewLine = (offset) => this.lineStarts.push(offset);
-    this.linePos = (offset) => {
-      let low = 0;
-      let high = this.lineStarts.length;
-      while (low < high) {
-        const mid = low + high >> 1;
-        if (this.lineStarts[mid] < offset)
-          low = mid + 1;
-        else
-          high = mid;
-      }
-      if (this.lineStarts[low] === offset)
-        return { line: low + 1, col: 1 };
-      if (low === 0)
-        return { line: 0, col: offset };
-      const start = this.lineStarts[low - 1];
-      return { line: low, col: offset - start + 1 };
+// ../../node_modules/.bun/yaml@2.9.1/node_modules/yaml/browser/dist/parse/cst.js
+var cst_exports = {};
+__export(cst_exports, {
+  BOM: () => BOM,
+  DOCUMENT: () => DOCUMENT,
+  FLOW_END: () => FLOW_END,
+  SCALAR: () => SCALAR2,
+  createScalarToken: () => createScalarToken,
+  isCollection: () => isCollection2,
+  isScalar: () => isScalar2,
+  prettyToken: () => prettyToken,
+  resolveAsScalar: () => resolveAsScalar,
+  setScalarValue: () => setScalarValue,
+  stringify: () => stringify2,
+  tokenType: () => tokenType,
+  visit: () => visit2
+});
+
+// ../../node_modules/.bun/yaml@2.9.1/node_modules/yaml/browser/dist/parse/cst-scalar.js
+function resolveAsScalar(token, strict = true, onError) {
+  if (token) {
+    const _onError = (pos, code, message) => {
+      const offset = typeof pos === "number" ? pos : Array.isArray(pos) ? pos[0] : pos.offset;
+      if (onError)
+        onError(offset, code, message);
+      else
+        throw new YAMLParseError([offset, offset + 1], code, message);
     };
+    switch (token.type) {
+      case "scalar":
+      case "single-quoted-scalar":
+      case "double-quoted-scalar":
+        return resolveFlowScalar(token, strict, _onError);
+      case "block-scalar":
+        return resolveBlockScalar({ options: { strict } }, token, _onError);
+    }
   }
-};
+  return null;
+}
+function createScalarToken(value, context) {
+  const { implicitKey = false, indent, inFlow = false, offset = -1, type = "PLAIN" } = context;
+  const source = stringifyString({ type, value }, {
+    implicitKey,
+    indent: indent > 0 ? " ".repeat(indent) : "",
+    inFlow,
+    options: { blockQuote: true, lineWidth: -1 }
+  });
+  const end = context.end ?? [
+    { type: "newline", offset: -1, indent, source: "\n" }
+  ];
+  switch (source[0]) {
+    case "|":
+    case ">": {
+      const he = source.indexOf("\n");
+      const head = source.substring(0, he);
+      const body = source.substring(he + 1) + "\n";
+      const props = [
+        { type: "block-scalar-header", offset, indent, source: head }
+      ];
+      if (!addEndtoBlockProps(props, end))
+        props.push({ type: "newline", offset: -1, indent, source: "\n" });
+      return { type: "block-scalar", offset, indent, props, source: body };
+    }
+    case '"':
+      return { type: "double-quoted-scalar", offset, indent, source, end };
+    case "'":
+      return { type: "single-quoted-scalar", offset, indent, source, end };
+    default:
+      return { type: "scalar", offset, indent, source, end };
+  }
+}
+function setScalarValue(token, value, context = {}) {
+  let { afterKey = false, implicitKey = false, inFlow = false, type } = context;
+  let indent = "indent" in token ? token.indent : null;
+  if (afterKey && typeof indent === "number")
+    indent += 2;
+  if (!type)
+    switch (token.type) {
+      case "single-quoted-scalar":
+        type = "QUOTE_SINGLE";
+        break;
+      case "double-quoted-scalar":
+        type = "QUOTE_DOUBLE";
+        break;
+      case "block-scalar": {
+        const header = token.props[0];
+        if (header.type !== "block-scalar-header")
+          throw new Error("Invalid block scalar header");
+        type = header.source[0] === ">" ? "BLOCK_FOLDED" : "BLOCK_LITERAL";
+        break;
+      }
+      default:
+        type = "PLAIN";
+    }
+  const source = stringifyString({ type, value }, {
+    implicitKey: implicitKey || indent === null,
+    indent: indent !== null && indent > 0 ? " ".repeat(indent) : "",
+    inFlow,
+    options: { blockQuote: true, lineWidth: -1 }
+  });
+  switch (source[0]) {
+    case "|":
+    case ">":
+      setBlockScalarValue(token, source);
+      break;
+    case '"':
+      setFlowScalarValue(token, source, "double-quoted-scalar");
+      break;
+    case "'":
+      setFlowScalarValue(token, source, "single-quoted-scalar");
+      break;
+    default:
+      setFlowScalarValue(token, source, "scalar");
+  }
+}
+function setBlockScalarValue(token, source) {
+  const he = source.indexOf("\n");
+  const head = source.substring(0, he);
+  const body = source.substring(he + 1) + "\n";
+  if (token.type === "block-scalar") {
+    const header = token.props[0];
+    if (header.type !== "block-scalar-header")
+      throw new Error("Invalid block scalar header");
+    header.source = head;
+    token.source = body;
+  } else {
+    const { offset } = token;
+    const indent = "indent" in token ? token.indent : -1;
+    const props = [
+      { type: "block-scalar-header", offset, indent, source: head }
+    ];
+    if (!addEndtoBlockProps(props, "end" in token ? token.end : void 0))
+      props.push({ type: "newline", offset: -1, indent, source: "\n" });
+    for (const key of Object.keys(token))
+      if (key !== "type" && key !== "offset")
+        delete token[key];
+    Object.assign(token, { type: "block-scalar", indent, props, source: body });
+  }
+}
+function addEndtoBlockProps(props, end) {
+  if (end)
+    for (const st of end)
+      switch (st.type) {
+        case "space":
+        case "comment":
+          props.push(st);
+          break;
+        case "newline":
+          props.push(st);
+          return true;
+      }
+  return false;
+}
+function setFlowScalarValue(token, source, type) {
+  switch (token.type) {
+    case "scalar":
+    case "double-quoted-scalar":
+    case "single-quoted-scalar":
+      token.type = type;
+      token.source = source;
+      break;
+    case "block-scalar": {
+      const end = token.props.slice(1);
+      let oa = source.length;
+      if (token.props[0].type === "block-scalar-header")
+        oa -= token.props[0].source.length;
+      for (const tok of end)
+        tok.offset += oa;
+      delete token.props;
+      Object.assign(token, { type, source, end });
+      break;
+    }
+    case "block-map":
+    case "block-seq": {
+      const offset = token.offset + source.length;
+      const nl = { type: "newline", offset, indent: token.indent, source: "\n" };
+      delete token.items;
+      Object.assign(token, { type, source, end: [nl] });
+      break;
+    }
+    default: {
+      const indent = "indent" in token ? token.indent : -1;
+      const end = "end" in token && Array.isArray(token.end) ? token.end.filter((st) => st.type === "space" || st.type === "comment" || st.type === "newline") : [];
+      for (const key of Object.keys(token))
+        if (key !== "type" && key !== "offset")
+          delete token[key];
+      Object.assign(token, { type, indent, source, end });
+    }
+  }
+}
+
+// ../../node_modules/.bun/yaml@2.9.1/node_modules/yaml/browser/dist/parse/cst-stringify.js
+var stringify2 = (cst) => "type" in cst ? stringifyToken(cst) : stringifyItem(cst);
+function stringifyToken(token) {
+  switch (token.type) {
+    case "block-scalar": {
+      let res = "";
+      for (const tok of token.props)
+        res += stringifyToken(tok);
+      return res + token.source;
+    }
+    case "block-map":
+    case "block-seq": {
+      let res = "";
+      for (const item of token.items)
+        res += stringifyItem(item);
+      return res;
+    }
+    case "flow-collection": {
+      let res = token.start.source;
+      for (const item of token.items)
+        res += stringifyItem(item);
+      for (const st of token.end)
+        res += st.source;
+      return res;
+    }
+    case "document": {
+      let res = stringifyItem(token);
+      if (token.end)
+        for (const st of token.end)
+          res += st.source;
+      return res;
+    }
+    default: {
+      let res = token.source;
+      if ("end" in token && token.end)
+        for (const st of token.end)
+          res += st.source;
+      return res;
+    }
+  }
+}
+function stringifyItem({ start, key, sep, value }) {
+  let res = "";
+  for (const st of start)
+    res += st.source;
+  if (key)
+    res += stringifyToken(key);
+  if (sep)
+    for (const st of sep)
+      res += st.source;
+  if (value)
+    res += stringifyToken(value);
+  return res;
+}
 
 // ../../node_modules/.bun/yaml@2.9.1/node_modules/yaml/browser/dist/parse/cst-visit.js
 var BREAK2 = /* @__PURE__ */ Symbol("break visit");
@@ -4718,6 +4977,22 @@ var BOM = "\uFEFF";
 var DOCUMENT = "";
 var FLOW_END = "";
 var SCALAR2 = "";
+var isCollection2 = (token) => !!token && "items" in token;
+var isScalar2 = (token) => !!token && (token.type === "scalar" || token.type === "single-quoted-scalar" || token.type === "double-quoted-scalar" || token.type === "block-scalar");
+function prettyToken(token) {
+  switch (token) {
+    case BOM:
+      return "<BOM>";
+    case DOCUMENT:
+      return "<DOC>";
+    case FLOW_END:
+      return "<FLOW_END>";
+    case SCALAR2:
+      return "<SCALAR>";
+    default:
+      return JSON.stringify(token);
+  }
+}
 function tokenType(source) {
   switch (source) {
     case BOM:
@@ -5360,6 +5635,31 @@ var Lexer = class {
   }
 };
 
+// ../../node_modules/.bun/yaml@2.9.1/node_modules/yaml/browser/dist/parse/line-counter.js
+var LineCounter = class {
+  constructor() {
+    this.lineStarts = [];
+    this.addNewLine = (offset) => this.lineStarts.push(offset);
+    this.linePos = (offset) => {
+      let low = 0;
+      let high = this.lineStarts.length;
+      while (low < high) {
+        const mid = low + high >> 1;
+        if (this.lineStarts[mid] < offset)
+          low = mid + 1;
+        else
+          high = mid;
+      }
+      if (this.lineStarts[low] === offset)
+        return { line: low + 1, col: 1 };
+      if (low === 0)
+        return { line: 0, col: offset };
+      const start = this.lineStarts[low - 1];
+      return { line: low, col: offset - start + 1 };
+    };
+  }
+};
+
 // ../../node_modules/.bun/yaml@2.9.1/node_modules/yaml/browser/dist/parse/parser.js
 function includesToken(list, type) {
   for (let i = 0; i < list.length; ++i)
@@ -6229,6 +6529,20 @@ function parseOptions(options) {
   const lineCounter = options.lineCounter || prettyErrors && new LineCounter() || null;
   return { lineCounter, prettyErrors };
 }
+function parseAllDocuments(source, options = {}) {
+  const { lineCounter, prettyErrors } = parseOptions(options);
+  const parser = new Parser(lineCounter?.addNewLine);
+  const composer = new Composer(options);
+  const docs = Array.from(composer.compose(parser.parse(source)));
+  if (prettyErrors && lineCounter)
+    for (const doc of docs) {
+      doc.errors.forEach(prettifyError(source, lineCounter));
+      doc.warnings.forEach(prettifyError(source, lineCounter));
+    }
+  if (docs.length > 0)
+    return docs;
+  return Object.assign([], { empty: true }, composer.streamInfo());
+}
 function parseDocument(source, options = {}) {
   const { lineCounter, prettyErrors } = parseOptions(options);
   const parser = new Parser(lineCounter?.addNewLine);
@@ -6267,8 +6581,61 @@ function parse(src, reviver, options) {
   }
   return doc.toJS(Object.assign({ reviver: _reviver }, options));
 }
+function stringify3(value, replacer, options) {
+  let _replacer = null;
+  if (typeof replacer === "function" || Array.isArray(replacer)) {
+    _replacer = replacer;
+  } else if (options === void 0 && replacer) {
+    options = replacer;
+  }
+  if (typeof options === "string")
+    options = options.length;
+  if (typeof options === "number") {
+    const indent = Math.round(options);
+    options = indent < 1 ? void 0 : indent > 8 ? { indent: 8 } : { indent };
+  }
+  if (value === void 0) {
+    const { keepUndefined } = options ?? replacer ?? {};
+    if (!keepUndefined)
+      return void 0;
+  }
+  if (isDocument(value) && !_replacer)
+    return value.toString(options);
+  return new Document(value, _replacer, options).toString(options);
+}
+
+// ../../node_modules/.bun/yaml@2.9.1/node_modules/yaml/browser/index.js
+var browser_default = dist_exports;
 
 export {
+  isAlias,
+  isDocument,
+  isMap,
+  isPair,
+  isScalar,
+  isSeq,
+  isCollection,
+  isNode,
+  visit,
+  visitAsync,
+  Alias,
+  Scalar,
+  Pair,
+  YAMLMap,
+  YAMLSeq,
+  Schema,
+  Document,
+  YAMLError,
+  YAMLParseError,
+  YAMLWarning,
+  Composer,
+  cst_exports,
+  Lexer,
+  LineCounter,
+  Parser,
+  parseAllDocuments,
   parseDocument,
-  parse
+  parse,
+  stringify3 as stringify,
+  browser_default
 };

package/js/{chunk-2HHMABB6.js → chunk-WFSQXYUT.js}

@@ -2,7 +2,9 @@ import {
   ValidationError
 } from "./chunk-SATWJKN6.js";
 import {
+  Cause_exports,
   Effect_exports,
+  Exit_exports,
   SchemaGetter_exports,
   SchemaIssue_exports,
   SchemaParser_exports,
@@ -1330,24 +1332,58 @@ var compileJsonSchemaDecoder = (document) => Effect_exports.gen(function* () {
   );
   return Object.assign(decoder, { [ImportedJsonSchema]: document });
 });
-var lazyJsonSchemaDecoder = (document) => Effect_exports.gen(function* () {
+var lazyDecoder = (document) => {
   const read = once(document);
-  const compiled = yield* Effect_exports.cached(Effect_exports.suspend(() => compileJsonSchemaDecoder(read())));
+  let compiled;
+  const compile = Effect_exports.suspend(
+    () => compiled ?? compileJsonSchemaDecoder(read()).pipe(
+      // An interrupted compilation is not a result; the next decode compiles again.
+      Effect_exports.onExit(
+        (exit) => Effect_exports.sync(() => {
+          if (Exit_exports.isSuccess(exit) || !Cause_exports.hasInterrupts(exit.cause)) compiled = exit;
+        })
+      )
+    )
+  );
   const decoder = Schema_exports.declareConstructor()(
     [],
-    () => (input, _ast, options) => compiled.pipe(
-      Effect_exports.mapError(
-        () => new SchemaIssue_exports.InvalidValue({ message: "Unsupported JSON Schema" })
-      ),
+    () => (input, _ast, options) => compile.pipe(
+      Effect_exports.mapError(() => new SchemaIssue_exports.InvalidValue({ message: "Unsupported JSON Schema" })),
       Effect_exports.flatMap((schema) => SchemaParser_exports.decodeUnknownEffect(schema)(input, options))
     )
   );
   return withLazyJsonSchemaDocument(decoder, read);
+};
+var lazyJsonSchemaDecoder = (document) => Effect_exports.sync(() => lazyDecoder(document));
+var isJsonValue = Schema_exports.is(Schema_exports.Json);
+var jsonDocument = (input) => {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) return void 0;
+  const keys = Object.keys(input);
+  const values = keys.map((key) => Reflect.get(input, key));
+  if (!isJsonValue(values)) return void 0;
+  const document = {};
+  keys.forEach(
+    (key, index) => Object.defineProperty(document, key, {
+      value: values[index],
+      enumerable: true,
+      writable: true,
+      configurable: true
+    })
+  );
+  return document;
+};
+var jsonSchemaDecoder = (input) => Effect_exports.suspend(() => {
+  const document = jsonDocument(input);
+  return document === void 0 ? Effect_exports.fail(new ValidationError()) : lazyJsonSchemaDecoder(() => document);
 });
-var jsonSchemaDecoder = (input) => parse(Schema_exports.Record(Schema_exports.String, Schema_exports.Json), input).pipe(
-  Effect_exports.flatMap((document) => lazyJsonSchemaDecoder(() => document))
-);
-var jsonSchema = (input) => wrap(Effect_exports.runSync(jsonSchemaDecoder(input)), false);
+var jsonSchema = (input) => {
+  const document = jsonDocument(input);
+  if (document === void 0) throw new ValidationError();
+  return wrap(
+    lazyDecoder(() => document),
+    false
+  );
+};
 var storageFieldOf = (schema) => schema[StorageField];
 var id = (table) => wrap(Schema_exports.NonEmptyString, false, { kind: "id", references: table });
 var userId = () => wrap(Schema_exports.NonEmptyString, false, { kind: "userId" });

package/js/{chunk-6IIO4NPI.js → chunk-Z5NMEGJN.js}

@@ -1,6 +1,6 @@
 import {
   operationDeclaration
-} from "./chunk-PZ36XMXW.js";
+} from "./chunk-PYUYJRSK.js";
 
 // src/implementation/protocol-operations.ts
 var protocolOperations = (operations, kinds = {}) => {

package/js/client.js

@@ -28,7 +28,7 @@ import {
 } from "./chunk-QKHR7BMF.js";
 import {
   decoderOf
-} from "./chunk-2HHMABB6.js";
+} from "./chunk-WFSQXYUT.js";
 import {
   StorageName
 } from "./chunk-FZJOYIZO.js";

package/js/contracts.js

@@ -18,6 +18,7 @@ import {
   HostEvaluationFailed,
   HostInputInvalid,
   HostInspectError,
+  HostInvocation,
   HostOperationFailed,
   HostOperationNotFound,
   HostOutputInvalid,
@@ -73,16 +74,19 @@ import {
   defaultElicitationLimits,
   defaultMcpClientLimits,
   defaultWebhookTransportLimits,
+  frameworkProtocol,
   indexCommand,
   inspectCommand,
   maxInputProblems,
   minimumIntervalMilliseconds,
+  protocol1,
   selectTools,
   skillCatalog,
   skillsCommand,
   workflowDurationMillis
-} from "./chunk-IHQ4ML7K.js";
+} from "./chunk-MYYEW3RA.js";
 import "./chunk-BMOIAIVR.js";
+import "./chunk-LGIYBDWA.js";
 import {
   AppSkillMetadata,
   AppSkillName,
@@ -142,6 +146,7 @@ export {
   HostEvaluationFailed,
   HostInputInvalid,
   HostInspectError,
+  HostInvocation,
   HostOperationFailed,
   HostOperationNotFound,
   HostOutputInvalid,
@@ -206,10 +211,12 @@ export {
   defaultElicitationLimits,
   defaultMcpClientLimits,
   defaultWebhookTransportLimits,
+  frameworkProtocol,
   indexCommand,
   inspectCommand,
   maxInputProblems,
   minimumIntervalMilliseconds,
+  protocol1,
   selectTools,
   skillCatalog,
   skillFormatLimits,

package/js/effect.js

@@ -3,17 +3,18 @@ import {
   ApprovalDecision,
   createAppHandler,
   prepareElicitation
-} from "./chunk-KOXMLKTM.js";
-import "./chunk-ZTFQHGEB.js";
-import "./chunk-NCYXZN2G.js";
-import "./chunk-RBAC33PQ.js";
+} from "./chunk-J7O55ZV7.js";
+import "./chunk-D47C7KG5.js";
+import "./chunk-FDNTX5QJ.js";
+import "./chunk-JN55AYQH.js";
 import "./chunk-PLCMJREA.js";
-import "./chunk-PZ36XMXW.js";
+import "./chunk-PYUYJRSK.js";
 import "./chunk-ZJWDMTE3.js";
 import {
   ToolAnnotations
-} from "./chunk-IHQ4ML7K.js";
+} from "./chunk-MYYEW3RA.js";
 import "./chunk-BMOIAIVR.js";
+import "./chunk-LGIYBDWA.js";
 import "./chunk-YEJOQEII.js";
 import "./chunk-SWPD52J7.js";
 import "./chunk-W7D7WVSY.js";
@@ -25,7 +26,7 @@ import {
   decoderOf,
   jsonSchemaDecoder,
   wrap
-} from "./chunk-2HHMABB6.js";
+} from "./chunk-WFSQXYUT.js";
 import "./chunk-FZJOYIZO.js";
 import {
   HttpUrl,