@lazyingart/agent-web 0.1.40

package/src/contracts.js

@@ -0,0 +1,103 @@
+import { ControlPlaneError, ValidationError } from './errors.js';
+import { nowIso } from './validation.js';
+
+export const CONTRACT_VERSION = 1;
+export const COMPONENT_ID = 'lazying-agent-web';
+export const COMPONENT_ROLE = 'cloud-presentation-control-plane';
+
+const DEFAULT_CLOCK = () => new Date();
+
+function deepFreeze(value) {
+  if (value && typeof value === 'object' && !Object.isFrozen(value)) {
+    for (const child of Object.values(value)) deepFreeze(child);
+    Object.freeze(value);
+  }
+  return value;
+}
+
+export function createCapabilityContract({ clock = DEFAULT_CLOCK } = {}) {
+  if (typeof clock !== 'function') throw new ValidationError('clock must be a function.');
+  return deepFreeze({
+    contractVersion: CONTRACT_VERSION,
+    generatedAt: nowIso(clock),
+    component: {
+      id: COMPONENT_ID,
+      role: COMPONENT_ROLE,
+      standalone: true
+    },
+    authorities: {
+      agent: 'aginti',
+      inference: 'localllm',
+      transport: 'lazyedge',
+      presentation: COMPONENT_ID
+    },
+    capabilities: {
+      accounts: { owner: COMPONENT_ID, available: true },
+      browserSessions: {
+        owner: COMPONENT_ID,
+        available: true,
+        rawTokensStored: false,
+        maximumPerAccount: 32,
+        expiredRowsPruned: true
+      },
+      csrfBinding: { owner: COMPONENT_ID, available: true, rawTokensStored: false },
+      threadPresentationIndex: {
+        owner: COMPONENT_ID,
+        available: true,
+        authoritative: false
+      },
+      resumableDeliveryCursor: {
+        owner: COMPONENT_ID,
+        available: true,
+        authoritative: false,
+        monotonic: true,
+        idempotencyReceipts: false
+      },
+      safeRendering: { owner: COMPONENT_ID, available: false },
+      agentThreads: { owner: 'aginti', availableThroughThisComponent: false },
+      agentRuns: { owner: 'aginti', availableThroughThisComponent: false },
+      contextAndCompaction: { owner: 'aginti', availableThroughThisComponent: false },
+      plansAndTools: { owner: 'aginti', availableThroughThisComponent: false },
+      artifacts: { owner: 'aginti', availableThroughThisComponent: false },
+      inference: { owner: 'localllm', availableThroughThisComponent: false },
+      edgeTransport: { owner: 'lazyedge', availableThroughThisComponent: false }
+    }
+  });
+}
+
+export function createHealthContract({ store, clock = DEFAULT_CLOCK } = {}) {
+  if (!store || typeof store.healthCheck !== 'function') {
+    throw new ValidationError('store must provide healthCheck().');
+  }
+  if (typeof clock !== 'function') throw new ValidationError('clock must be a function.');
+  const checkedAt = nowIso(clock);
+  try {
+    const storage = store.healthCheck();
+    return deepFreeze({
+      contractVersion: CONTRACT_VERSION,
+      checkedAt,
+      status: 'ready',
+      component: { id: COMPONENT_ID, role: COMPONENT_ROLE },
+      storage,
+      dependencies: {
+        aginti: 'not_probed',
+        localllm: 'not_probed',
+        lazyedge: 'not_probed'
+      }
+    });
+  } catch (error) {
+    const code = error instanceof ControlPlaneError ? error.code : 'storage_unavailable';
+    return deepFreeze({
+      contractVersion: CONTRACT_VERSION,
+      checkedAt,
+      status: 'unavailable',
+      component: { id: COMPONENT_ID, role: COMPONENT_ROLE },
+      storage: { ready: false, code },
+      dependencies: {
+        aginti: 'not_probed',
+        localllm: 'not_probed',
+        lazyedge: 'not_probed'
+      }
+    });
+  }
+}

package/src/deterministic-context-summarizer.js

