@nanobpm/urban 0.87.1 → 0.88.1

package/dist/runtime/core/modules/mcp.d.ts

@@ -1,3 +1,4 @@
+import { type OpenApiDoc, type OpenApiSchema, type OperationInfo } from "../../../openapi/spec.ts";
 import type { AppApi, RuntimeContext } from "../context.ts";
 import type { HttpRequest } from "../host.ts";
 import { type Route } from "../router.ts";
@@ -64,6 +65,33 @@ export declare function readHeader(headers: Record<string, string | string[] | u
  *  required is enough to have missing (or whitespace-only) calls rejected rather than silently
  *  substituted with an empty string. */
 export declare function missingRequiredArgs(inputSchema: Record<string, unknown>, args: Record<string, unknown>): string[];
+/** The operation's effective request-body schema for classifying a tool-call `body`: P0's resolved,
+ *  `$ref`-free schema ({@link OperationInfo.requestBodySchemaResolved}, produced by
+ *  `collectOperations`). As defence in depth, if that metadata is somehow still a bare `$ref` (it
+ *  should never be after resolution), re-resolve it via {@link resolveSchema} against `doc` so the
+ *  classification below never keys off an opaque `#/components/...` pointer. */
+export declare function effectiveRequestBodySchema(op: OperationInfo, doc: OpenApiDoc | undefined): OpenApiSchema | undefined;
+/** Whether the operation declares a STRUCTURED (object/array) request body — the shapes the app door
+ *  expects as a JSON object/array rather than a bare scalar. Classified from the RESOLVED schema so a
+ *  `$ref`-bodied op (e.g. `previewDeliveryGraph`, whose object `type` is only visible after P0's
+ *  resolution) is recognized, not merely an inline-`type` object body. */
+export declare function structuredBodyKind(schema: OpenApiSchema | undefined): "object" | "array" | undefined;
+/** Normalize a tool-call `body` argument for FAITHFUL transport (ADR 0067). A client that saw an
+ *  opaque input schema — or that coerces non-primitive args — may send `body` as a pre-encoded JSON
+ *  *string* instead of the object/array the operation declares. Left as-is, `toHttpRequest`'s
+ *  `JSON.stringify` would DOUBLE-encode it into a quoted string and the door would reject it with
+ *  "expected object, got string". So when the op declares an object/array body and `body` arrives as
+ *  a string, parse it once so it round-trips as the structured value. A genuine object/array argument
+ *  passes through untouched (still serialized by the transport). A string that does not parse to the
+ *  declared shape is a CLEAR tool error naming the expected shape — never a silently double-encoded
+ *  (and 4xx-rejected) request. */
+export declare function normalizeBodyArg(op: OperationInfo, args: Record<string, unknown>, doc: OpenApiDoc | undefined): {
+    ok: true;
+    args: Record<string, unknown>;
+} | {
+    ok: false;
+    error: string;
+};
 /**
  * Mount the runtime-served MCP surface at `/app/mcp` (ADR 0067). Returns a single `*`-method route
  * (mounted unconditionally, like `/app/agent`); the handler bridges the host request/response seam

package/dist/runtime/core/modules/mcp.js

@@ -286,7 +286,7 @@ function toHttpRequest(op, args, forwardHeaders) {
  *  `collectOperations`). As defence in depth, if that metadata is somehow still a bare `$ref` (it
  *  should never be after resolution), re-resolve it via {@link resolveSchema} against `doc` so the
  *  classification below never keys off an opaque `#/components/...` pointer. */
-function effectiveRequestBodySchema(op, doc) {
+export function effectiveRequestBodySchema(op, doc) {
     const schema = op.requestBodySchemaResolved ?? op.requestBodySchema;
     if (schema?.$ref)
         return doc ? resolveSchema(doc, schema) : undefined;
@@ -296,7 +296,7 @@ function effectiveRequestBodySchema(op, doc) {
  *  expects as a JSON object/array rather than a bare scalar. Classified from the RESOLVED schema so a
  *  `$ref`-bodied op (e.g. `previewDeliveryGraph`, whose object `type` is only visible after P0's
  *  resolution) is recognized, not merely an inline-`type` object body. */
-function structuredBodyKind(schema) {
+export function structuredBodyKind(schema) {
     if (!schema)
         return undefined;
     if (isObjectSchema(schema))
@@ -314,7 +314,7 @@ function structuredBodyKind(schema) {
  *  passes through untouched (still serialized by the transport). A string that does not parse to the
  *  declared shape is a CLEAR tool error naming the expected shape — never a silently double-encoded
  *  (and 4xx-rejected) request. */
-function normalizeBodyArg(op, args, doc) {
+export function normalizeBodyArg(op, args, doc) {
     const body = args.body;
     const kind = structuredBodyKind(effectiveRequestBodySchema(op, doc));
     if (body === undefined || kind === undefined || typeof body !== "string") {