@inneranimalmedia/agentsam-sdk 2.5.0 → 2.6.0

package/packages/connectors/cloudflare/src/routes.js

@@ -0,0 +1,223 @@
+import {
+  CLOUDFLARE_CALLBACK_PATH,
+  CLOUDFLARE_OAUTH_TOKEN_URL,
+  CLOUDFLARE_OAUTH_REVOKE_URL,
+  buildAuthorizeUrl,
+  cloudflareConnectionSafeStatus,
+  resolveCloudflareOAuthClient,
+  requestedCloudflareScopes,
+  assertConnectionOwner,
+} from './index.js';
+import { resolveAuthenticatedOwner } from './owner.js';
+import { sealToken, vaultConfigured } from './vault.js';
+
+function json(data, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' },
+  });
+}
+
+function redirect(location) {
+  return new Response(null, { status: 302, headers: { location } });
+}
+
+export function isCloudflareConnectionPath(pathname) {
+  return pathname === '/api/connections/cloudflare'
+    || pathname === '/api/connections/cloudflare/start'
+    || pathname === CLOUDFLARE_CALLBACK_PATH
+    || pathname === '/api/connections/cloudflare/disconnect';
+}
+
+async function ensureTables(env) {
+  if (!env?.DB?.prepare) return;
+  await env.DB.prepare(`CREATE TABLE IF NOT EXISTS agentsam_cloudflare_connections (
+    connection_id TEXT PRIMARY KEY,
+    owner_id TEXT NOT NULL,
+    cloudflare_account_id TEXT,
+    scopes TEXT,
+    status TEXT,
+    access_token_encrypted TEXT,
+    refresh_token_encrypted TEXT,
+    created_at INTEGER,
+    updated_at INTEGER,
+    expires_at INTEGER
+  )`).run();
+  await env.DB.prepare(`CREATE TABLE IF NOT EXISTS agentsam_cloudflare_oauth_state (
+    state TEXT PRIMARY KEY,
+    owner_id TEXT NOT NULL,
+    code_verifier TEXT NOT NULL,
+    created_at INTEGER
+  )`).run();
+}
+
+export async function handleCloudflareConnectionRequest(request, env) {
+  const url = new URL(request.url);
+  const client = resolveCloudflareOAuthClient(env);
+  if (request.method === 'OPTIONS') {
+    return new Response(null, { status: 204 });
+  }
+
+  let body = {};
+  if (request.method === 'POST') {
+    body = await request.json().catch(() => ({}));
+  }
+
+  const isCallback = url.pathname === CLOUDFLARE_CALLBACK_PATH && request.method === 'GET';
+  let ownerId = '';
+  try {
+    ownerId = await resolveAuthenticatedOwner(request, env, url, body);
+  } catch (err) {
+    if (!isCallback || err.code === 'untrusted_owner_hint') {
+      const code = err.code || 'unauthenticated';
+      return json({ ok: false, error: code }, code === 'untrusted_owner_hint' ? 400 : 401);
+    }
+  }
+
+  if (!client.productionReady) {
+    if (url.pathname === '/api/connections/cloudflare' && request.method === 'GET') {
+      return json({
+        ok: true,
+        ...cloudflareConnectionSafeStatus(env, null, ownerId),
+      });
+    }
+    if (url.pathname === '/api/connections/cloudflare/start') {
+      return json({
+        ok: false,
+        error: 'not_configured',
+        message: 'real Cloudflare OAuth client still required',
+        fixture: client.fixture,
+      }, 503);
+    }
+  }
+
+  await ensureTables(env);
+
+  if (url.pathname === '/api/connections/cloudflare' && request.method === 'GET') {
+    let connection = null;
+    if (env.DB) {
+      const row = await env.DB.prepare(
+        `SELECT connection_id, owner_id, cloudflare_account_id, scopes, status, created_at, updated_at, expires_at
+         FROM agentsam_cloudflare_connections WHERE owner_id = ? LIMIT 1`,
+      ).bind(ownerId).first();
+      if (row) {
+        connection = {
+          connectionId: row.connection_id,
+          ownerId: row.owner_id,
+          cloudflareAccountId: row.cloudflare_account_id,
+          scopes: row.scopes ? String(row.scopes).split(' ') : [],
+          status: row.status,
+          createdAt: row.created_at,
+          updatedAt: row.updated_at,
+          expiresAt: row.expires_at,
+        };
+      }
+    }
+    return json({ ok: true, ...cloudflareConnectionSafeStatus(env, connection, ownerId) });
+  }
+
+  if (url.pathname === '/api/connections/cloudflare/start' && request.method === 'GET') {
+    const state = crypto.randomUUID().replace(/-/g, '');
+    const verifierBytes = crypto.getRandomValues(new Uint8Array(32));
+    const verifier = btoa(String.fromCharCode(...verifierBytes)).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+    const digest = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(verifier));
+    const challenge = btoa(String.fromCharCode(...new Uint8Array(digest))).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+    if (env.DB) {
+      await env.DB.prepare(
+        `INSERT INTO agentsam_cloudflare_oauth_state (state, owner_id, code_verifier, created_at) VALUES (?, ?, ?, unixepoch())`,
+      ).bind(state, ownerId, verifier).run();
+    } else if (env.oauthState instanceof Map) {
+      env.oauthState.set(state, { ownerId, verifier });
+    }
+    const redirectUri = `${url.origin}${CLOUDFLARE_CALLBACK_PATH}`;
+    const authorize = buildAuthorizeUrl({
+      clientId: String(env.CLOUDFLARE_OAUTH_CLIENT_ID),
+      redirectUri,
+      state,
+      codeChallenge: challenge,
+    });
+    return json({ ok: true, authorize_url: authorize, callback: CLOUDFLARE_CALLBACK_PATH });
+  }
+
+  if (url.pathname === CLOUDFLARE_CALLBACK_PATH && request.method === 'GET') {
+    const code = url.searchParams.get('code') || '';
+    const state = url.searchParams.get('state') || '';
+    let stored = null;
+    if (env.DB) {
+      stored = await env.DB.prepare(
+        `SELECT owner_id, code_verifier FROM agentsam_cloudflare_oauth_state WHERE state = ?`,
+      ).bind(state).first();
+    } else if (env.oauthState instanceof Map) {
+      stored = env.oauthState.get(state);
+      if (stored) stored = { owner_id: stored.ownerId, code_verifier: stored.verifier };
+    }
+    if (!stored) {
+      return json({ ok: false, error: 'cloudflare_connection_forbidden' }, 403);
+    }
+    if (!ownerId) ownerId = stored.owner_id;
+    if (stored.owner_id !== ownerId) {
+      return json({ ok: false, error: 'cloudflare_connection_forbidden' }, 403);
+    }
+    const tokenRes = await fetch(CLOUDFLARE_OAUTH_TOKEN_URL, {
+      method: 'POST',
+      headers: { 'content-type': 'application/x-www-form-urlencoded' },
+      body: new URLSearchParams({
+        grant_type: 'authorization_code',
+        code,
+        redirect_uri: `${url.origin}${CLOUDFLARE_CALLBACK_PATH}`,
+        client_id: String(env.CLOUDFLARE_OAUTH_CLIENT_ID),
+        client_secret: String(env.CLOUDFLARE_OAUTH_CLIENT_SECRET),
+        code_verifier: stored.code_verifier,
+      }),
+    });
+    if (!tokenRes.ok) {
+      return json({ ok: false, error: 'token_exchange_failed' }, 502);
+    }
+    const tokens = await tokenRes.json();
+    const connectionId = `cfconn_${crypto.randomUUID().replace(/-/g, '').slice(0, 16)}`;
+    if (tokens.access_token && !vaultConfigured(env)) {
+      return json({ ok: false, error: 'vault_unavailable' }, 503);
+    }
+    const aad = `cloudflare-connection:${ownerId}`;
+    let accessEnc = null;
+    let refreshEnc = null;
+    try {
+      accessEnc = await sealToken(env, tokens.access_token, aad);
+      refreshEnc = await sealToken(env, tokens.refresh_token, aad);
+    } catch (err) {
+      return json({ ok: false, error: err.code || 'vault_unavailable' }, 503);
+    }
+    if (env.DB) {
+      await env.DB.prepare(
+        `INSERT INTO agentsam_cloudflare_connections (
+           connection_id, owner_id, cloudflare_account_id, scopes, status,
+           access_token_encrypted, refresh_token_encrypted, created_at, updated_at, expires_at
+         ) VALUES (?, ?, ?, ?, 'connected', ?, ?, unixepoch(), unixepoch(), ?)`,
+      ).bind(
+        connectionId,
+        ownerId,
+        tokens.account_id || null,
+        (tokens.scope || requestedCloudflareScopes().join(' ')),
+        accessEnc,
+        refreshEnc,
+        tokens.expires_in ? Math.floor(Date.now() / 1000) + Number(tokens.expires_in) : null,
+      ).run();
+    }
+    return redirect(`/agentsam?connection=cloudflare`);
+  }
+
+  if (url.pathname === '/api/connections/cloudflare/disconnect' && request.method === 'POST') {
+    if (env.DB) {
+      const row = await env.DB.prepare(
+        `SELECT connection_id, owner_id FROM agentsam_cloudflare_connections WHERE owner_id = ?`,
+      ).bind(ownerId).first();
+      if (row) {
+        assertConnectionOwner({ ownerId: row.owner_id, connectionId: row.connection_id }, ownerId);
+        await env.DB.prepare(`DELETE FROM agentsam_cloudflare_connections WHERE owner_id = ?`).bind(ownerId).run();
+      }
+    }
+    return json({ ok: true, status: 'not_configured' });
+  }
+
+  return json({ ok: false, error: 'not_found' }, 404);
+}

