@native-marketing/sdk 0.3.1 → 0.3.3

package/dist/http.js

@@ -1,11 +1,83 @@
 // packages/api-client/src/client.ts
 import createClient from "openapi-fetch";
+
+// packages/api-client/src/request-policy.ts
+var verbs = /* @__PURE__ */ new Set(["GET", "PUT", "POST", "DELETE", "OPTIONS", "HEAD", "PATCH", "TRACE"]);
+function unsafe() {
+  throw new TypeError("HTTP client request violates its configured secure API boundary.");
+}
+function scopeOf(value) {
+  if (typeof value !== "string" || value.trim() !== value || /[\\?#]/.test(value)) unsafe();
+  const relative = value.startsWith("/") && !value.startsWith("//");
+  let url;
+  try {
+    url = relative ? new URL(value, "https://relative.invalid") : new URL(value);
+  } catch {
+    return unsafe();
+  }
+  if (url.username || url.password || url.search || url.hash) unsafe();
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname)))
+    unsafe();
+  return {
+    ...relative ? {} : { origin: url.origin },
+    pathname: url.pathname.replace(/\/+$/, "")
+  };
+}
+function httpRequestPolicy(baseUrl, transport) {
+  const scope = scopeOf(baseUrl);
+  const origin = scope.origin ?? globalThis.location?.origin;
+  return {
+    validateInit(value) {
+      if (value === void 0) return;
+      if (value === null || typeof value !== "object") unsafe();
+      const init = value;
+      if (init.redirect !== void 0 && init.redirect !== "error") unsafe();
+      if (init.fetch !== void 0 || init.Request !== void 0 || init.middleware !== void 0)
+        unsafe();
+      if (init.baseUrl !== void 0) {
+        if (typeof init.baseUrl !== "string") unsafe();
+        const alternate = scopeOf(init.baseUrl);
+        if ((alternate.origin ?? origin) !== origin || alternate.pathname !== scope.pathname)
+          unsafe();
+      }
+    },
+    async fetch(request) {
+      const url = new URL(request.url);
+      if (!origin || url.origin !== origin || url.username || url.password || !(url.pathname === scope.pathname || url.pathname.startsWith(`${scope.pathname}/`)) || request.redirect !== "error")
+        unsafe();
+      return transport(request);
+    }
+  };
+}
+function guardHttpMethods(client, validate) {
+  const methods = /* @__PURE__ */ new Map();
+  return new Proxy(client, {
+    get(target, property, receiver) {
+      const value = Reflect.get(target, property, receiver);
+      if (typeof property !== "string" || typeof value !== "function" || !(verbs.has(property) || property === "request"))
+        return value;
+      if (!methods.has(property))
+        methods.set(property, async (...args) => {
+          validate(args[property === "request" ? 2 : 1]);
+          return Reflect.apply(value, target, args);
+        });
+      return methods.get(property);
+    }
+  });
+}
+
+// packages/api-client/src/client.ts
 function createContentFactoryClient(options = {}) {
+  const baseUrl = options.baseUrl ?? "/api/v1";
+  const policy = httpRequestPolicy(
+    baseUrl,
+    options.fetch ?? ((request) => globalThis.fetch(request))
+  );
   const client = createClient({
-    baseUrl: options.baseUrl ?? "/api/v1",
+    baseUrl,
     credentials: "include",
     redirect: "error",
-    ...options.fetch ? { fetch: options.fetch } : {}
+    fetch: policy.fetch
   });
   client.use({
     onRequest({ request }) {
@@ -16,7 +88,7 @@ function createContentFactoryClient(options = {}) {
       return new Request(request, { headers, body: "{}" });
     }
   });
-  return client;
+  return guardHttpMethods(client, policy.validateInit);
 }
 
 // packages/contracts/src/business-code.ts

package/dist/index.js

@@ -5238,6 +5238,7 @@ var capabilityRejectedErrorCodes = [
   "DISTRIBUTION_TARGET_INVALID",
   "FORBIDDEN",
   "CAPABILITY_INPUT_INVALID",
+  "CAPABILITY_INPUT_LIMIT_EXCEEDED",
   "CAPABILITY_SCHEMA_CHANGED",
   "CAPABILITY_CALL_RESERVED",
   "FOUNDATION_EDIT_CONFLICT",
@@ -5489,6 +5490,18 @@ var businessDocumentInputSchema = z72.object({
 // packages/contracts/src/agent/compact-surface.ts
 import { z as z73 } from "zod";
 var nativeAgentSurfaceCapability = "io.native-marketing/agent-native";
+var capabilityInputLimits = Object.freeze({ maxElements: 2e4, maxDepth: 64 });
+var capabilityProtocolToolNames = [
+  "cf_discover_capabilities",
+  "cf_describe_capability",
+  "cf_read_capability_schema",
+  "cf_search_business",
+  "cf_read_business_document",
+  "cf_get_business_summary",
+  "cf_call_capability",
+  "cf_read_capability",
+  "cf_write_capability"
+];
 var hash = z73.string().regex(/^[a-f0-9]{64}$/u);
 var capabilitySchemaReadSchema = capabilityDescribeSchema.extend({
   expectedSchemaSha256: hash,
@@ -6834,6 +6847,7 @@ function isKnownCapabilityRejection(code2, name) {
 var recoveries = {
   CAPABILITY_SCHEMA_CHANGED: "READ_EXACT_SCHEMA",
   CAPABILITY_INPUT_INVALID: "READ_EXACT_SCHEMA",
+  CAPABILITY_INPUT_LIMIT_EXCEEDED: "REDUCE_INPUT_SIZE_OR_DEPTH",
   OPPORTUNITY_STRATEGY_REFRESH_REQUIRED: "READ_CURRENT_STRATEGY",
   CAPABILITY_EFFECT_MISMATCH: "USE_ENTRY_MATCHING_EFFECT",
   CAPABILITY_OUTPUT_INVALID: "QUERY_ORIGINAL_OUTCOME_BEFORE_RETRY",
@@ -7406,6 +7420,7 @@ var CapabilityDefinitionCache = class {
   remember(value) {
     const verified = verifyCapabilityDefinition(value, value.definition.name);
     const key2 = `${verified.definition.name}:AGENT_V3:${verified.schemaSha256}`;
+    this.values.delete(key2);
     if (this.values.size >= 64) this.values.delete(this.values.keys().next().value);
     this.values.set(key2, structuredClone(verified));
   }
@@ -7413,6 +7428,15 @@ var CapabilityDefinitionCache = class {
     const value = this.values.get(`${name}:AGENT_V3:${hash5}`);
     return value ? structuredClone(value) : void 0;
   }
+  latest(name) {
+    for (const value of [...this.values.values()].reverse())
+      if (value.definition.name === name) return structuredClone(value);
+    return void 0;
+  }
+  forget(name) {
+    for (const [key2, value] of this.values)
+      if (value.definition.name === name) this.values.delete(key2);
+  }
 };
 
 // packages/cli-client/src/capability-errors.ts
@@ -7436,6 +7460,7 @@ function capabilityError(tool5, data, readOnly = true, input) {
     outcome,
     {
       recovery,
+      ...code2 === "CAPABILITY_INPUT_LIMIT_EXCEEDED" && outcome === "REJECTED" ? { inputLimits: capabilityInputLimits } : {},
       ...receipt ? { receipt } : {},
       ...status ? { status } : {},
       ...validation?.success && validationMatches ? { validation: validation.data } : {}
@@ -7454,6 +7479,7 @@ function boundedFetch(origin2, timeout) {
       throw new CliError("UNTRUSTED_ENDPOINT", "Cross-origin credential requests are forbidden.");
     const signal = AbortSignal.any([
       AbortSignal.timeout(timeout),
+      ...input instanceof Request ? [input.signal] : [],
       ...init?.signal ? [init.signal] : []
     ]);
     const response = await fetch(input, { ...init, signal, redirect: "error" });
@@ -7652,12 +7678,12 @@ var ProfileStore = class {
     const temporary = `${this.path}.${randomUUID()}.tmp`;
     const file = await open2(temporary, "wx", 384);
     try {
-      await file.writeFile(JSON.stringify(profile) + "\n");
-      await file.sync();
-    } finally {
-      await file.close();
-    }
-    try {
+      try {
+        await file.writeFile(JSON.stringify(profile) + "\n");
+        await file.sync();
+      } finally {
+        await file.close();
+      }
       await rename(temporary, this.path);
     } finally {
       await unlink(temporary).catch(() => void 0);
@@ -7762,6 +7788,8 @@ async function withClient(profile, timeout, operation) {
   }
 }
 async function callTool(client, tool5, input, timeout, readOnly, errorToolName = tool5.name) {
+  if (["cf_call_capability", "cf_read_capability", "cf_write_capability"].includes(tool5.name) && errorToolName === tool5.name && typeof input.name === "string" && /^cf_[a-z0-9_]{1,100}$/.test(input.name))
+    errorToolName = input.name;
   const original = ["cf_call_capability", "cf_read_capability", "cf_write_capability"].includes(tool5.name) && input.name === errorToolName ? input.arguments : input;
   const unknown = (code2, message) => {
     const receipt = capabilityReceiptRead(errorToolName, original);
@@ -8015,7 +8043,7 @@ function checkTimeout(timeout) {
 }
 
 // packages/cli-client/src/tool-definition.ts
-async function nativeToolDefinition(client, name, timeout) {
+async function nativeToolDefinition(client, name, timeout, definitions, reuse = true) {
   const feature = client.getServerCapabilities()?.experimental?.[nativeAgentSurfaceCapability];
   if (feature !== void 0) {
     if (!feature || typeof feature !== "object" || !("version" in feature) || feature.version !== 1)
@@ -8023,7 +8051,9 @@ async function nativeToolDefinition(client, name, timeout) {
         "UNSUPPORTED_AGENT_SURFACE",
         "Unsupported discovery version; no business call was sent."
       );
-    const exact = await describeNativeCapability(client, name, timeout);
+    const cached = reuse ? definitions?.latest(name) : void 0;
+    const exact = cached ?? await describeNativeCapability(client, name, timeout);
+    if (!cached) definitions?.remember(exact);
     return { tool: exact.definition, schemaSha256: exact.schemaSha256 };
   }
   let cursor;
@@ -8215,9 +8245,9 @@ function knowledgePathMatchesResource(readingPath, resourcePath) {
 }
 
 // packages/cli-client/src/operations.ts
-async function inspectNativeTool(client, name, timeout = 3e4) {
+async function inspectNativeTool(client, name, timeout = 3e4, definitions) {
   check(name, {}, timeout);
-  return (await nativeToolDefinition(client, name, timeout)).tool;
+  return (await nativeToolDefinition(client, name, timeout, definitions)).tool;
 }
 async function listNativeToolsPage(client, input = {}, timeout = 3e4) {
   check("cf_list", input, timeout);
@@ -8231,13 +8261,25 @@ async function listNativeToolsPage(client, input = {}, timeout = 3e4) {
     throw new CliError("INVALID_TOOL_DIRECTORY", "Expected one typed tool catalogue page.");
   return page2;
 }
-async function callNativeTool(client, name, input, resource, options = {}, timeout = 3e4) {
+async function callNativeTool(client, name, input, resource, options = {}, timeout = 3e4, definitions) {
   check(name, input, timeout);
   if (Object.keys(options).some((key2) => !["view", "expectedSchemaSha256"].includes(key2)) || options.view !== void 0 && !["SUMMARY", "INDEX", "PAGE", "ORIGINAL"].includes(options.view))
     throw new CliError("INVALID_VIEW", "Use SUMMARY, INDEX, PAGE or ORIGINAL.");
   if (options.expectedSchemaSha256 !== void 0 && !/^[a-f0-9]{64}$/.test(options.expectedSchemaSha256))
     throw new CliError("INVALID_SCHEMA_HASH", "Supply the observed schema SHA-256.");
-  const { tool: tool5, schemaSha256 } = await nativeToolDefinition(client, name, timeout);
+  const summary2 = agentSummarySourceSchema.safeParse(name), document2 = businessDocumentToolSchema.safeParse(name);
+  const protocol = capabilityProtocolToolNames.some((entry) => entry === name);
+  const cached = definitions?.latest(name), flags2 = cached?.definition.annotations;
+  const reuse = Boolean(
+    cached && !protocol && (options.view === "ORIGINAL" || options.view === void 0 && !summary2.success && !document2.success) && (flags2?.readOnlyHint !== true || flags2.destructiveHint !== true && flags2.openWorldHint === false)
+  );
+  const { tool: tool5, schemaSha256 } = await nativeToolDefinition(
+    client,
+    name,
+    timeout,
+    definitions,
+    reuse
+  );
   if (options.expectedSchemaSha256 !== void 0 && schemaSha256 !== options.expectedSchemaSha256)
     throw new CliError(
       "CAPABILITY_SCHEMA_CHANGED",
@@ -8245,7 +8287,6 @@ async function callNativeTool(client, name, input, resource, options = {}, timeo
       "NOT_SENT",
       { recovery: "READ_EXACT_SCHEMA" }
     );
-  const summary2 = agentSummarySourceSchema.safeParse(name), document2 = businessDocumentToolSchema.safeParse(name);
   const read2 = tool5.annotations?.readOnlyHint === true;
   const view = options.view ?? (schemaSha256 && read2 ? summary2.success ? "SUMMARY" : document2.success ? "INDEX" : "ORIGINAL" : "ORIGINAL");
   if (view !== "ORIGINAL" && (!schemaSha256 || !read2 || (view === "SUMMARY" ? !summary2.success : !document2.success)))
@@ -8254,29 +8295,41 @@ async function callNativeTool(client, name, input, resource, options = {}, timeo
       "This view is unavailable for this exact tool/resource; no business call was sent."
     );
   let result2;
-  if (view === "SUMMARY" && summary2.success)
-    result2 = await getNativeBusinessSummary(
-      client,
-      { sourceTool: summary2.data, sourceInput: input },
-      timeout
-    );
-  else if ((view === "INDEX" || view === "PAGE") && document2.success)
-    result2 = await readNativeDocumentPage(
-      client,
-      {
-        sourceTool: document2.data,
-        sourceInput: input,
-        format: view === "INDEX" ? "INDEX" : "JSON_TEXT"
-      },
-      timeout
-    );
-  else if (schemaSha256 && !read2 && name !== "cf_call_capability")
-    result2 = await callNativeCapability(
-      client,
-      { name, expectedSchemaSha256: schemaSha256, arguments: input, delivery: "ORIGINAL" },
-      timeout
-    );
-  else result2 = await callTool(client, tool5, input, timeout, read2);
+  try {
+    if (view === "SUMMARY" && summary2.success)
+      result2 = await getNativeBusinessSummary(
+        client,
+        { sourceTool: summary2.data, sourceInput: input },
+        timeout
+      );
+    else if ((view === "INDEX" || view === "PAGE") && document2.success)
+      result2 = await readNativeDocumentPage(
+        client,
+        {
+          sourceTool: document2.data,
+          sourceInput: input,
+          format: view === "INDEX" ? "INDEX" : "JSON_TEXT"
+        },
+        timeout
+      );
+    else if (schemaSha256 && read2 && !protocol && tool5.annotations?.destructiveHint !== true && tool5.annotations?.openWorldHint === false)
+      result2 = await readNativeCapability(
+        client,
+        { name, expectedSchemaSha256: schemaSha256, arguments: input, delivery: "ORIGINAL" },
+        timeout
+      );
+    else if (schemaSha256 && !read2 && !protocol)
+      result2 = await callNativeCapability(
+        client,
+        { name, expectedSchemaSha256: schemaSha256, arguments: input, delivery: "ORIGINAL" },
+        timeout
+      );
+    else result2 = await callTool(client, tool5, input, timeout, read2);
+  } catch (error) {
+    if (error instanceof CliError && error.code === "CAPABILITY_SCHEMA_CHANGED")
+      definitions?.forget(name);
+    throw error;
+  }
   return { tool: name, view, result: result2, links: reviewLinks(resource, name, result2, input) };
 }
 function check(name, input, timeout) {
@@ -8601,8 +8654,8 @@ async function withNativeAgentClient(connection, action, options = {}) {
       readProjectMediaFile: (input) => readNativeProjectMediaFile(connection, input, timeout),
       uploadProjectMedia: (file) => uploadNativeProjectMedia(connection, file, timeout),
       uploadMaterial: (file) => uploadNativeMaterial(connection, file, timeout),
-      inspectTool: (name) => inspectNativeTool(client, name, timeout),
-      callTool: (name, input = {}, options2) => callNativeTool(client, name, input, connection.resource, options2, timeout),
+      inspectTool: (name) => inspectNativeTool(client, name, timeout, definitions),
+      callTool: (name, input = {}, options2) => callNativeTool(client, name, input, connection.resource, options2, timeout, definitions),
       listToolsPage: (input = {}) => listNativeToolsPage(client, input, timeout),
       readCapabilitySchemaPage: (input) => readNativeCapabilitySchemaPage(client, input, timeout),
       readDocumentPage: (input) => readNativeDocumentPage(client, input, timeout),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@native-marketing/sdk",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "type": "module",
   "license": "Apache-2.0",
   "engines": {

package/release.json

@@ -1,7 +1,7 @@
 {
-  "sourceCommit": "afa0dc260d267c9f7fa1da3ff3e629325bf5a6a1",
+  "sourceCommit": "a8ae57db987c771cf1884afa5f318828da0f45ab",
   "workingTreeDirty": false,
-  "version": "0.3.1",
+  "version": "0.3.3",
   "openapiTypesSha256": "1a86e24ce9e458e945e4df5e9c7423c9bf4253ac24b3f627f67ba38c92856a38",
   "localBuild": true
 }

package/types/contracts/agent/compact-surface.d.ts

@@ -1,5 +1,10 @@
 import { z } from 'zod';
 export declare const nativeAgentSurfaceCapability = "io.native-marketing/agent-native";
+export declare const capabilityInputLimits: Readonly<{
+    maxElements: 20000;
+    maxDepth: 64;
+}>;
+export declare const capabilityProtocolToolNames: readonly ['cf_discover_capabilities', 'cf_describe_capability', 'cf_read_capability_schema', 'cf_search_business', 'cf_read_business_document', 'cf_get_business_summary', 'cf_call_capability', 'cf_read_capability', 'cf_write_capability'];
 export declare const capabilitySchemaReadSchema: z.ZodObject<{
     name: z.ZodString;
     expectedSchemaSha256: z.ZodString;

package/types/http/request-policy.d.ts

@@ -0,0 +1,5 @@
+export declare function httpRequestPolicy(baseUrl: string, transport: (input: Request) => Promise<Response>): {
+    validateInit(value: unknown): void;
+    fetch(request: Request): Promise<Response>;
+};
+export declare function guardHttpMethods<T extends object>(client: T, validate: (init: unknown) => void): T;

package/types/sdk/capability-definition.d.ts

@@ -21,4 +21,22 @@ export declare class CapabilityDefinitionCache {
             callsReauthorize: true;
         };
     } | undefined;
+    latest(name: string): {
+        schemaVersion: 1;
+        schemaSha256: string;
+        definition: {
+            name: string;
+            title?: string | undefined;
+            description?: string | undefined;
+            inputSchema: Record<string, unknown>;
+            outputSchema?: Record<string, unknown> | undefined;
+            annotations?: Record<string, unknown> | undefined;
+            _meta?: Record<string, unknown> | undefined;
+        };
+        authority: {
+            discoveryIsAuthority: false;
+            callsReauthorize: true;
+        };
+    } | undefined;
+    forget(name: string): void;
 }

package/types/sdk/operations.d.ts

@@ -1,4 +1,5 @@
 import type { Client } from '@modelcontextprotocol/client';
+import type { CapabilityDefinitionCache } from './capability-definition.js';
 export type NativeReadView = 'SUMMARY' | 'INDEX' | 'PAGE' | 'ORIGINAL';
 export type NativeToolOptions = {
     view?: NativeReadView | undefined;
@@ -10,7 +11,7 @@ export type NativeToolResult<T = unknown> = {
     result: T;
     links: Record<string, string>;
 };
-export declare function inspectNativeTool(client: Client, name: string, timeout?: number): Promise<{
+export declare function inspectNativeTool(client: Client, name: string, timeout?: number, definitions?: CapabilityDefinitionCache): Promise<{
     description?: string | undefined;
     inputSchema: {
         [x: string]: unknown;
@@ -207,4 +208,4 @@ export declare function listNativeToolsPage(client: Client, input?: Record<strin
         title?: string | undefined;
     }[];
 }>;
-export declare function callNativeTool(client: Client, name: string, input: Record<string, unknown>, resource: string, options?: NativeToolOptions, timeout?: number): Promise<NativeToolResult>;
+export declare function callNativeTool(client: Client, name: string, input: Record<string, unknown>, resource: string, options?: NativeToolOptions, timeout?: number, definitions?: CapabilityDefinitionCache): Promise<NativeToolResult>;

package/types/sdk/tool-definition.d.ts

@@ -1,5 +1,6 @@
 import type { Client, Tool } from '@modelcontextprotocol/client';
-export declare function nativeToolDefinition(client: Client, name: string, timeout: number): Promise<{
+import type { CapabilityDefinitionCache } from './capability-definition.js';
+export declare function nativeToolDefinition(client: Client, name: string, timeout: number, definitions?: CapabilityDefinitionCache, reuse?: boolean): Promise<{
     tool: Tool;
     schemaSha256: string;
 } | {