Record and reopen an encrypted session

python -m pip install https://docs.soterias.io/downloads/api-preview/soterias_local-0.1.0rc5%2Bapi2-cp311-abi3-win_amd64.whl

npm install https://docs.soterias.io/downloads/api-preview/soterias-core-0.1.0-rc.5-api.2.tgz
npm install --save-dev typescript@5.8.3 @types/node@24

import json
from pathlib import Path
import secrets
import tempfile
from soterias import LocalSession, observe

import assert from 'node:assert/strict';
import fs from 'node:fs';
import os from 'node:os';
import path from 'node:path';
import { randomBytes } from 'node:crypto';
import { LocalSession, observe } from '@soterias/core';

# %% Observe an existing function
# The wrapper preserves the returned value. This records observations, not authority.
observed_total = observe(lambda values: sum(values))
assert observed_total([500, 1000]) == 1500
assert observed_total.last_recording_error is None

// %% Observe an existing function
// The wrapper preserves the returned value. This records observations, not authority.
const observedTotal = observe((values: number[]) => values.reduce((a, b) => a + b, 0));
assert.equal(observedTotal([500, 1000]), 1500);
assert.equal(observedTotal.lastRecordingError, null);

# %% Retain one explicit boundary in encrypted local storage
# Use a fresh random unlock for this synthetic example; keep it outside your trace.
root = Path(tempfile.mkdtemp(prefix="soterias-trace-"))
unlock = secrets.token_hex(32).encode()
with LocalSession.create(root / "trace", passphrase=unlock,
                         namespace="invoices", run_id="review-42") as session:
    event = session.record_boundary("tool_boundary", b"Invoice 42: CHF 15.00")
    session.finish()
    checkpoint = session.checkpoint()
    redacted = session.export_redacted()
    assert b"Invoice 42" not in redacted

// %% Retain one explicit boundary in encrypted local storage
// Use a fresh random unlock for this synthetic example; keep it outside your trace.
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'soterias-trace-'));
const passphrase = randomBytes(32);
const session = LocalSession.create({ path: path.join(root, 'trace'), passphrase,
  namespace: 'invoices', runId: 'review-42' });
let event: ReturnType<LocalSession['recordBoundary']>, checkpoint: Buffer, redacted: string;
try {
  event = session.recordBoundary('tool_boundary', Buffer.from('Invoice 42: CHF 15.00'));
  session.finish();
  checkpoint = session.checkpoint();
  redacted = JSON.stringify(session.exportRedacted());
  assert(!redacted.includes('Invoice 42'));
} finally { session.close(); }

# %% Reopen against the independently retained checkpoint
# Never ask the store for its newest pin and silently trust that state.
with LocalSession.open(root / "trace", passphrase=unlock,
                       checkpoint=checkpoint) as reader:
    assert reader.read_boundary(event.event_id) == b"Invoice 42: CHF 15.00"
    report = json.loads(reader.export_redacted())
    assert report["finished"]
    assert report["current_permission"] is False

print(json.dumps({"status": "PASS", "retained_boundary_verified": True,
                  "redacted_export_bytes": len(redacted)}))

// %% Reopen against the independently retained checkpoint
// Never ask the store for its newest pin and silently trust that state.
const reader = LocalSession.open({ path: path.join(root, 'trace'), passphrase, checkpoint });
try {
  assert.equal(reader.readBoundary(event.event.event_id).toString(), 'Invoice 42: CHF 15.00');
  const report = reader.exportRedacted();
  assert(report.finished);
  assert.equal(report.current_permission, false);
} finally { reader.close(); }
console.log(JSON.stringify({ status: 'PASS', retained_boundary_verified: true,
  redacted_export_bytes: Buffer.byteLength(redacted) }));

import { Soterias, observe, canonicalize, Metrics, audit, HistoricalPolicyInputs } from '@soterias/core';
import fs from 'node:fs';
import os from 'node:os';
import path from 'node:path';
import { McpServer } from '@modelcontextprotocol/server';
import { serveStdio } from '@modelcontextprotocol/server/stdio';
import * as z from 'zod/v4';

// Trusted startup: paths, trust and credentials are fixed by the host.
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'soterias-mcp-'));
const sdk = new Soterias({workflow: 'invoice-tools', directory: path.join(root, 'metrics')});
const sum = input => input.cents.reduce((a, b) => a + b, 0);
const traced = observe(sum);

// Agent input is bounded data. It cannot replace host configuration or trust.
const handle = serveStdio(() => {
  const server = new McpServer({name: 'soterias-tracing', version: '1.0.0'});
  server.registerTool('invoice_total', {
    description: 'Use tracing through the host-selected native SDK.',
    inputSchema: z.object({cents: z.array(z.number().int().min(0).max(1000000)).max(100)}).strict(),
  }, async input => {
    try {
      const result = await (async () => {
        const total = traced(input);

if (traced.lastRecordingError) throw new Error('observation_failed');
return {total_cents: total, observation_recorded: true};
      })();
      return {content: [{type: 'text', text: JSON.stringify(result, (_key, value) => typeof value === 'bigint' ? value.toString() : value)}]};
    } catch {
      return {isError: true, content: [{type: 'text', text: 'feature_request_refused'}]};
    }
  });
  return server;
}, {maxSubscriptions: 0});
process.stdin.once('end', () => {
  void (async () => { await handle.close(); await sdk.closeAsync(); })();
});

import { Client } from '@modelcontextprotocol/client';
import { StdioClientTransport } from '@modelcontextprotocol/client/stdio';
import { fileURLToPath } from 'node:url';

const client = new Client({name: 'feature-example', version: '1.0.0'});
try {
  await client.connect(new StdioClientTransport({
    command: process.execPath,
    args: [fileURLToPath(new URL('./mcp.mjs', import.meta.url))],
    env: Object.fromEntries(Object.entries(process.env).filter(([, value]) => value !== undefined)),
  }));
  const result = await client.callTool({name: 'invoice_total', arguments: {cents: [500, 1000]}});
  if (result.isError) throw new Error('Feature request refused');
  console.log(JSON.stringify(result));
} finally { await client.close(); }