package/packages/connectors/cloudflare/src/vault.js

@@ -0,0 +1,80 @@
+/**
+ * AES-256-GCM token vault matching apps/local-studio/backend/worker encryptSecret.
+ * Connector tokens are server-only. Never return plaintext on status routes.
+ */
+const enc = new TextEncoder();
+const dec = new TextDecoder();
+
+function b64ToBytes(value) {
+  const bin = atob(value);
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i += 1) out[i] = bin.charCodeAt(i);
+  return out;
+}
+
+function bytesToB64(bytes) {
+  let bin = '';
+  for (const b of bytes) bin += String.fromCharCode(b);
+  return btoa(bin);
+}
+
+export function vaultConfigured(env = {}) {
+  return Boolean(env.VAULT_MASTER_KEY || env.VAULT_KEY);
+}
+
+async function importVaultKey(env) {
+  const raw = env.VAULT_MASTER_KEY || env.VAULT_KEY;
+  if (!raw) throw new Error('VAULT_MASTER_KEY missing');
+  let keyBytes;
+  try {
+    keyBytes = b64ToBytes(raw);
+  } catch {
+    keyBytes = enc.encode(raw);
+  }
+  if (keyBytes.byteLength === 32) {
+    // ok
+  } else if (keyBytes.byteLength > 32) {
+    keyBytes = keyBytes.slice(0, 32);
+  } else {
+    const hash = await crypto.subtle.digest('SHA-256', keyBytes);
+    keyBytes = new Uint8Array(hash);
+  }
+  return crypto.subtle.importKey('raw', keyBytes, { name: 'AES-GCM' }, false, ['encrypt', 'decrypt']);
+}
+
+export async function encryptSecret(env, plaintext, aad) {
+  const key = await importVaultKey(env);
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const cipher = await crypto.subtle.encrypt(
+    { name: 'AES-GCM', iv, additionalData: enc.encode(aad || '') },
+    key,
+    enc.encode(plaintext),
+  );
+  const packed = new Uint8Array(iv.byteLength + cipher.byteLength);
+  packed.set(iv, 0);
+  packed.set(new Uint8Array(cipher), iv.byteLength);
+  return bytesToB64(packed);
+}
+
+export async function decryptSecret(env, packedB64, aad) {
+  const key = await importVaultKey(env);
+  const packed = b64ToBytes(packedB64);
+  const iv = packed.slice(0, 12);
+  const data = packed.slice(12);
+  const plain = await crypto.subtle.decrypt(
+    { name: 'AES-GCM', iv, additionalData: enc.encode(aad || '') },
+    key,
+    data,
+  );
+  return dec.decode(plain);
+}
+
+export async function sealToken(env, plaintext, aad) {
+  if (!plaintext) return null;
+  if (!vaultConfigured(env)) {
+    const err = new Error('vault_unavailable');
+    err.code = 'vault_unavailable';
+    throw err;
+  }
+  return encryptSecret(env, plaintext, aad);
+}

