@7h3/protocol 0.1.2 → 0.4.0

package/scripts/mcpGatewayCli.test.ts

@@ -0,0 +1,116 @@
+import { spawn, type ChildProcessWithoutNullStreams } from 'node:child_process'
+import { describe, expect, it } from 'vitest'
+
+interface JsonRpcEnvelope {
+  jsonrpc: '2.0'
+  id: string | number | null
+  result?: unknown
+  error?: {
+    code: number
+    message: string
+  }
+}
+
+function waitForLine(child: ChildProcessWithoutNullStreams, timeoutMs = 8_000): Promise<string> {
+  return new Promise((resolve, reject) => {
+    let buffer = ''
+    const timer = setTimeout(() => {
+      cleanup()
+      reject(new Error('Timed out waiting for gateway output'))
+    }, timeoutMs)
+
+    const onData = (chunk: Buffer) => {
+      buffer += chunk.toString('utf8')
+      const newlineIndex = buffer.indexOf('\n')
+      if (newlineIndex >= 0) {
+        const line = buffer.slice(0, newlineIndex).trim()
+        cleanup()
+        resolve(line)
+      }
+    }
+
+    const onError = (error: Error) => {
+      cleanup()
+      reject(error)
+    }
+
+    const onExit = () => {
+      cleanup()
+      reject(new Error('Gateway process exited before producing output'))
+    }
+
+    const cleanup = () => {
+      clearTimeout(timer)
+      child.stdout.off('data', onData)
+      child.off('error', onError)
+      child.off('exit', onExit)
+    }
+
+    child.stdout.on('data', onData)
+    child.on('error', onError)
+    child.on('exit', onExit)
+  })
+}
+
+function startGateway(extraEnv: Record<string, string> = {}): ChildProcessWithoutNullStreams {
+  const child = spawn('npm', ['run', '-s', 'aip:mcp:gateway'], {
+    cwd: process.cwd(),
+    env: {
+      ...process.env,
+      ...extraEnv,
+    },
+    stdio: ['pipe', 'pipe', 'pipe'],
+  })
+
+  child.stderr.on('data', () => {
+    // suppress stderr accumulation in test output
+  })
+
+  return child
+}
+
+async function stopGateway(child: ChildProcessWithoutNullStreams): Promise<void> {
+  if (child.killed) return
+  child.kill('SIGTERM')
+  await new Promise<void>((resolve) => {
+    child.once('exit', () => resolve())
+    setTimeout(() => resolve(), 2_000)
+  })
+}
+
+describe('AIP MCP gateway CLI', () => {
+  it('returns JSON-RPC result for allowed method', async () => {
+    const child = startGateway()
+    try {
+      child.stdin.write(
+        `${JSON.stringify({ jsonrpc: '2.0', id: 99, method: 'tools/call', params: { name: 'planner' } })}\n`,
+      )
+      const line = await waitForLine(child)
+      const response = JSON.parse(line) as JsonRpcEnvelope
+
+      expect(response.jsonrpc).toBe('2.0')
+      expect(response.id).toBe(99)
+      expect(response.error).toBeUndefined()
+      expect(response.result).toBeTruthy()
+    } finally {
+      await stopGateway(child)
+    }
+  })
+
+  it('returns method-not-found for disallowed method from env policy', async () => {
+    const child = startGateway({ AIP_ALLOWED_METHODS: 'tools/call' })
+    try {
+      child.stdin.write(
+        `${JSON.stringify({ jsonrpc: '2.0', id: 'abc', method: 'resources/read', params: { uri: 'file://x' } })}\n`,
+      )
+      const line = await waitForLine(child)
+      const response = JSON.parse(line) as JsonRpcEnvelope
+
+      expect(response.id).toBe('abc')
+      expect(response.result).toBeUndefined()
+      expect(response.error?.code).toBe(-32601)
+    } finally {
+      await stopGateway(child)
+    }
+  })
+})

package/scripts/prepare-aip-package.ts