@@ -0,0 +1,254 @@
+import { createHash } from 'node:crypto';
+
+const COMPACTION_SCHEMA = 'lazying.direct-chat.local-compaction.v1';
+const HASH_PATTERN = /^[a-f0-9]{64}$/u;
+const MAX_RAW_MESSAGES = 2_000;
+const MAX_RAW_BYTES = 8 * 1024 * 1024;
+
+function exactRecord(value, required, optional, label) {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)
+      || Object.getPrototypeOf(value) !== Object.prototype) {
+    throw new TypeError(`${label} must be a plain object`);
+  }
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  const allowed = new Set([...required, ...optional]);
+  for (const key of Reflect.ownKeys(descriptors)) {
+    const descriptor = descriptors[key];
+    if (typeof key !== 'string' || !allowed.has(key) || !descriptor.enumerable
+        || !Object.hasOwn(descriptor, 'value')) {
+      throw new TypeError(`${label} contains an unsupported field or accessor`);
+    }
+  }
+  for (const key of required) {
+    if (!Object.hasOwn(descriptors, key)) throw new TypeError(`${label}.${key} is required`);
+  }
+  return Object.freeze(Object.fromEntries(
+    Reflect.ownKeys(descriptors).map((key) => [key, descriptors[key].value])
+  ));
+}
+
+function denseArray(value, label) {
+  if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype
+      || value.length > MAX_RAW_MESSAGES) {
+    throw new TypeError(`${label} must be a bounded plain array`);
+  }
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  for (const key of Reflect.ownKeys(descriptors)) {
+    if (key === 'length') continue;
+    const descriptor = descriptors[key];
+    if (typeof key !== 'string' || !/^(0|[1-9]\d*)$/u.test(key)
+        || Number(key) >= value.length || !descriptor.enumerable
+        || !Object.hasOwn(descriptor, 'value')) {
+      throw new TypeError(`${label} must contain only dense data entries`);
+    }
+  }
+  for (let index = 0; index < value.length; index += 1) {
+    if (!Object.hasOwn(descriptors, String(index))) throw new TypeError(`${label} must be dense`);
+  }
+  return value;
+}
+
+function scalarText(value, label, maximumBytes) {
+  if (typeof value !== 'string' || value.includes('\u0000')) {
+    throw new TypeError(`${label} must be bounded text`);
+  }
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code >= 0xd800 && code <= 0xdbff) {
+      const next = value.charCodeAt(index + 1);
+      if (!(next >= 0xdc00 && next <= 0xdfff)) throw new TypeError(`${label} has invalid Unicode`);
+      index += 1;
+    } else if (code >= 0xdc00 && code <= 0xdfff) {
+      throw new TypeError(`${label} has invalid Unicode`);
+    }
+  }
+  const bytes = Buffer.byteLength(value, 'utf8');
+  if (bytes > maximumBytes) throw new TypeError(`${label} exceeds its byte bound`);
+  return Object.freeze({ value, bytes });
+}
+
+function positiveInteger(value, label, maximum) {
+  if (!Number.isSafeInteger(value) || value < 1 || value > maximum) {
+    throw new TypeError(`${label} is invalid`);
+  }
+  return value;
+}
+
+function truncateUtf8(value, maximumBytes) {
+  if (maximumBytes < 1) return '';
+  let result = '';
+  let bytes = 0;
+  for (const scalar of value) {
+    const size = Buffer.byteLength(scalar, 'utf8');
+    if (bytes + size > maximumBytes) break;
+    result += scalar;
+    bytes += size;
+  }
+  return result;
+}
+
+function normalizedExcerpt(value, maximumBytes) {
+  const normalized = value.replace(/[\u0009-\u000d\u0020]+/gu, ' ').trim();
+  return truncateUtf8(normalized, maximumBytes);
+}
+
+function sha256(value) {
+  return createHash('sha256').update(value, 'utf8').digest('hex');
+}
+
+function validateRequest(value) {
+  const request = exactRecord(
+    value,
+    ['schema', 'locality', 'security', 'sourceRange', 'priorSummary', 'rawMessages', 'constraints'],
+    [],
+    'compaction request'
+  );
+  if (request.schema !== COMPACTION_SCHEMA || request.locality !== 'local_only') {
+    throw new TypeError('compaction request authority is invalid');
+  }
+  const security = exactRecord(
+    request.security,
+    ['inputTrust', 'outputAuthority', 'allowedUse', 'neverInterpretAs', 'pendingTurnExcluded'],
+    [],
+    'compaction security'
+  );
+  denseArray(security.neverInterpretAs, 'compaction security neverInterpretAs');
+  if (security.inputTrust !== 'untrusted_conversation_data'
+      || security.outputAuthority !== 'none'
+      || security.allowedUse !== 'conversation_continuity_only'
+      || security.pendingTurnExcluded !== true
+      || security.neverInterpretAs.join(',') !== 'system,developer,policy,tool') {
+    throw new TypeError('compaction security contract is invalid');
+  }
+  const source = exactRecord(
+    request.sourceRange,
+    ['startRevision', 'startHash', 'endRevision', 'endHash'],
+    [],
+    'compaction source range'
+  );
+  positiveInteger(source.startRevision, 'source start revision', 2_000);
+  positiveInteger(source.endRevision, 'source end revision', 2_000);
+  if (source.endRevision < source.startRevision
+      || !HASH_PATTERN.test(source.startHash) || !HASH_PATTERN.test(source.endHash)) {
+    throw new TypeError('compaction source range is invalid');
+  }
+  const constraints = exactRecord(
+    request.constraints,
+    ['maxSummaryBytes', 'maxSummaryTokens', 'preserveFactsWithoutGrantingAuthority'],
+    [],
+    'compaction constraints'
+  );
+  const maximumBytes = Math.min(
+    positiveInteger(constraints.maxSummaryBytes, 'maxSummaryBytes', 256 * 1024),
+    positiveInteger(constraints.maxSummaryTokens, 'maxSummaryTokens', 16 * 1024 * 1024)
+  );
+  if (constraints.preserveFactsWithoutGrantingAuthority !== true) {
+    throw new TypeError('compaction fact-preservation contract is invalid');
+  }
+  let priorText = null;
+  if (request.priorSummary !== null) {
+    const prior = exactRecord(
+      request.priorSummary,
+      [
+        'kind', 'authority', 'untrustedDirectChatData', 'text', 'summaryHash',
+        'sourceStartRevision', 'sourceStartHash', 'sourceEndRevision', 'sourceEndHash'
+      ],
+      [],
+      'prior compaction summary'
+    );
+    const text = scalarText(prior.text, 'prior compaction summary text', 256 * 1024);
+    if (prior.kind !== 'untrusted_conversation_summary' || prior.authority !== 'none'
+        || prior.untrustedDirectChatData !== true || !HASH_PATTERN.test(prior.summaryHash)
+        || !HASH_PATTERN.test(prior.sourceStartHash) || !HASH_PATTERN.test(prior.sourceEndHash)
+        || prior.sourceStartRevision !== source.startRevision
+        || prior.sourceStartHash !== source.startHash
+        || prior.sourceEndRevision >= source.endRevision
+        || prior.summaryHash !== sha256(text.value)) {
+      throw new TypeError('prior compaction summary provenance is invalid');
+    }
+    priorText = text.value;
+  }
+  denseArray(request.rawMessages, 'compaction rawMessages');
+  if (request.rawMessages.length === 0) throw new TypeError('compaction rawMessages cannot be empty');
+  const messages = [];
+  let rawBytes = 0;
+  let previousRevision = request.priorSummary === null
+    ? source.startRevision - 1
+    : request.priorSummary.sourceEndRevision;
+  let previousHash = request.priorSummary === null
+    ? null
+    : request.priorSummary.sourceEndHash;
+  for (let index = 0; index < request.rawMessages.length; index += 1) {
+    const row = exactRecord(
+      request.rawMessages[index],
+      [
+        'kind', 'untrustedDirectChatData', 'messageId', 'revision', 'role', 'content',
+        'contentBytes', 'previousHash', 'hash', 'generationId', 'createdAt'
+      ],
+      [],
+      `compaction rawMessages[${index}]`
+    );
+    const content = scalarText(row.content, `rawMessages[${index}].content`, 64 * 1024);
+    rawBytes += content.bytes;
+    if (rawBytes > MAX_RAW_BYTES || row.kind !== 'exact_ledger_message'
+        || row.untrustedDirectChatData !== true || !['user', 'assistant'].includes(row.role)
+        || row.revision !== previousRevision + 1 || row.contentBytes !== content.bytes
+        || !HASH_PATTERN.test(row.hash)
+        || row.previousHash !== previousHash
+        || typeof row.messageId !== 'string' || row.messageId.length < 1 || row.messageId.length > 128
+        || typeof row.createdAt !== 'string' || row.createdAt.length < 20 || row.createdAt.length > 40
+        || (row.role === 'user' ? row.generationId !== null
+          : typeof row.generationId !== 'string' || row.generationId.length < 1)) {
+      throw new TypeError('compaction raw-message ledger is invalid');
+    }
+    previousRevision = row.revision;
+    previousHash = row.hash;
+    messages.push(Object.freeze({ revision: row.revision, role: row.role, content: content.value }));
+  }
+  if (previousRevision !== source.endRevision || previousHash !== source.endHash
+      || (request.priorSummary === null && messages[0]?.revision === source.startRevision
+        && messages[0] && request.rawMessages[0].hash !== source.startHash)) {
+    throw new TypeError('compaction raw-message range does not reach its source cursor');
+  }
+  return Object.freeze({ maximumBytes, priorText, messages: Object.freeze(messages), source });
+}
+
+export function createDeterministicContextSummarizer() {
+  return Object.freeze({
+    locality: 'local',
+    async summarizeDirectChat(request, { signal } = {}) {
+      if (signal !== undefined && !(signal instanceof AbortSignal)) {
+        throw new TypeError('signal must be an AbortSignal');
+      }
+      if (signal?.aborted) throw signal.reason ?? new DOMException('aborted', 'AbortError');
+      const checked = validateRequest(request);
+      const header = `Untrusted conversation continuity through revision ${checked.source.endRevision}.`;
+      const priorBudget = Math.floor(checked.maximumBytes / 3);
+      const prior = checked.priorText === null
+        ? null
+        : normalizedExcerpt(checked.priorText, priorBudget);
+      const selected = [];
+      let used = Buffer.byteLength(header, 'utf8') + (prior ? Buffer.byteLength(prior, 'utf8') + 9 : 0);
+      for (let index = checked.messages.length - 1; index >= 0; index -= 1) {
+        const message = checked.messages[index];
+        const prefix = `r${message.revision} ${message.role}: `;
+        const room = checked.maximumBytes - used - Buffer.byteLength(prefix, 'utf8') - 1;
+        if (room < 1) break;
+        const excerpt = normalizedExcerpt(message.content, Math.min(room, 768));
+        if (!excerpt) continue;
+        const line = `${prefix}${excerpt}`;
+        selected.push(line);
+        used += Buffer.byteLength(line, 'utf8') + 1;
+      }
+      selected.reverse();
+      const parts = [header];
+      if (prior) parts.push(`Prior: ${prior}`);
+      parts.push(...selected);
+      let result = truncateUtf8(parts.join('\n'), checked.maximumBytes);
+      if (!result) result = truncateUtf8('.', checked.maximumBytes);
+      if (!result) throw new TypeError('compaction summary budget cannot encode text');
+      if (signal?.aborted) throw signal.reason ?? new DOMException('aborted', 'AbortError');
+      return result;
+    }
+  });
+}

