From first access to deployment.

Memory: proven consent required

Effective in the deployed brain: without a proof, the write is refused. The SDK enforces it too: without a proof, nothing is sent.

ELYSÉA writes no memory without a consent proof supplied by you, the builder. The consentToken authenticates the operation (P7); it is not consent.

What you must show — an explicit, separate memory consent text (not buried in terms and conditions), accepted by a positive action of the user.

What you must keep — the exact text shown, its version, the time of consent and the user concerned, so you can prove the consent.

What you must send — with every memory.write, a MemoryConsentProof. Every field is required and non-empty; the SDK never fills one in for you.

import { libelleSha256, ElyseaSDKError, ElyseaNetworkError, type MemoryConsentProof } from '@elysea/core';

// Your record of the consent (exact text shown, version, time)
const proof: MemoryConsentProof = {
  granted: true,
  consent_text_version: consent.version,
  libelle_sha256: libelleSha256(consent.textShown),
  consent_granted_at: consent.grantedAt,
  constructor_legal_entity: 'Your Company Ltd',
  app_id: 'your-app',
};

try {
  await elysea.memory.write(
    coreUserId,
    { type: 'preferences_communication', content: 'Short answers.', expires_at: '2027-01-01T00:00:00Z' },
    consentToken,
    proof,
  );
} catch (e) {
  if ((e instanceof ElyseaSDKError || e instanceof ElyseaNetworkError) && e.errorCode === 'CONSENT_PROOF_REQUIRED') {
    // Memory disabled for this user: do not retry without a complete proof.
  }
}

Withdrawal — as soon as the user withdraws consent, stop sending the proof (no new write is then possible) and erase items already written with memory.delete(coreUserId, itemId, consentToken). The brain does not yet expose an SDK route to withdraw the recorded consent itself.

// elysea.ts — complete ELYSEA CERVEAU integration
import { createElyseaClient, type PipelineResult } from '@elysea/core';

const elysea = createElyseaClient({
  baseUrl:     process.env.ELYSEA_BASE_URL!,
  auth: {
    apiKey:    process.env.ELYSEA_API_KEY!,
    apiSecret: process.env.ELYSEA_API_SECRET!,
  },
  appId:       process.env.ELYSEA_APP_ID!,
  countryCode: 'GB',
  region:      'EU',
});

type Message = { role: 'user' | 'assistant'; content: string };

export async function chat(
  userJwt:  string,
  message:  string,
  history:  Message[] = [],
): Promise<PipelineResult> {
  // 1. Resolve identity — never the email, never real data
  const { coreUserId } = await elysea.identity.resolve({ userJwt });

  // 2. Cognitive pipeline call — ethics applied by the pipeline, not configured
  const result = await elysea.pipeline.run({
    userInput:           message,
    coreUserId,
    conversationHistory: history,
  });

  // result.response         → canon-compliant response, ready to display
  // result.posture          → runtime posture (present_neutral, firm_safety…)
  // result.guardianAction   → 'pass'|'warn'|'block' (if block: errorCode + errorMessage)
  // result.canonConformance → true if compliant with ELYSÉA canons
  return result;
}

// Usage in your API handler:
// const result = await chat(req.headers.authorization, req.body.message, history);
// res.json({ reply: result.response });