@@ -0,0 +1,88 @@
+import { mkdir, readFile, writeFile, copyFile, readdir } from 'node:fs/promises'
+import process from 'node:process'
+
+interface RootPackageJson {
+  version?: string
+}
+
+function parseVersionArg(argv: string[]): string | undefined {
+  const idx = argv.indexOf('--version')
+  if (idx < 0) return undefined
+  return argv[idx + 1]
+}
+
+async function readRootVersion(): Promise<string> {
+  const raw = await readFile('package.json', 'utf8')
+  const parsed = JSON.parse(raw) as RootPackageJson
+  return parsed.version ?? '0.0.0'
+}
+
+async function main(): Promise<void> {
+  const version = parseVersionArg(process.argv) ?? (await readRootVersion())
+  const outDir = 'dist/npm-protocol'
+
+  await mkdir(outDir, { recursive: true })
+  await copyFile('dist/protocol/index.js', `${outDir}/index.js`)
+
+  // Copy all .d.ts files — index.d.ts re-exports from the individual module files,
+  // so all of them must be present for TypeScript consumers to resolve types.
+  const distFiles = await readdir('dist/protocol')
+  for (const file of distFiles) {
+    if (file.endsWith('.d.ts')) {
+      await copyFile(`dist/protocol/${file}`, `${outDir}/${file}`)
+    }
+  }
+
+  const packageJson = {
+    name: '@7h3/protocol',
+    version,
+    description: '7h3 Protocol: deterministic, signed, replay-safe AI-to-AI message envelopes (wire 7h3/0.1).',
+    type: 'module',
+    main: './index.js',
+    types: './index.d.ts',
+    exports: {
+      '.': {
+        import: './index.js',
+        types: './index.d.ts',
+      },
+    },
+    files: ['index.js', '*.d.ts', 'README.md'],
+    license: 'MIT',
+    repository: {
+      type: 'git',
+      url: 'https://github.com/IceMasterT/7h3-protocol-aip.git',
+    },
+  }
+
+  const readme = [
+    '# @7h3/protocol',
+    '',
+    '7h3 Protocol (wire version `7h3/0.1`):',
+    'deterministic, signed, replay-safe AI-to-AI message envelopes.',
+    '',
+    'Install:',
+    '',
+    '```bash',
+    'npm install @7h3/protocol',
+    '```',
+    '',
+    'Import:',
+    '',
+    '```ts',
+    "import { createAipAgentAdapter, receiveEnvelope } from '@7h3/protocol'",
+    '```',
+    '',
+  ].join('\n')
+
+  await writeFile(`${outDir}/package.json`, `${JSON.stringify(packageJson, null, 2)}\n`, 'utf8')
+  await writeFile(`${outDir}/README.md`, readme, 'utf8')
+
+  console.log(`Prepared publishable package in ${outDir}`)
+  console.log(`Version: ${version}`)
+}
+
+main().catch((error: unknown) => {
+  const message = error instanceof Error ? error.stack ?? error.message : String(error)
+  console.error(message)
+  process.exitCode = 1
+})

package/scripts/regen-conformance-sigs.ts

@@ -0,0 +1,18 @@
+import { signCanonicalPayloadHmac, signCanonicalPayloadEd25519 } from '../src/protocol'
+import { AIP_V01_CONFORMANCE_VECTORS, AIP_V01_ED25519_CONFORMANCE_VECTORS } from '../src/conformanceVectors'
+
+async function main() {
+  console.log('=== HMAC vectors ===')
+  for (const v of AIP_V01_CONFORMANCE_VECTORS) {
+    const sig = await signCanonicalPayloadHmac(v.canonical, v.secret)
+    console.log(`${v.id}: '${sig}'`)
+  }
+
+  console.log('\n=== Ed25519 vectors ===')
+  for (const v of AIP_V01_ED25519_CONFORMANCE_VECTORS) {
+    const sig = await signCanonicalPayloadEd25519(v.canonical, v.privateKey)
+    console.log(`${v.id}: '${sig}'`)
+  }
+}
+
+main().catch(e => { console.error(e); process.exit(1) })

package/scripts/release-gate.ts

@@ -0,0 +1,19 @@
+import { spawnSync } from 'node:child_process'
+
+const commands: Array<[string, string[]]> = [
+  ['npm', ['run', 'policy:validate']],
+  ['npm', ['run', 'test']],
+  ['npm', ['run', 'build:protocol']],
+  ['npm', ['run', 'lint']],
+  ['npm', ['run', 'bench:wire:quick']],
+  ['npm', ['run', 'bench:openloop:adaptive:ci']],
+]
+
+for (const [command, args] of commands) {
+  console.log(`\n$ ${command} ${args.join(' ')}`)
+  const result = spawnSync(command, args, { stdio: 'inherit', shell: false })
+  if (result.status !== 0) {
+    process.exitCode = result.status ?? 1
+    break
+  }
+}