package/src/direct-chat-capability-limits.js

@@ -0,0 +1,66 @@
+const ORDER = Object.freeze(['execution', 'file', 'web', 'external']);
+
+const TEXT = Object.freeze({
+  execution: 'Capability limit: Direct Chat cannot execute code or create execution-backed plots.',
+  file: 'Capability limit: Direct Chat cannot create, upload, or provide downloadable files or generated media.',
+  web: 'Capability limit: Direct Chat cannot search, browse, or open the web.',
+  external: 'Capability limit: Direct Chat cannot deploy, publish, message, or change external state.'
+});
+
+const NEGATED_ACTION =
+  /^(?:do\s+not|don't|dont|never|avoid|without|no\s+need\s+to)\b|^(?:不要|不用|无需|無需|不需要|避免)/iu;
+const DISCUSSION_LEAD =
+  /^(?:explain|describe|discuss|review|compare|define|translate|summari[sz]e|quote|analy[sz]e|tell\s+me\s+(?:about|how|why|what)|how\b|why\b|what\b|write\s+(?:an?\s+)?(?:tutorial|explanation|guide|example|article)|(?:解释|解釋|描述|讨论|討論|说明|說明|为什么|為什麼|如何|什么是|什麼是))/iu;
+const EXECUTION_ACTION =
+  /^(?:run|execute)\b[^.!?;\r\n]{0,180}\b(?:python|code|script|program|command|test|calculation)\b|^(?:plot|visuali[sz]e)\b|^(?:make|create|generate|draw|show|render|produce)\b[^.!?;\r\n]{0,160}\b(?:plot|chart|graph)\b|^(?:运行|運行|执行|執行).{0,80}(?:代码|代碼|脚本|腳本|python)|^(?:画图|畫圖|绘图|繪圖|生成图表|生成圖表)/iu;
+const FILE_ACTION =
+  /^(?:make|create|generate|produce|prepare|compile|typeset|render|export|save|download|upload|provide|return|send|give|share)\b[^.!?;\r\n]{0,220}(?:\b(?:files?|attachments?|downloads?|archives?|pdf|latex|tex|documents?|spreadsheets?|presentations?|images?|photos?|illustrations?|audio|voice|videos?)\b|\.(?:pdf|tex|csv|json|md|docx?|xlsx?|pptx?|zip|tar|gz|py|js|ts|html|svg|png|jpe?g|webp|mp3|wav|m4a|mp4)\b)|^(?:创建|建立|生成|制作|製作|编译|編譯|导出|導出|下载|下載|上传|上傳).{0,140}(?:文件|文档|文檔|pdf|latex|tex|图片|圖片|音频|音頻|视频|視頻)/iu;
+const WEB_ACTION =
+  /^(?:search|browse|google|visit|fetch|open|read|look\s+up|find)\b[^.!?;\r\n]{0,180}(?:\b(?:web|internet|online|website|site|url)\b|https?:\/\/|www\.)|^(?:搜索|搜尋|浏览|瀏覽|打开|打開|查找|查詢).{0,120}(?:网络|網絡|互联网|互聯網|网站|網站|网页|網頁)/iu;
+const EXTERNAL_ACTION =
+  /^(?:deploy|publish|push|upload|email|post|submit)\b|^send\b[^.!?;\r\n]{0,160}\b(?:email|notification)\b|^send\b[^.!?;\r\n]{0,160}\bto\s+(?!(?:me|us|here|this\s+chat)\b)\S|^(?:change|update|delete|remove)\b[^.!?;\r\n]{0,160}\b(?:account|website|site|server|deployment|repository|repo|setting|record|remote)\b|^(?:部署|发布|發布|推送|上传|上傳|发送|發送|删除|刪除|修改).{0,120}(?:网站|網站|服务器|伺服器|仓库|倉庫|账号|帳號|设置|設定|邮件|郵件|消息)/iu;
+
+function actionText(value) {
+  let text = String(value || '').trim();
+  text = text.replace(/^(?:please|kindly)\s+/iu, '');
+  text = text.replace(/^(?:can|could|would|will)\s+you\s+(?:(?:please|kindly)\s+)?/iu, '');
+  text = text.replace(/^i(?:'d|\s+would)?\s+(?:like|want|need)\s+(?:you\s+)?to\s+/iu, '');
+  text = text.replace(/^let(?:'s|\s+us)\s+/iu, '');
+  text = text.replace(/^(?:请你?|請你?|麻烦你?|麻煩你?)[ \t]*/u, '');
+  return text;
+}
+
+function clauses(value) {
+  const unquoted = String(value || '')
+    .normalize('NFKC')
+    .replace(/```[^\r\n]*\r?\n?[\s\S]*?```/gu, ' ')
+    .replace(/~~~[^\r\n]*\r?\n?[\s\S]*?~~~/gu, ' ')
+    .replace(/`[^`\r\n]*`/gu, ' ')
+    .replace(/[“”]([^“”\r\n]*)[“”]/gu, ' ')
+    .replace(/"([^"\r\n]*)"/gu, ' ')
+    .replace(/[‘’]([^‘’\r\n]*)[‘’]/gu, ' ');
+  return unquoted
+    .split(/(?:[!?。！？;；\r\n]+|\.(?=\s|$))/u)
+    .flatMap((clause) => clause.split(/(?:,\s*)?\b(?:and\s+then|then|but)\b\s+(?=(?:(?:please|kindly)\s+)?(?:do\s+not|don't|dont|never|avoid|run|execute|plot|visuali[sz]e|make|create|generate|draw|show|render|produce|prepare|compile|typeset|export|save|download|upload|provide|return|send|give|share|search|browse|google|visit|fetch|open|read|look\s+up|find|deploy|publish|push|email|post|submit|change|update|delete|remove|explain|describe|discuss|summari[sz]e)\b)/giu))
+    .map(actionText)
+    .filter(Boolean);
+}
+
+export function directChatCapabilityCategories(value) {
+  const requested = new Set();
+  for (const clause of clauses(value)) {
+    if (NEGATED_ACTION.test(clause) || DISCUSSION_LEAD.test(clause)) continue;
+    if (EXECUTION_ACTION.test(clause)) requested.add('execution');
+    if (FILE_ACTION.test(clause)) requested.add('file');
+    const suppliedTextTarget = /\b(?:in|from)\s+(?:the\s+)?(?:supplied|provided|attached|this|given)\s+(?:text|content|document)\b/iu.test(clause);
+    if (!suppliedTextTarget && WEB_ACTION.test(clause)) requested.add('web');
+    if (EXTERNAL_ACTION.test(clause)) requested.add('external');
+  }
+  return Object.freeze(ORDER.filter((category) => requested.has(category)));
+}
+
+export function directChatCapabilityNotice(value) {
+  const categories = directChatCapabilityCategories(value);
+  if (categories.length === 0) return '';
+  return `${categories.map((category) => TEXT[category]).join('\n')}\n\nI will still complete every supported text or current supplied-image part below.\n\n`;
+}

package/src/direct-chat-contract.js

@@ -0,0 +1,3 @@
+// One shared boundary for the coordinator and the LocalLLM connector. A
+// labeled summary consumes one entry just like an exact ledger message.
+export const DIRECT_CHAT_CONTEXT_ENTRY_LIMIT = 256;

package/src/errors.js

@@ -0,0 +1,50 @@
+export class ControlPlaneError extends Error {
+  constructor(message, { code = 'control_plane_error', cause } = {}) {
+    super(message, { cause });
+    this.name = new.target.name;
+    this.code = code;
+  }
+}
+
+export class ValidationError extends ControlPlaneError {
+  constructor(message, options = {}) {
+    super(message, { ...options, code: 'invalid_input' });
+  }
+}
+
+export class NotFoundError extends ControlPlaneError {
+  constructor(message = 'The requested resource does not exist.', options = {}) {
+    super(message, { ...options, code: 'not_found' });
+  }
+}
+
+export class ConflictError extends ControlPlaneError {
+  constructor(message = 'The requested mutation conflicts with existing state.', options = {}) {
+    super(message, { ...options, code: 'conflict' });
+  }
+}
+
+export class IdempotencyConflictError extends ControlPlaneError {
+  constructor(message = 'The idempotency key was already used for a different request.', options = {}) {
+    super(message, { ...options, code: 'idempotency_conflict' });
+  }
+}
+
+export class StorageSecurityError extends ControlPlaneError {
+  constructor(message, options = {}) {
+    super(message, { ...options, code: 'storage_security_error' });
+  }
+}
+
+export class StorageCorruptionError extends ControlPlaneError {
+  constructor(message = 'The control-plane database failed integrity validation.', options = {}) {
+    super(message, { ...options, code: 'storage_corruption' });
+  }
+}
+
+export class UnsupportedSchemaError extends ControlPlaneError {
+  constructor(message = 'The control-plane database schema is newer than this software.', options = {}) {
+    super(message, { ...options, code: 'unsupported_schema' });
+  }
+}
+