@nullsquare/agent-authority 0.4.0

package/examples/live-github-derived-mutation.js

@@ -0,0 +1,208 @@
+import { AuthorityRuntime } from '../src/index.js';
+import {
+  AuthorityApprovalRequiredError,
+  AuthorityDeniedError,
+  createTaskLeaseGuard
+} from '../src/guard.js';
+import { createTaskLease } from '../src/task-lease.js';
+
+const repository = process.env.AA_VALIDATION_REPOSITORY || 'Null-Square/agent-authority';
+const marker = process.env.AA_VALIDATION_MARKER || 'agent-authority-live-fixture-v1';
+const token = process.env.GITHUB_TOKEN;
+
+if (!token) {
+  throw new Error('GITHUB_TOKEN is required for the live derived-mutation validation');
+}
+
+const [owner, repo] = repository.split('/');
+if (!owner || !repo) throw new Error(`invalid repository: ${repository}`);
+
+const mission = {
+  version: '0.1',
+  mission_id: 'mission:live-derived-github-mutation',
+  principal: { id: 'user:validation' },
+  agent: { id: 'agent:github-actions-validation' },
+  objective: 'Discover the validation issue and comment only on that issue',
+  resources: [
+    {
+      service: 'github',
+      allow: ['issue.list', 'issue.comment'],
+      deny: ['issue.close', 'issue.delete', 'repo.write', 'repo.delete'],
+      constraints: { repository: [repository] }
+    }
+  ],
+  constraints: { expires_at: '2099-01-01T00:00:00Z' }
+};
+
+const lease = createTaskLease({
+  mission,
+  request: 'Find the Agent Authority live validation fixture and leave one validation comment',
+  roots: [
+    {
+      fact_id: 'fact:repository',
+      kind: 'github.repository',
+      value: repository,
+      source: 'validation-task'
+    }
+  ],
+  bindings: [
+    {
+      service: 'github',
+      action: 'issue.list',
+      context_field: 'repository',
+      fact_id: 'fact:repository'
+    },
+    {
+      service: 'github',
+      action: 'issue.comment',
+      context_field: 'repository',
+      fact_id: 'fact:repository'
+    },
+    {
+      service: 'github',
+      action: 'issue.comment',
+      context_field: 'issue_number',
+      fact_id: 'fact:discovered-issue-number'
+    }
+  ]
+});
+
+const guard = createTaskLeaseGuard({ lease, runtime: new AuthorityRuntime() });
+const headers = {
+  accept: 'application/vnd.github+json',
+  authorization: `Bearer ${token}`,
+  'user-agent': 'agent-authority-derived-mutation-validation',
+  'x-github-api-version': '2022-11-28'
+};
+
+let providerReadCalls = 0;
+let providerMutationCalls = 0;
+let cleanupCalls = 0;
+let createdCommentId = null;
+
+async function githubJson(url, options = {}) {
+  const response = await fetch(url, {
+    ...options,
+    headers: { ...headers, ...(options.headers || {}) }
+  });
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(`GitHub ${response.status}: ${body.slice(0, 300)}`);
+  }
+  if (response.status === 204) return null;
+  return response.json();
+}
+
+async function discoverFixtureIssue() {
+  return guard.run(
+    {
+      service: 'github',
+      action: 'issue.list',
+      context: { repository }
+    },
+    async () => {
+      providerReadCalls += 1;
+      const issues = await githubJson(
+        `https://api.github.com/repos/${owner}/${repo}/issues?state=open&per_page=100`
+      );
+      const fixture = issues.find((issue) => !issue.pull_request && issue.body?.includes(marker));
+      if (!fixture) throw new Error(`validation fixture with marker ${marker} was not found`);
+      return { number: fixture.number, title: fixture.title };
+    }
+  );
+}
+
+async function commentOnIssue(issueNumber, body) {
+  return guard.run(
+    {
+      service: 'github',
+      action: 'issue.comment',
+      context: { repository, issue_number: issueNumber }
+    },
+    async () => {
+      providerMutationCalls += 1;
+      const comment = await githubJson(
+        `https://api.github.com/repos/${owner}/${repo}/issues/${issueNumber}/comments`,
+        {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ body })
+        }
+      );
+      return { id: comment.id, html_url: comment.html_url };
+    }
+  );
+}
+
+async function cleanupComment(commentId) {
+  cleanupCalls += 1;
+  await githubJson(
+    `https://api.github.com/repos/${owner}/${repo}/issues/comments/${commentId}`,
+    { method: 'DELETE' }
+  );
+}
+
+try {
+  console.log(`Task root repository: ${repository}`);
+  console.log('1. Discover fixture through an authorized live GitHub issue-list call');
+  const discovered = await discoverFixtureIssue();
+  console.log(`   ALLOW -> discovered issue #${discovered.output.number}: ${discovered.output.title}`);
+
+  lease.derive({
+    fact_id: 'fact:discovered-issue-number',
+    kind: 'github.issue.number',
+    value: discovered.output.number,
+    from: ['fact:repository'],
+    receipt: discovered.receipt,
+    selector: 'output.number'
+  });
+  console.log(`2. Derived authority -> issue #${discovered.output.number}`);
+
+  const validationBody = `Agent Authority live derived-authority validation (${new Date().toISOString()}). Temporary comment; CI removes it after the proof.`;
+  const allowedMutation = await commentOnIssue(discovered.output.number, validationBody);
+  createdCommentId = allowedMutation.output.id;
+  console.log(`3. ALLOW -> real GitHub comment mutation executed (comment ${createdCommentId})`);
+
+  const unrelatedIssue = discovered.output.number === 1 ? 2 : 1;
+  try {
+    await commentOnIssue(unrelatedIssue, 'THIS MUST NEVER REACH GITHUB');
+    throw new Error('unrelated issue mutation unexpectedly executed');
+  } catch (error) {
+    if (!(error instanceof AuthorityApprovalRequiredError) || error.code !== 'authority_delta_required') {
+      throw error;
+    }
+    console.log(`4. STEP-UP -> unrelated issue #${unrelatedIssue} blocked before provider mutation`);
+  }
+
+  if (providerMutationCalls !== 1) {
+    throw new Error(`expected exactly one task-side provider mutation before completion, got ${providerMutationCalls}`);
+  }
+
+  lease.complete('live derived-mutation validation complete');
+  try {
+    await commentOnIssue(discovered.output.number, 'THIS MUST NOT RUN AFTER TASK COMPLETION');
+    throw new Error('post-completion mutation unexpectedly executed');
+  } catch (error) {
+    if (!(error instanceof AuthorityDeniedError) || error.code !== 'task_lease_completed') {
+      throw error;
+    }
+    console.log(`5. DENY -> post-completion mutation blocked for issue #${discovered.output.number}`);
+  }
+
+  if (providerReadCalls !== 1) {
+    throw new Error(`expected exactly one provider discovery call, got ${providerReadCalls}`);
+  }
+  if (providerMutationCalls !== 1) {
+    throw new Error(`expected exactly one provider mutation after blocked attempts, got ${providerMutationCalls}`);
+  }
+
+  console.log('PASS -> dynamic resource was discovered from GitHub, derived into the Task Lease, and mutated exactly once');
+  console.log('PASS -> unrelated and post-completion mutations produced zero additional provider mutation calls');
+} finally {
+  if (createdCommentId) {
+    await cleanupComment(createdCommentId);
+    console.log(`Cleanup -> deleted temporary validation comment ${createdCommentId} (outside the agent authority proof)`);
+  }
+  console.log(`Provider calls observed before cleanup: reads=${providerReadCalls}, task_mutations=${providerMutationCalls}`);
+  console.log(`Harness cleanup calls: ${cleanupCalls}`);
+}

