@forgeintel/sdk 0.5.0-beta.12 → 0.5.0-beta.13

package/dist/core.js

@@ -104,7 +104,10 @@ export function checkOptions(input) {
     }
     return { errors, warnings, options };
 }
-/** Everything passes through untouched. Used when invalid options turned Forge off. */
+/**
+ * Used when invalid options turned Forge off: nothing is recorded or added, but agent context is still removed from
+ * requests, so agents that learned about it (an earlier deploy, a cached listing) can't trip strict validators.
+ */
 function disabledCore(errors, warnings) {
     const passThrough = {
         feedbackId: undefined,
@@ -113,8 +116,8 @@ function disabledCore(errors, warnings) {
         json: (_status, body) => body,
         text: (_status, _type, body) => body,
         headers: () => ({}),
-        requestBody: (body) => body,
-        requestUrl: (url) => url,
+        requestBody: (body) => takeFromBody(body).body,
+        requestUrl: (url) => takeFromUrl(url).url,
         finish: () => { },
     };
     return {

package/dist/express.js

@@ -202,8 +202,18 @@ export function createForge(options) {
         diagnostics: core.diagnostics,
         shutdown: core.shutdown,
         middleware() {
-            if (!core.enabled)
-                return (_req, _res, next) => next();
+            if (!core.enabled) {
+                // Disabled by invalid options: only remove agent context, so strict validators never see it.
+                return (req, _res, next) => {
+                    try {
+                        takeAgentContext(req, core.call({ method: req.method, path: req.path, header: () => undefined }));
+                    }
+                    catch {
+                        // never break the business request
+                    }
+                    next();
+                };
+            }
             return (req, res, next) => {
                 core
                     .route({

package/dist/fetch.js

@@ -113,8 +113,6 @@ export function createForge(options) {
         }
     }
     async function handle(request, next) {
-        if (!core.enabled)
-            return next(request);
         // Before the handler: our own routes, the spec, and agent context. Required-context errors stop paid attempts.
         let call;
         let forwarded = request;
@@ -168,6 +166,9 @@ export function createForge(options) {
             }
             return next(request);
         }
+        // Disabled by invalid options: agent context is removed (above), nothing else.
+        if (!core.enabled)
+            return next(forwarded);
         const response = await next(forwarded);
         // After the handler: decorate the 402 or the paid response. Any failure before the body is read: the original
         // response goes out. Once read, the body is always sent from what was read (decorated or not).

package/dist/hono.js

@@ -10,8 +10,6 @@ export function createForge(options) {
         shutdown: forge.shutdown,
         validate: forge.validate,
         middleware() {
-            if (!forge.enabled)
-                return async (_c, next) => next();
             return async (c, next) => {
                 let ranNext = false;
                 const response = await forge.handle(c.req.raw, async (request) => {

package/dist/openapi.js

@@ -61,6 +61,8 @@ function feedbackProperties(rateUrl, hintField = false) {
 }
 /** Returns an extended copy of an object schema, or a reason it can't be extended safely. */
 function extendSchema(doc, schema, props) {
+    if (schema === true)
+        schema = {}; // `true` accepts any value, like {}
     if (!isObj(schema))
         return { reason: "no_schema" };
     let target = schema;
@@ -83,7 +85,10 @@ function extendSchema(doc, schema, props) {
     if (COMPOSITION.some((k) => k in copy))
         return { reason: "composition" };
     const types = Array.isArray(copy.type) ? copy.type : [copy.type];
-    const objectish = types.includes("object") || (copy.type === undefined && (isObj(copy.properties) || Array.isArray(copy.allOf)));
+    // {} (annotations only) accepts any value, e.g. FastAPI's default response schema. `properties` only constrains
+    // objects, so documenting the field there narrows nothing.
+    const anyValue = Object.keys(copy).every((k) => ANNOTATIONS.has(k));
+    const objectish = anyValue || types.includes("object") || (copy.type === undefined && (isObj(copy.properties) || Array.isArray(copy.allOf)));
     if (!objectish)
         return { reason: "not_object" };
     if ("propertyNames" in copy || "maxProperties" in copy)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgeintel/sdk",
-  "version": "0.5.0-beta.12",
+  "version": "0.5.0-beta.13",
   "description": "The Forge SDK for x402 paid APIs: agent feedback, agent context, OpenAPI and challenge enrichment, and passive call signals. Express, Hono, Next.js and fetch handlers. No Forge network request on the merchant response path.",
   "license": "MIT",
   "type": "module",