package/scripts/validate-runtime-policy.ts

@@ -0,0 +1,18 @@
+import { readFile } from 'node:fs/promises'
+import { parseRuntimePolicyJson } from '../src/runtimePolicy'
+
+async function main(): Promise<void> {
+  const path = process.argv[2] ?? 'AI_RUNTIME_POLICY.json'
+  const text = await readFile(path, 'utf8')
+  const policy = parseRuntimePolicyJson(text)
+  if (!policy.hard_invariants || !policy.slo_defaults || !policy.tuning) {
+    throw new Error('Runtime policy is missing one or more required sections: hard_invariants, slo_defaults, tuning')
+  }
+  console.log(`Runtime policy validated: ${policy.name}@${policy.version} (${policy.status})`)
+}
+
+main().catch((error: unknown) => {
+  const message = error instanceof Error ? error.stack ?? error.message : String(error)
+  console.error(message)
+  process.exitCode = 1
+})

package/sdk/browser/index.test.ts

@@ -0,0 +1,162 @@
+import { describe, it, expect } from 'vitest'
+import {
+  generateKeypair,
+  canonicalizeEnvelope,
+  createEnvelope,
+  signEnvelope,
+  verifyEnvelope,
+  signRequest,
+  isEnvelopeExpired,
+  ENVELOPE_HEADER,
+  WIRE_VERSION,
+  type BrowserEnvelopeHeader,
+  type BrowserEnvelopeBody,
+} from './index.ts'
+
+describe('Browser SDK', () => {
+  // Test 1: generateKeypair produces non-empty strings
+  it('generateKeypair produces non-empty strings', async () => {
+    const kp = await generateKeypair()
+    expect(typeof kp.publicKey).toBe('string')
+    expect(kp.publicKey.length).toBeGreaterThan(0)
+    expect(typeof kp.privateKey).toBe('string')
+    expect(kp.privateKey.length).toBeGreaterThan(0)
+  })
+
+  // Test 2: canonicalizeEnvelope matches exact conformance vector
+  it('canonicalizeEnvelope matches conformance vector', () => {
+    const header: BrowserEnvelopeHeader = {
+      version: '7h3/0.1',
+      messageId: 'vec-1',
+      nonce: 'nonce-vec-1',
+      sender: 'agent.alpha',
+      recipient: 'agent.beta',
+      timestampMs: 1712500000000,
+      ttlMs: 60000,
+    }
+    const body: BrowserEnvelopeBody = {
+      intent: 'TASK',
+      content: 'route:alpha->beta',
+      capability: 'task.plan',
+      correlationId: 'corr-1',
+    }
+    const expected =
+      '{"body":{"capability":"task.plan","content":"route:alpha->beta","correlationId":"corr-1","intent":"TASK"},"header":{"messageId":"vec-1","nonce":"nonce-vec-1","recipient":"agent.beta","sender":"agent.alpha","timestampMs":1712500000000,"ttlMs":60000,"version":"7h3/0.1"}}'
+    expect(canonicalizeEnvelope({ header, body })).toBe(expected)
+  })
+
+  // Test 3: canonicalizeEnvelope with no optional fields
+  it('canonicalizeEnvelope omits undefined optional fields', () => {
+    const header: BrowserEnvelopeHeader = {
+      version: '7h3/0.1',
+      messageId: 'msg-1',
+      nonce: 'n1',
+      sender: 'agent.x',
+      timestampMs: 1712500000000,
+      ttlMs: 30000,
+    }
+    const body: BrowserEnvelopeBody = {
+      intent: 'PING',
+      content: 'hello',
+    }
+    const result = canonicalizeEnvelope({ header, body })
+    const parsed = JSON.parse(result)
+    expect(parsed.header.recipient).toBeUndefined()
+    expect(parsed.body.capability).toBeUndefined()
+    expect(parsed.body.correlationId).toBeUndefined()
+    // Verify the raw string doesn't include those keys
+    expect(result).not.toContain('"recipient"')
+    expect(result).not.toContain('"capability"')
+    expect(result).not.toContain('"correlationId"')
+  })
+
+  // Test 4: createEnvelope produces correct structure
+  it('createEnvelope produces correct structure', () => {
+    const env = createEnvelope({
+      sender: 'agent.test',
+      body: { intent: 'TASK', content: 'do work' },
+    })
+    expect(env.header.version).toBe(WIRE_VERSION)
+    expect(typeof env.header.messageId).toBe('string')
+    expect(env.header.messageId.length).toBeGreaterThan(0)
+    expect(env.body.intent).toBe('TASK')
+    expect(env.header.sender).toBe('agent.test')
+    expect(env.header.ttlMs).toBe(60_000)
+  })
+
+  // Test 5: signEnvelope + verifyEnvelope round trip
+  it('signEnvelope + verifyEnvelope round trip', async () => {
+    const kp = await generateKeypair()
+    const env = createEnvelope({
+      sender: 'agent.a',
+      body: { intent: 'PING', content: 'test' },
+    })
+    const signed = await signEnvelope(env, kp.privateKey)
+    expect(signed.signature).toBeDefined()
+    expect(signed.signature?.alg).toBe('ED25519')
+    const valid = await verifyEnvelope(signed, kp.publicKey)
+    expect(valid).toBe(true)
+  })
+
+  // Test 6: verifyEnvelope: tampered body returns false
+  it('verifyEnvelope: tampered body returns false', async () => {
+    const kp = await generateKeypair()
+    const env = createEnvelope({
+      sender: 'agent.a',
+      body: { intent: 'PING', content: 'original' },
+    })
+    const signed = await signEnvelope(env, kp.privateKey)
+    const tampered = {
+      ...signed,
+      body: { ...signed.body, content: 'tampered' },
+    }
+    const valid = await verifyEnvelope(tampered, kp.publicKey)
+    expect(valid).toBe(false)
+  })
+
+  // Test 7: verifyEnvelope: wrong key returns false
+  it('verifyEnvelope: wrong key returns false', async () => {
+    const kp1 = await generateKeypair()
+    const kp2 = await generateKeypair()
+    const env = createEnvelope({
+      sender: 'agent.a',
+      body: { intent: 'PING', content: 'test' },
+    })
+    const signed = await signEnvelope(env, kp1.privateKey)
+    const valid = await verifyEnvelope(signed, kp2.publicKey)
+    expect(valid).toBe(false)
+  })
+
+  // Test 8: signRequest: produces Request with x-7h3-envelope header set
+  it('signRequest: produces Request with x-7h3-envelope header', async () => {
+    const kp = await generateKeypair()
+    const req = new Request('https://example.com/api')
+    const signed = await signRequest(req, {
+      sender: 'agent.client',
+      privateKey: kp.privateKey,
+    })
+    const headerVal = signed.headers.get(ENVELOPE_HEADER)
+    expect(headerVal).not.toBeNull()
+    expect(typeof headerVal).toBe('string')
+    const parsed = JSON.parse(headerVal!)
+    expect(parsed.signature).toBeDefined()
+    expect(parsed.header.sender).toBe('agent.client')
+  })
+
+  // Test 9: isEnvelopeExpired: returns true for past timestamp
+  it('isEnvelopeExpired: returns true for past timestamp', () => {
+    const past = Date.now() - 120_000
+    const env = {
+      header: {
+        version: '7h3/0.1' as const,
+        messageId: 'x',
+        nonce: 'y',
+        sender: 'agent.z',
+        timestampMs: past,
+        ttlMs: 60_000,
+      },
+      body: { intent: 'PING' as const, content: 'old' },
+    }
+    expect(isEnvelopeExpired(env)).toBe(true)
+  })
+})