package/examples/live-github-task-lease.js

@@ -0,0 +1,80 @@
+import { AuthorityRuntime } from '../src/index.js';
+import { AuthorityApprovalRequiredError, createTaskLeaseGuard } from '../src/guard.js';
+import { createTaskLease } from '../src/task-lease.js';
+
+const allowedRepository = process.argv[2] || 'Null-Square/agent-authority';
+const blockedRepository = process.argv[3] || 'octocat/Hello-World';
+
+const mission = {
+  version: '0.1',
+  mission_id: 'mission:live-github-validation',
+  principal: { id: 'user:validation' },
+  agent: { id: 'agent:ordinary-node-app' },
+  objective: 'Read only the repository authorized for this task',
+  resources: [{
+    service: 'github',
+    allow: ['repo.read'],
+    deny: ['repo.delete', 'repo.write'],
+    constraints: {}
+  }],
+  constraints: { expires_at: '2099-01-01T00:00:00Z' }
+};
+
+const lease = createTaskLease({
+  mission,
+  request: `Inspect ${allowedRepository}`,
+  roots: [{
+    fact_id: 'fact:repository',
+    kind: 'github.repository',
+    value: allowedRepository
+  }],
+  bindings: [{
+    service: 'github',
+    action: 'repo.read',
+    context_field: 'repository',
+    fact_id: 'fact:repository'
+  }]
+});
+
+const guard = createTaskLeaseGuard({ lease, runtime: new AuthorityRuntime() });
+let outboundCalls = 0;
+
+async function githubRead(repository) {
+  return guard.run({
+    service: 'github',
+    action: 'repo.read',
+    context: { repository }
+  }, async () => {
+    outboundCalls += 1;
+    const headers = {
+      accept: 'application/vnd.github+json',
+      'user-agent': 'agent-authority-live-validation'
+    };
+    if (process.env.GITHUB_TOKEN) headers.authorization = `Bearer ${process.env.GITHUB_TOKEN}`;
+
+    const response = await fetch(`https://api.github.com/repos/${repository}`, { headers });
+    if (!response.ok) throw new Error(`GitHub returned ${response.status}`);
+    const body = await response.json();
+    return { full_name: body.full_name, private: body.private, html_url: body.html_url };
+  });
+}
+
+console.log(`Task allows exactly: ${allowedRepository}`);
+console.log(`Credential mode: ${process.env.GITHUB_TOKEN ? 'authenticated GitHub token' : 'public GitHub API'}`);
+
+const allowed = await githubRead(allowedRepository);
+console.log(`ALLOW -> live GitHub returned ${allowed.output.full_name}`);
+console.log(`Outbound GitHub calls: ${outboundCalls}`);
+
+try {
+  await githubRead(blockedRepository);
+  throw new Error('blocked repository unexpectedly executed');
+} catch (error) {
+  if (!(error instanceof AuthorityApprovalRequiredError) || error.code !== 'authority_delta_required') throw error;
+  console.log(`STEP-UP -> ${blockedRepository} is outside task authority`);
+}
+
+if (outboundCalls !== 1) throw new Error(`expected exactly one outbound GitHub call, got ${outboundCalls}`);
+console.log('PASS -> unrelated repository was blocked before fetch()');
+
+lease.complete('live validation complete');