package/packages/connectors/cloudflare/tests/connector.test.mjs

@@ -0,0 +1,44 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import {
+  assertConnectionOwner,
+  cloudflareConnectionSafeStatus,
+  resolveCloudflareOAuthClient,
+} from '../src/index.js';
+
+describe('cloudflare connector', () => {
+  it('reports not_configured when credentials are absent', () => {
+    const client = resolveCloudflareOAuthClient({});
+    assert.equal(client.status, 'not_configured');
+    assert.equal(client.configured, false);
+    assert.equal(client.productionReady, false);
+  });
+
+  it('loads fake fixtures without treating them as production authority', () => {
+    const client = resolveCloudflareOAuthClient({
+      CLOUDFLARE_OAUTH_CLIENT_ID: 'sillynotreal',
+      CLOUDFLARE_OAUTH_CLIENT_SECRET: 'sillynotreal-secret',
+    });
+    assert.equal(client.configured, true);
+    assert.equal(client.fixture, true);
+    assert.equal(client.productionReady, false);
+    assert.equal(client.status, 'fixture');
+  });
+
+  it('never includes secrets in safe status output', () => {
+    const status = cloudflareConnectionSafeStatus({
+      CLOUDFLARE_OAUTH_CLIENT_ID: 'sillynotreal',
+      CLOUDFLARE_OAUTH_CLIENT_SECRET: 'sillynotreal-secret',
+    });
+    const blob = JSON.stringify(status);
+    assert.equal(blob.includes('sillynotreal-secret'), false);
+    assert.equal(status.secret, 'configured');
+    assert.equal(status.configured, false);
+  });
+
+  it('denies cross-account connection access', () => {
+    const record = { ownerId: 'sam', connectionId: 'c1' };
+    assert.throws(() => assertConnectionOwner(record, 'connor'), /cloudflare_connection_forbidden/);
+    assert.equal(assertConnectionOwner(record, 'sam').connectionId, 'c1');
+  });
+});