package/sdk/browser/index.ts

@@ -0,0 +1,257 @@
+// 7h3 Protocol - Browser/Edge SDK
+// Pure Web Crypto API. Zero dependencies.
+// Works in browsers, Deno, Cloudflare Workers, Bun, and Node 20+.
+
+export const WIRE_VERSION = '7h3/0.1'
+export const ENVELOPE_HEADER = 'x-7h3-envelope'
+export const RESPONSE_HEADER = 'x-7h3-response'
+
+export type IntentKind = 'PING' | 'PONG' | 'CAPS' | 'TASK' | 'RESULT' | 'ERROR'
+
+export interface BrowserEnvelopeHeader {
+  version: typeof WIRE_VERSION
+  messageId: string
+  timestampMs: number
+  ttlMs: number
+  sender: string
+  recipient?: string
+  nonce: string
+}
+
+export interface BrowserEnvelopeBody {
+  intent: IntentKind
+  content: string
+  capability?: string
+  correlationId?: string
+}
+
+export interface BrowserSignature {
+  alg: 'ED25519'
+  keyId: string
+  value: string
+}
+
+export interface BrowserEnvelope {
+  header: BrowserEnvelopeHeader
+  body: BrowserEnvelopeBody
+  signature?: BrowserSignature
+}
+
+export interface BrowserKeyPair {
+  publicKey: string  // base64url SPKI, no padding
+  privateKey: string // base64url PKCS8, no padding
+}
+
+// ─── Internal helpers (NOT exported) ─────────────────────────────────────────
+
+function toBase64Url(buf: ArrayBuffer | Uint8Array): string {
+  const bytes = buf instanceof Uint8Array ? buf : new Uint8Array(buf)
+  let binary = ''
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i])
+  }
+  return btoa(binary)
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_')
+    .replace(/=+$/g, '')
+}
+
+function fromBase64Url(str: string): Uint8Array {
+  const padded = str
+    .replace(/-/g, '+')
+    .replace(/_/g, '/')
+    .padEnd(Math.ceil(str.length / 4) * 4, '=')
+  const binary = atob(padded)
+  const bytes = new Uint8Array(binary.length)
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i)
+  }
+  return bytes
+}
+
+function generateNonce(): string {
+  const bytes = new Uint8Array(16)
+  crypto.getRandomValues(bytes)
+  return toBase64Url(bytes)
+}
+
+function canonicalBody(b: BrowserEnvelopeBody): string {
+  const parts: string[] = []
+  if (b.capability !== undefined) {
+    parts.push(`"capability":${JSON.stringify(b.capability)}`)
+  }
+  parts.push(`"content":${JSON.stringify(b.content)}`)
+  if (b.correlationId !== undefined) {
+    parts.push(`"correlationId":${JSON.stringify(b.correlationId)}`)
+  }
+  parts.push(`"intent":${JSON.stringify(b.intent)}`)
+  return `{${parts.join(',')}}`
+}
+
+function canonicalHeader(h: BrowserEnvelopeHeader): string {
+  const parts: string[] = [
+    `"messageId":${JSON.stringify(h.messageId)}`,
+    `"nonce":${JSON.stringify(h.nonce)}`,
+  ]
+  if (h.recipient !== undefined) {
+    parts.push(`"recipient":${JSON.stringify(h.recipient)}`)
+  }
+  parts.push(`"sender":${JSON.stringify(h.sender)}`)
+  parts.push(`"timestampMs":${h.timestampMs}`)
+  parts.push(`"ttlMs":${h.ttlMs}`)
+  parts.push(`"version":${JSON.stringify(h.version)}`)
+  return `{${parts.join(',')}}`
+}
+
+// ─── Public API ───────────────────────────────────────────────────────────────
+
+export function canonicalizeEnvelope(envelope: Omit<BrowserEnvelope, 'signature'>): string {
+  return `{"body":${canonicalBody(envelope.body)},"header":${canonicalHeader(envelope.header)}}`
+}
+
+export async function generateKeypair(): Promise<BrowserKeyPair> {
+  const pair = await crypto.subtle.generateKey(
+    { name: 'Ed25519' } as AlgorithmIdentifier,
+    true,
+    ['sign', 'verify'],
+  ) as CryptoKeyPair
+
+  const privateKeyRaw = await crypto.subtle.exportKey('pkcs8', pair.privateKey)
+  const publicKeyRaw = await crypto.subtle.exportKey('spki', pair.publicKey)
+
+  return {
+    publicKey: toBase64Url(publicKeyRaw),
+    privateKey: toBase64Url(privateKeyRaw),
+  }
+}
+
+export async function signEnvelope(
+  envelope: Omit<BrowserEnvelope, 'signature'>,
+  privateKeyPkcs8Base64Url: string,
+  keyId?: string,
+): Promise<BrowserEnvelope> {
+  const der = fromBase64Url(privateKeyPkcs8Base64Url)
+  const cryptoKey = await crypto.subtle.importKey(
+    'pkcs8',
+    der.buffer.slice(der.byteOffset, der.byteOffset + der.byteLength) as ArrayBuffer,
+    { name: 'Ed25519' } as AlgorithmIdentifier,
+    false,
+    ['sign'],
+  )
+
+  const payload = canonicalizeEnvelope(envelope)
+  const sigBuffer = await crypto.subtle.sign(
+    'Ed25519',
+    cryptoKey,
+    new TextEncoder().encode(payload),
+  )
+
+  return {
+    ...envelope,
+    signature: {
+      alg: 'ED25519',
+      keyId: keyId ?? generateNonce().slice(0, 16),
+      value: toBase64Url(sigBuffer),
+    },
+  }
+}
+
+export async function verifyEnvelope(
+  envelope: BrowserEnvelope,
+  publicKeySpkiBase64Url: string,
+): Promise<boolean> {
+  if (!envelope.signature) return false
+  if (envelope.signature.alg !== 'ED25519') return false
+
+  const der = fromBase64Url(publicKeySpkiBase64Url)
+  const cryptoKey = await crypto.subtle.importKey(
+    'spki',
+    der.buffer.slice(der.byteOffset, der.byteOffset + der.byteLength) as ArrayBuffer,
+    { name: 'Ed25519' } as AlgorithmIdentifier,
+    false,
+    ['verify'],
+  )
+
+  const unsigned: Omit<BrowserEnvelope, 'signature'> = {
+    header: envelope.header,
+    body: envelope.body,
+  }
+  const payload = canonicalizeEnvelope(unsigned)
+  const sigBytes = fromBase64Url(envelope.signature.value)
+
+  return crypto.subtle.verify(
+    'Ed25519',
+    cryptoKey,
+    sigBytes.buffer.slice(sigBytes.byteOffset, sigBytes.byteOffset + sigBytes.byteLength) as ArrayBuffer,
+    new TextEncoder().encode(payload),
+  )
+}
+
+export function createEnvelope(opts: {
+  sender: string
+  recipient?: string
+  ttlMs?: number
+  body: BrowserEnvelopeBody
+}): Omit<BrowserEnvelope, 'signature'> {
+  return {
+    header: {
+      version: WIRE_VERSION,
+      messageId: generateNonce(),
+      timestampMs: Date.now(),
+      ttlMs: opts.ttlMs ?? 60_000,
+      sender: opts.sender,
+      recipient: opts.recipient,
+      nonce: generateNonce(),
+    },
+    body: opts.body,
+  }
+}
+
+export async function signRequest(
+  request: Request,
+  opts: {
+    sender: string
+    recipient?: string
+    ttlMs?: number
+    privateKey: string
+    keyId?: string
+  },
+): Promise<Request> {
+  const envelope = createEnvelope({
+    sender: opts.sender,
+    recipient: opts.recipient,
+    ttlMs: opts.ttlMs,
+    body: {
+      intent: 'TASK',
+      content: request.url,
+    },
+  })
+
+  const signed = await signEnvelope(envelope, opts.privateKey, opts.keyId)
+
+  const headers = new Headers(request.headers)
+  headers.set(ENVELOPE_HEADER, JSON.stringify(signed))
+
+  return new Request(request, { headers })
+}
+
+export async function verifyResponseHeader(
+  response: Response,
+  publicKey: string,
+): Promise<boolean> {
+  const headerValue = response.headers.get(RESPONSE_HEADER)
+  if (!headerValue) return false
+
+  let parsed: BrowserEnvelope
+  try {
+    parsed = JSON.parse(headerValue) as BrowserEnvelope
+  } catch {
+    return false
+  }
+
+  return verifyEnvelope(parsed, publicKey)
+}
+
+export function isEnvelopeExpired(envelope: BrowserEnvelope): boolean {
+  return envelope.header.timestampMs + envelope.header.ttlMs < Date.now()
+}

package/sdk/browser/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@7h3/protocol-browser",
+  "version": "0.4.0",
+  "description": "7h3 Protocol - Browser/Edge SDK. Pure Web Crypto API. Zero dependencies.",
+  "type": "module",
+  "main": "./index.js",
+  "module": "./index.js",
+  "types": "./index.d.ts",
+  "exports": { ".": { "types": "./index.d.ts", "import": "./index.js" } },
+  "keywords": ["7h3","protocol","browser","webcrypto","ed25519","signing","mcp"],
+  "license": "MIT",
+  "sideEffects": false
+}

package/sdk/go/go.mod

@@ -0,0 +1,3 @@
+module github.com/IceMasterT/7h3-protocol/sdk/go
+
+go 1.21