package/examples/mission.json

@@ -0,0 +1,20 @@
+{
+  "version": "0.1",
+  "mission_id": "mission:demo",
+  "principal": { "id": "user:demo" },
+  "agent": { "id": "agent:demo", "harness": "local" },
+  "objective": "Maintain an approved project without destructive or billing actions",
+  "resources": [
+    { "service": "github", "allow": ["repo.read", "repo.write", "pull_request.*"], "deny": ["repo.delete", "billing.*"] },
+    { "service": "google", "allow": ["gmail.read", "gmail.draft", "gmail.send"], "deny": ["gmail.delete"] },
+    { "service": "cloudflare", "allow": ["workers.read", "workers.deploy"], "deny": ["account.delete", "billing.*"] }
+  ],
+  "constraints": {
+    "max_delegation_depth": 2,
+    "budget": { "currency": "USD", "amount": 100 },
+    "expires_at": "2027-01-01T00:00:00Z"
+  },
+  "approvals": [
+    { "match": { "service": "google", "action": "gmail.send" }, "required": true, "reason": "outbound communication requires human approval" }
+  ]
+}

package/examples/missions/chatgpt-web-validation.json

@@ -0,0 +1,33 @@
+{
+  "version": "0.1",
+  "mission_id": "mission:chatgpt-web-validation",
+  "principal": {
+    "id": "user:local"
+  },
+  "agent": {
+    "id": "agent:chatgpt-web"
+  },
+  "objective": "Validate that a web agent can read only the approved public Agent Authority repository through an MCP gateway.",
+  "resources": [
+    {
+      "service": "mcp:validation-upstream",
+      "allow": [
+        "tool.github_repo_metadata"
+      ],
+      "deny": [
+        "tool.dangerous_demo_write",
+        "*write*",
+        "*delete*"
+      ],
+      "constraints": {
+        "repository": [
+          "Null-Square/agent-authority"
+        ]
+      }
+    }
+  ],
+  "constraints": {
+    "max_delegation_depth": 0
+  },
+  "approvals": []
+}