package/packages/identity/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@inneranimalmedia/agentsam-sdk-identity",
-  "version": "2.5.0",
+  "version": "2.6.0",
   "private": true,
   "type": "module",
-  "description": "Identity module for @inneranimalmedia/agentsam-sdk (workspace \u2014 publish via root SDK)",
+  "description": "Identity module for @inneranimalmedia/agentsam-sdk (workspace — publish via root SDK)",
   "agentsam": {
     "system": "identity",
     "kind": "library",

package/packages/identity/src/contracts/auth-config.js

@@ -5,20 +5,24 @@
  * may provide storage/verification adapters without inventing competing aliases.
  *
  * Canonical variables:
- *   IAM_ORIGIN            IAM authority + browser/OAuth/API origin
+ *   IAM_OAUTH_ISSUER      public authorization-server authority (issuer)
  *   IAM_CLIENT_ID         OAuth client id
  *   IAM_CLIENT_SECRET     OAuth client secret
+ *   IAM_ORIGIN            deprecated alias of IAM_OAUTH_ISSUER (migration window)
  *   AGENTSAM_SDK_KEY      account/delegated sdk_* bearer
  *   AGENTSAM_BRIDGE_KEY   machine/integration credential
  *
  * Migration-only fallbacks:
- *   IAM_OAUTH_ISSUER      -> IAM_ORIGIN
+ *   IAM_ORIGIN            -> IAM_OAUTH_ISSUER
  *   AGENTSAM_SDK_TOKEN    -> AGENTSAM_SDK_KEY
  */
 
-export const DEFAULT_IAM_ORIGIN = 'https://inneranimalmedia.com';
+export const DEFAULT_IAM_OAUTH_ISSUER = 'https://inneranimalmedia.com';
+/** @deprecated Use DEFAULT_IAM_OAUTH_ISSUER. */
+export const DEFAULT_IAM_ORIGIN = DEFAULT_IAM_OAUTH_ISSUER;
 
 export const AGENTSAM_AUTH_ENV = Object.freeze({
+  iamIssuer: 'IAM_OAUTH_ISSUER',
   iamOrigin: 'IAM_ORIGIN',
   iamClientId: 'IAM_CLIENT_ID',
   iamClientSecret: 'IAM_CLIENT_SECRET',
@@ -27,7 +31,7 @@ export const AGENTSAM_AUTH_ENV = Object.freeze({
 });
 
 export const AGENTSAM_AUTH_LEGACY_ENV = Object.freeze({
-  iamOrigin: 'IAM_OAUTH_ISSUER',
+  iamOrigin: 'IAM_ORIGIN',
   sdkKey: 'AGENTSAM_SDK_TOKEN',
 });
 
@@ -35,6 +39,7 @@ export const AGENTSAM_AUTH_CONTRACT = Object.freeze({
   version: 1,
   authority: 'agentsam-sdk',
   iam: Object.freeze({
+    issuer: AGENTSAM_AUTH_ENV.iamIssuer,
     origin: AGENTSAM_AUTH_ENV.iamOrigin,
     clientId: AGENTSAM_AUTH_ENV.iamClientId,
     clientSecret: AGENTSAM_AUTH_ENV.iamClientSecret,
@@ -54,6 +59,7 @@ export const AGENTSAM_AUTH_CONTRACT = Object.freeze({
   }),
   compatibility: Object.freeze({
     iamOriginFallback: AGENTSAM_AUTH_LEGACY_ENV.iamOrigin,
+    iamIssuerCanonical: AGENTSAM_AUTH_ENV.iamIssuer,
     sdkKeyFallback: AGENTSAM_AUTH_LEGACY_ENV.sdkKey,
   }),
 });
@@ -66,13 +72,18 @@ function normalizeOrigin(value) {
   return clean(value).replace(/\/+$/, '');
 }
 
-/** Resolve canonical IAM authority origin with one migration fallback. */
-export function resolveIamOrigin(env = {}, explicit = '') {
+/** Resolve canonical IAM issuer. IAM_OAUTH_ISSUER wins; IAM_ORIGIN is compatibility only. */
+export function resolveIamIssuer(env = {}, explicit = '') {
   return normalizeOrigin(
-    explicit || env?.IAM_ORIGIN || env?.IAM_OAUTH_ISSUER || DEFAULT_IAM_ORIGIN,
+    explicit || env?.IAM_OAUTH_ISSUER || env?.IAM_ORIGIN || DEFAULT_IAM_OAUTH_ISSUER,
   );
 }
 
+/** @deprecated Use resolveIamIssuer. Same resolution order as issuer. */
+export function resolveIamOrigin(env = {}, explicit = '') {
+  return resolveIamIssuer(env, explicit);
+}
+
 /** Resolve account/delegated SDK bearer; canonical name wins over legacy. */
 export function resolveSdkKey(env = {}, explicit = '') {
   return clean(explicit || env?.AGENTSAM_SDK_KEY || env?.AGENTSAM_SDK_TOKEN);

package/packages/identity/tests/auth-config.test.mjs

@@ -9,23 +9,27 @@ import {
 } from '../src/contracts/auth-config.js';
 
 describe('auth configuration contract', () => {
-  it('prefers canonical IAM_ORIGIN over the migration alias', () => {
+  it('prefers canonical IAM_OAUTH_ISSUER over IAM_ORIGIN', () => {
     assert.equal(
       resolveIamOrigin({
-        IAM_ORIGIN: 'https://canonical.example.test/',
-        IAM_OAUTH_ISSUER: 'https://legacy.example.test/',
+        IAM_ORIGIN: 'https://legacy.example.test/',
+        IAM_OAUTH_ISSUER: 'https://canonical.example.test/',
       }),
       'https://canonical.example.test',
     );
   });
 
-  it('accepts IAM_OAUTH_ISSUER as migration-only fallback', () => {
+  it('accepts IAM_ORIGIN as migration-only fallback', () => {
     assert.equal(
-      resolveIamOrigin({ IAM_OAUTH_ISSUER: 'https://legacy.example.test/' }),
+      resolveIamOrigin({ IAM_ORIGIN: 'https://legacy.example.test/' }),
       'https://legacy.example.test',
     );
   });
 
+  it('defaults issuer when neither IAM_OAUTH_ISSUER nor IAM_ORIGIN exists', () => {
+    assert.equal(resolveIamOrigin({}), 'https://inneranimalmedia.com');
+  });
+
   it('prefers AGENTSAM_SDK_KEY over AGENTSAM_SDK_TOKEN', () => {
     assert.equal(
       resolveSdkKey({

package/packages/identity/tests/oauth-credentials.test.mjs

@@ -46,18 +46,18 @@ describe('oauth credentials', () => {
     assert.equal(resolveOAuthCredentialLane(env, 'iam')?.lane, 'iam_platform');
   });
 
-  it('prefers IAM_ORIGIN and exposes origin as the canonical authority', () => {
+  it('prefers IAM_OAUTH_ISSUER and exposes issuer as the canonical authority', () => {
     const creds = resolveIamPlatformCredentials({
       IAM_CLIENT_ID: 'c',
       IAM_CLIENT_SECRET: 's',
-      IAM_ORIGIN: 'https://iam.example.test/',
-      IAM_OAUTH_ISSUER: 'https://legacy.example.test/',
+      IAM_ORIGIN: 'https://legacy.example.test/',
+      IAM_OAUTH_ISSUER: 'https://iam.example.test/',
     });
     assert.equal(creds?.origin, 'https://iam.example.test');
     assert.equal(creds?.issuer, 'https://iam.example.test');
   });
 
-  it('accepts IAM_OAUTH_ISSUER only as a migration fallback', () => {
+  it('accepts IAM_ORIGIN only as a migration fallback', () => {
     const creds = resolveIamPlatformCredentials({
       IAM_CLIENT_ID: 'c',
       IAM_CLIENT_SECRET: 's',

package/protocol/README.md

@@ -12,6 +12,7 @@ Platform repositories may consume the SDK, provide host adapters, or incubate pr
 4. **Contracts travel with the SDK.** Shared schemas and protocol definitions live under `protocol/` and are versioned with the code that consumes them.
 5. **No copied package trees.** Do not duplicate `protocol/`, `agentsam_sdk/`, or package source under another path in this repository or another repository merely to keep two homes in sync.
 6. **Repository tools observe before they prescribe.** Generic repository intelligence must accept an explicit repo root, be read-only by default, and must not hardcode one repository's folder names, tenant IDs, workspace IDs, providers, or framework layout.
+7. **Model facts have one authority chain.** `/models`, CLI JSON, runtime selection, and usage receipts must follow the normative model SSOT contract in `protocol/models/README.md`; provider facts retain authoritative provenance while AgentSam recommendations remain separate policy.
 
 ## Layout
 

package/protocol/capabilities/cloudflare-cpu-audit-input.schema.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://schemas.inneranimalmedia.com/agentsam/capabilities/cloudflare-cpu-audit-input.schema.json",
+  "title": "cloudflare.cpu.audit input",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["file"],
+  "properties": {
+    "cwd": { "type": "string", "minLength": 1 },
+    "file": { "type": "string", "minLength": 1 },
+    "sources": {
+      "type": "array",
+      "maxItems": 12,
+      "items": { "type": "string", "minLength": 1 }
+    },
+    "maxFrames": { "type": "integer", "minimum": 1, "maximum": 100 },
+    "maxSourceChars": { "type": "integer", "minimum": 1000, "maximum": 64000, "default": 24000 }
+  }
+}

package/protocol/capabilities/cloudflare-cpu-profile-input.schema.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://schemas.inneranimalmedia.com/agentsam/capabilities/cloudflare-cpu-profile-input.schema.json",
+  "title": "cloudflare.cpu.profile input",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["file"],
+  "properties": {
+    "cwd": { "type": "string", "minLength": 1 },
+    "file": { "type": "string", "minLength": 1 },
+    "maxFrames": { "type": "integer", "minimum": 1, "maximum": 100 }
+  }
+}

package/protocol/capabilities/cloudflare-wrangler-native-input.schema.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://schemas.inneranimalmedia.com/agentsam/capabilities/cloudflare-wrangler-native-input.schema.json",
+  "title": "cloudflare.wrangler.native input",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["command"],
+  "properties": {
+    "command": { "enum": ["whoami", "deployments.list", "versions.list", "types.check", "queues.list"] },
+    "cwd": { "type": "string", "minLength": 1 },
+    "name": { "type": "string" },
+    "account": { "type": "string" },
+    "config": { "type": "string" },
+    "env": { "type": "string" },
+    "profile": { "type": "string" },
+    "path": { "type": "string" },
+    "page": { "type": "integer", "minimum": 1 }
+  }
+}

package/protocol/capabilities/manifest.json

@@ -279,6 +279,53 @@
       "side_effects": "none",
       "output_schema": "protocol/context/resolved-context-pack.schema.json",
       "status": "experimental"
+    },
+    "cloudflare.wrangler.native": {
+      "id": "cloudflare.wrangler.native",
+      "kind": "capability",
+      "version": 1,
+      "domain": "cloudflare",
+      "runtime": "node+wrangler",
+      "package": "@inneranimalmedia/agentsam-sdk/cloudflare",
+      "export": "runWranglerNative",
+      "cli": "agentsam cloudflare run <command>",
+      "description": "Execute one allowlisted read-only Wrangler operation with argv-safe cwd/config scoping and structured diagnostics.",
+      "deterministic": false,
+      "model_required": false,
+      "side_effects": "network-read",
+      "input_schema": "protocol/capabilities/cloudflare-wrangler-native-input.schema.json",
+      "status": "experimental"
+    },
+    "cloudflare.cpu.profile": {
+      "id": "cloudflare.cpu.profile",
+      "kind": "capability",
+      "version": 1,
+      "domain": "cloudflare",
+      "runtime": "node",
+      "package": "@inneranimalmedia/agentsam-sdk/cloudflare",
+      "export": "summarizeCloudflareCpuProfileFile",
+      "cli": "agentsam cloudflare cpu analyze <profile.cpuprofile>",
+      "description": "Summarize a local workerd/DevTools CPU profile into bounded ranked self-time evidence.",
+      "deterministic": true,
+      "model_required": false,
+      "side_effects": "none",
+      "input_schema": "protocol/capabilities/cloudflare-cpu-profile-input.schema.json",
+      "status": "experimental"
+    },
+    "cloudflare.cpu.audit": {
+      "id": "cloudflare.cpu.audit",
+      "kind": "agent_primitive",
+      "version": 1,
+      "domain": "cloudflare",
+      "runtime": "node",
+      "package": "@inneranimalmedia/agentsam-sdk/cloudflare",
+      "export": "runCloudflareCpuAudit",
+      "description": "Analyze a bounded Cloudflare CPU profile and selected source evidence through an injected reasoning adapter without deploy authority.",
+      "deterministic": false,
+      "model_required": true,
+      "side_effects": "none",
+      "input_schema": "protocol/capabilities/cloudflare-cpu-audit-input.schema.json",
+      "status": "experimental"
     }
   }
 }

package/protocol/context/context-budget.schema.json

@@ -5,21 +5,10 @@
   "type": "object",
   "additionalProperties": false,
   "required": [
-    "windowTokens",
-    "windowChars",
-    "charsPerToken",
-    "targetInputRatio",
-    "hardInputRatio",
-    "targetInputTokens",
-    "hardInputTokens",
-    "targetInputChars",
-    "hardInputChars",
-    "maxSystemChars",
-    "maxToolSchemaChars",
-    "maxEvidenceChars",
-    "maxFileCharsPerRead",
-    "maxFileCharsPerTurn",
-    "maxToolResultChars"
+    "windowTokens", "windowChars", "charsPerToken", "targetInputRatio", "hardInputRatio", "hardWindowRatio",
+    "targetInputTokens", "compactAtTokens", "interveneAtTokens", "maxNormalInputTokens", "hardInputTokens",
+    "pricingThresholdTokens", "safetyMarginTokens", "targetInputChars", "hardInputChars",
+    "maxSystemChars", "maxToolSchemaChars", "maxEvidenceChars", "maxFileCharsPerRead", "maxFileCharsPerTurn", "maxToolResultChars"
   ],
   "properties": {
     "windowTokens": { "type": "integer", "minimum": 1 },
@@ -27,8 +16,14 @@
     "charsPerToken": { "type": "number", "exclusiveMinimum": 0 },
     "targetInputRatio": { "type": "number", "exclusiveMinimum": 0, "maximum": 1 },
     "hardInputRatio": { "type": "number", "exclusiveMinimum": 0, "maximum": 1 },
+    "hardWindowRatio": { "type": "number", "exclusiveMinimum": 0, "maximum": 1 },
     "targetInputTokens": { "type": "integer", "minimum": 1 },
+    "compactAtTokens": { "type": "integer", "minimum": 1 },
+    "interveneAtTokens": { "type": "integer", "minimum": 1 },
+    "maxNormalInputTokens": { "type": "integer", "minimum": 1 },
     "hardInputTokens": { "type": "integer", "minimum": 1 },
+    "pricingThresholdTokens": { "type": ["integer", "null"], "minimum": 1 },
+    "safetyMarginTokens": { "type": "integer", "minimum": 0 },
     "targetInputChars": { "type": "integer", "minimum": 1 },
     "hardInputChars": { "type": "integer", "minimum": 1 },
     "maxSystemChars": { "type": "integer", "minimum": 1 },