apps 0.0.1-beta.30 → 0.0.1-beta.32

package/types/apps/src/contracts/openapi-compile.d.ts

@@ -1,5 +1,6 @@
 /** Shared OpenAPI compilation diagnostics. */
 import { Schema } from "effect";
+/** Which part of an OpenAPI document could not be compiled into tools. */
 export declare const OpenapiCompileErrorCode: Schema.Literals<readonly ["server_protocol", "server_url", "external_reference", "circular_reference", "schema_keyword", "schema_reference", "missing_component", "openapi_version", "auth_helper", "auth_missing", "operation_path", "operation_method", "duplicate_operation", "server_missing", "multiple_hosts", "parameter_encoding", "parameter_style", "request_body", "combined_oauth", "auth_method", "event_stream", "input_schema", "no_operations", "no_supported_operations", "invalid_document", "source_generation", "authoring_reference"]>;
 /** A declared operation the importer left out, and why. */
 export declare const OpenapiSkippedOperation: Schema.Struct<{

package/types/apps/src/implementation/input-problems.d.ts

@@ -1,3 +1,6 @@
 import { HostInputInvalid } from "../contracts/host.js";
-/** Failing input paths and expected shapes from a schema decode failure, without supplied values. */
+/**
+ * Failing input paths and what each expects, from a schema decode failure, without supplied
+ * values. An expected object names its keys, so a caller can correct nesting from the problem.
+ */
 export declare const inputInvalid: (error: unknown) => HostInputInvalid;

package/types/apps/src/implementation/openapi-document.d.ts

@@ -34,27 +34,27 @@ export declare function openApiDocument(input: JsonObject): Promise<{
                 readonly [x: string]: Schema.Json;
             };
         };
-        readonly security?: readonly {
-            readonly [x: string]: readonly string[];
-        }[];
-        readonly servers?: readonly {
-            readonly url: string;
-            readonly variables?: {
-                readonly [x: string]: Schema.Json;
-            };
-        }[];
         readonly components?: {
-            readonly securitySchemes?: {
+            readonly schemas?: {
                 readonly [x: string]: {
                     readonly [x: string]: Schema.Json;
                 };
             };
-            readonly schemas?: {
+            readonly securitySchemes?: {
                 readonly [x: string]: {
                     readonly [x: string]: Schema.Json;
                 };
             };
         };
+        readonly security?: readonly {
+            readonly [x: string]: readonly string[];
+        }[];
+        readonly servers?: readonly {
+            readonly url: string;
+            readonly variables?: {
+                readonly [x: string]: Schema.Json;
+            };
+        }[];
     };
     definitions: Map<string, {
         readonly [x: string]: Schema.Json;

package/types/apps/src/implementation/schema.d.ts

@@ -111,8 +111,36 @@ export declare const withLazyJsonSchemaDocument: <S extends EffectSchema.Decoder
  * Relocate a self-contained JSON Schema under a document pointer. Resolve references
  * before nesting so account schemas can reuse definition names, IDs and anchors.
  * Only schema nodes are rewritten; examples and ordinary property values stay intact.
+ * A `$recursiveRef` becomes the pointer to its static target, such as the relocated root. The
+ * patched validator applies it like `"#"` was: the recursive anchor in scope, else that target.
  */
 export declare const nestJsonSchema: (input: JsonObject, pointer: string) => JsonObject;
+/**
+ * Whether an input key may be named in a validation problem. Other keys can carry supplied data,
+ * so problems locate them without echoing them.
+ */
+export declare const echoableKey: (key: string) => boolean;
+/**
+ * The keys an object accepts, as `object {name, optional?}`. `...` marks an object that also
+ * accepts other keys. Names come from the schema, never from supplied input.
+ */
+export declare const objectShape: (keys: readonly {
+    readonly name: string;
+    readonly optional: boolean;
+}[], open: boolean, limit?: number) => string;
+/**
+ * The values a schema fixes, as `"v1"` or `one of "a", "b" and 3 more`. Agents already read
+ * these values in the tool's signature, so problems list them, up to {@link maxListedValues}
+ * values and {@link maxValuesText} characters. They come from the schema, never from input.
+ */
+export declare const allowedValues: (values: readonly unknown[]) => string;
+/** Keys listed for each union alternative, so several alternatives fit in one problem. */
+export declare const maxAlternativeKeys = 8;
+/**
+ * The alternatives a union accepts, as `string or object {id}`, and the key whose value tells
+ * them apart. Shapes, values and the key come from the schema, never from supplied input.
+ */
+export declare const unionShape: (alternatives: readonly string[], selector: string | undefined) => string;
 /** Prepare an interpreted validator. No eval or generated JavaScript runs in any host. */
 export declare const compileJsonSchemaDecoder: (document: JsonObject) => Effect.Effect<EffectSchema.Codec<EffectSchema.Json, EffectSchema.Json, never, never> & {
     [ImportedJsonSchema]: {