package/examples/openclaw-tool-wrapper.js

@@ -0,0 +1,49 @@
+import { AgentAuthorityClient } from '../src/sdk.js';
+
+// Thin integration pattern for an OpenClaw/plugin-style tool wrapper.
+// The wrapper owns no provider credentials. It forwards normalized authority
+// requests to the Agent Authority sidecar and returns sanitized output.
+
+const authority = new AgentAuthorityClient({
+  baseUrl: process.env.AGENT_AUTHORITY_URL || 'http://127.0.0.1:8787'
+});
+
+export function createAuthorityTool({ mission }) {
+  return async function executeAuthorityTool({ service, action, context = {}, params = {} }) {
+    const result = await authority.execute(mission, {
+      service,
+      action,
+      context,
+      params
+    });
+
+    if (result.result?.decision === 'deny') {
+      const error = new Error(result.result.reason || 'Agent Authority denied the action');
+      error.code = result.result.code || 'authority_denied';
+      throw error;
+    }
+
+    if (result.result?.decision === 'require_approval') {
+      return {
+        status: 'require_approval',
+        receipt: result.receipt,
+        reason: result.result.reason
+      };
+    }
+
+    return {
+      status: 'ok',
+      receipt: result.receipt,
+      output: result.output
+    };
+  };
+}
+
+// Example OpenClaw tool mapping:
+//
+// await tool({
+//   service: 'github',
+//   action: 'repo.contents.read',
+//   context: { repository: 'Null-Square/agent-authority' },
+//   params: { path: 'src/index.js' }
+// });

package/examples/task-lease-demo.js

@@ -0,0 +1,98 @@
+import { AuthorityRuntime } from '../src/index.js';
+import { createTaskLeaseGuard } from '../src/guard.js';
+import { createTaskLease } from '../src/task-lease.js';
+
+const mission = {
+  version: '0.1',
+  mission_id: 'mission:handle-demo-request',
+  principal: { id: 'user:demo' },
+  agent: { id: 'agent:ops-demo' },
+  objective: 'Handle one demo inquiry',
+  resources: [
+    {
+      service: 'gmail',
+      allow: ['thread.read'],
+      deny: ['email.delete'],
+      constraints: { thread: ['thread:demo-91'] }
+    },
+    {
+      service: 'calendar',
+      allow: ['event.create'],
+      deny: ['event.delete'],
+      constraints: {}
+    }
+  ],
+  constraints: { expires_at: '2099-01-01T00:00:00Z' }
+};
+
+const lease = createTaskLease({
+  mission,
+  request: 'Handle the demo request in thread:demo-91',
+  roots: [
+    { fact_id: 'fact:origin-thread', kind: 'gmail.thread', value: 'thread:demo-91' }
+  ],
+  bindings: [
+    {
+      service: 'calendar',
+      action: 'event.create',
+      context_field: 'attendee',
+      fact_id: 'fact:requester-email'
+    }
+  ]
+});
+
+const guard = createTaskLeaseGuard({ lease, runtime: new AuthorityRuntime() });
+
+console.log('1. Read only the task-authorized Gmail thread');
+const read = await guard.run({
+  service: 'gmail',
+  action: 'thread.read',
+  context: { thread: 'thread:demo-91' }
+}, async () => ({
+  sender: 'customer@example.com',
+  subject: 'Can we book a demo next week?'
+}));
+console.log(`   ALLOW -> sender discovered: ${read.output.sender}`);
+
+console.log('2. Bind discovered sender to future calendar authority');
+lease.derive({
+  fact_id: 'fact:requester-email',
+  kind: 'email.address',
+  value: read.output.sender,
+  from: ['fact:origin-thread'],
+  receipt: read.receipt,
+  selector: 'output.sender'
+});
+console.log('   derived fact -> fact:requester-email');
+
+console.log('3. Create a meeting only with that derived attendee');
+const meeting = await guard.run({
+  service: 'calendar',
+  action: 'event.create',
+  context: { attendee: 'customer@example.com' }
+}, async () => ({ event_id: 'event:724' }));
+console.log(`   ALLOW -> ${meeting.output.event_id}`);
+
+console.log('4. Try the same calendar capability for an unrelated person');
+try {
+  await guard.run({
+    service: 'calendar',
+    action: 'event.create',
+    context: { attendee: 'other@example.com' }
+  }, async () => ({ event_id: 'should-never-exist' }));
+} catch (error) {
+  console.log(`   ${error.result.decision.toUpperCase()} -> ${error.code}`);
+  console.log('   side effect did not run');
+}
+
+console.log('5. Complete the task');
+lease.complete('demo request handled');
+try {
+  await guard.run({
+    service: 'gmail',
+    action: 'thread.read',
+    context: { thread: 'thread:demo-91' }
+  }, async () => ({ sender: 'should-not-run@example.com' }));
+} catch (error) {
+  console.log(`   ${error.result.decision.toUpperCase()} -> ${error.code}`);
+}

package/examples/validation-mcp-upstream.js

@@ -0,0 +1,112 @@
+import http from 'node:http';
+import { toNodeHandler } from '@modelcontextprotocol/node';
+import { createMcpHandler, McpServer } from '@modelcontextprotocol/server';
+import { z } from 'zod';
+
+const host = process.env.VALIDATION_MCP_HOST || '127.0.0.1';
+const port = Number(process.env.VALIDATION_MCP_PORT || 8791);
+
+function createValidationServer() {
+  const server = new McpServer({
+    name: 'agent-authority-validation-upstream',
+    version: '0.1.0',
+    description: 'Tiny upstream used to validate Agent Authority with real public GitHub data.'
+  });
+
+  server.registerTool(
+    'github_repo_metadata',
+    {
+      title: 'Read public GitHub repository metadata',
+      description: 'Read public metadata for exactly one owner/repository value.',
+      inputSchema: z.object({
+        repository: z.string().regex(/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/)
+      }),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    async ({ repository }) => {
+      const response = await fetch(`https://api.github.com/repos/${repository}`, {
+        headers: {
+          accept: 'application/vnd.github+json',
+          'user-agent': 'nullsquare-agent-authority-validation'
+        }
+      });
+
+      if (!response.ok) {
+        return {
+          isError: true,
+          content: [{ type: 'text', text: `GitHub returned ${response.status}` }]
+        };
+      }
+
+      const repo = await response.json();
+      const output = {
+        full_name: repo.full_name,
+        description: repo.description,
+        visibility: repo.visibility,
+        default_branch: repo.default_branch,
+        stars: repo.stargazers_count,
+        forks: repo.forks_count,
+        open_issues: repo.open_issues_count,
+        html_url: repo.html_url
+      };
+
+      return {
+        content: [{ type: 'text', text: JSON.stringify(output, null, 2) }],
+        structuredContent: output
+      };
+    }
+  );
+
+  server.registerTool(
+    'dangerous_demo_write',
+    {
+      title: 'Validation-only fake write tool',
+      description: 'A harmless fake mutation used only to prove that Agent Authority hides and blocks write-capable tools in read-only mode.',
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: false
+      }
+    },
+    async () => ({
+      content: [{ type: 'text', text: 'This validation-only fake write tool was called.' }]
+    })
+  );
+
+  return server;
+}
+
+const handler = createMcpHandler(createValidationServer);
+const nodeHandler = toNodeHandler(handler);
+
+const httpServer = http.createServer((req, res) => {
+  const url = new URL(req.url || '/', `http://${req.headers.host || `${host}:${port}`}`);
+  if (req.method === 'GET' && url.pathname === '/health') {
+    res.writeHead(200, { 'content-type': 'application/json', 'cache-control': 'no-store' });
+    return res.end(JSON.stringify({ ok: true, service: 'agent-authority-validation-upstream' }));
+  }
+  if (url.pathname !== '/mcp') {
+    res.writeHead(404, { 'content-type': 'application/json' });
+    return res.end(JSON.stringify({ error: 'not_found' }));
+  }
+  return nodeHandler(req, res);
+});
+
+httpServer.listen(port, host, () => {
+  console.log(`Validation MCP upstream: http://${host}:${port}/mcp`);
+  console.log('Tools: github_repo_metadata (read-only), dangerous_demo_write (fake write)');
+});
+
+async function shutdown() {
+  await new Promise((resolve) => httpServer.close(resolve));
+  await handler.close();
+}
+
+process.once('SIGINT', () => shutdown().finally(() => process.exit(0)));
+process.once('SIGTERM', () => shutdown().finally(() => process.exit(0)));

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@nullsquare/agent-authority",
+  "version": "0.4.0",
+  "description": "Task-bounded authority runtime for AI agents: give agents tasks, not standing account permissions.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "private": false,
+  "keywords": [
+    "ai-agent-authorization",
+    "agent-auth",
+    "agent-security",
+    "task-scoped-authorization",
+    "least-privilege",
+    "delegated-authorization",
+    "derived-authority",
+    "oauth",
+    "mcp",
+    "model-context-protocol",
+    "credential-broker",
+    "coding-agents",
+    "llm-agents",
+    "human-in-the-loop",
+    "agent-permissions",
+    "agentic-ai-security"
+  ],
+  "bin": {
+    "agent-authority": "src/cli.js",
+    "aauth": "src/cli.js"
+  },
+  "scripts": {
+    "start": "node src/cli.js serve",
+    "setup": "node src/cli.js setup",
+    "doctor": "node src/cli.js doctor",
+    "demo": "node examples/demo.js",
+    "demo:task-lease": "node examples/task-lease-demo.js",
+    "demo:live-github": "node examples/live-github-task-lease.js",
+    "demo:live-derived-github": "node examples/live-github-derived-mutation.js",
+    "demo:mcp-upstream": "node examples/validation-mcp-upstream.js",
+    "demo:guard": "node examples/direct-guard.js",
+    "test": "node --test test/*.test.js",
+    "test:ai-sdk": "node --test test/integrations/ai-sdk.integration.mjs",
+    "test:coverage": "node --experimental-test-coverage --test test/*.test.js",
+    "check:syntax": "node --check src/index.js && node --check src/connections.js && node --check src/execution.js && node --check src/providers/github.js && node --check src/storage.js && node --check src/runtime-env.js && node --check src/sdk.js && node --check src/server.js && node --check src/cli.js && node --check src/agent-auth.js && node --check src/approvals.js && node --check src/idempotency.js && node --check src/keys.js && node --check src/harness-bridge.js && node --check src/guard.js && node --check src/task-lease.js && node --check src/mcp-gateway.js && node --check src/mcp-remote.js && node --check src/mcp-server.js && node --check src/integrations/ai-sdk.js && node --check examples/validation-mcp-upstream.js && node --check examples/direct-guard.js && node --check examples/task-lease-demo.js && node --check examples/live-github-task-lease.js && node --check examples/live-github-derived-mutation.js",
+    "check:package": "npm pack --dry-run",
+    "check": "npm run check:syntax && npm test && npm run demo:task-lease && npm run check:package"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/client": "^2.0.0",
+    "@modelcontextprotocol/node": "^2.0.0",
+    "@modelcontextprotocol/server": "^2.0.0",
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "ai": "^7.0.73"
+  },
+  "engines": { "node": ">=20" },
+  "main": "src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./agent-auth": "./src/agent-auth.js",
+    "./approvals": "./src/approvals.js",
+    "./connections": "./src/connections.js",
+    "./execution": "./src/execution.js",
+    "./guard": "./src/guard.js",
+    "./harness-bridge": "./src/harness-bridge.js",
+    "./idempotency": "./src/idempotency.js",
+    "./integrations/ai-sdk": "./src/integrations/ai-sdk.js",
+    "./mcp-gateway": "./src/mcp-gateway.js",
+    "./mcp-remote": "./src/mcp-remote.js",
+    "./mcp-server": "./src/mcp-server.js",
+    "./sdk": "./src/sdk.js",
+    "./storage": "./src/storage.js",
+    "./task-lease": "./src/task-lease.js",
+    "./providers/github": "./src/providers/github.js"
+  },
+  "files": ["src", "docs", "examples", "README.md", "LICENSE", "SECURITY.md", "ROADMAP.md", "CONTRIBUTING.md"],
+  "repository": { "type": "git", "url": "git+https://github.com/Null-Square/agent-authority.git" },
+  "bugs": { "url": "https://github.com/Null-Square/agent-authority/issues" },
+  "homepage": "https://github.com/Null-Square/agent-authority#readme"
+}