@chatpanel/events 0.102.0 → 0.104.0

package/capability.js

@@ -1,126 +1 @@
-// The capability signature — one call shape a rule, a schedule, the user or a model all
-// invoke identically, through one policy path.
-//
-// `actor` is the field that makes capabilities turn-independent; it is the whole of the
-// "capabilities are not turn-shaped" principle expressed as data rather than as a
-// subsystem.
-//
-// `requirements` is what the router dispatches on: not "which model" but "what must be
-// true". {maxLatencyMs:100, deterministic:true, egress:'none'} selects class R or M on a
-// host that can realize it — or REFUSES. Silently exceeding a declared budget is the
-// failure mode this exists to prevent.
-
-import { CLASSES, EFFECTS, EGRESS, ACTOR_KINDS, SCOPE_KINDS, EventError } from './event.js';
-import { DATA_SCOPES } from './scopes.js';
-import { validateView } from './view.js';
-
-export { DATA_SCOPES } from './scopes.js';
-
-const str = (v) => typeof v === 'string' && v.length > 0;
-const strs = (v, allowed = null) => Array.isArray(v) && v.every((x) => str(x) && (!allowed || allowed.includes(x)));
-
-/**
- * Validate a capability DECLARATION — the static surface a reviewer, a user or an admin
- * approves BEFORE the capability runs. Everything here is readable without executing
- * anything, which is what makes load-time approval possible.
- */
-export function validateCapability(c) {
-  if (!c || typeof c !== 'object') throw new EventError('SHAPE', 'capability must be an object');
-  if (!str(c.id)) throw new EventError('SHAPE', 'capability.id required');
-  if (!str(c.version)) throw new EventError('SHAPE', 'capability.version required');
-  if (!CLASSES.includes(c.class)) throw new EventError('SHAPE', `capability.class must be one of ${CLASSES}`);
-  if (!strs(c.requires)) throw new EventError('SHAPE', 'capability.requires must be string[]');
-  if (!strs(c.provides)) throw new EventError('SHAPE', 'capability.provides must be string[]');
-  if (!strs(c.reads, DATA_SCOPES)) throw new EventError('SHAPE', `capability.reads must be within ${DATA_SCOPES}`);
-  if (!strs(c.writes, DATA_SCOPES)) throw new EventError('SHAPE', `capability.writes must be within ${DATA_SCOPES}`);
-  if (!EGRESS.includes(c.egress)) throw new EventError('SHAPE', `capability.egress must be one of ${EGRESS}`);
-  if (!EFFECTS.includes(c.effects)) throw new EventError('SHAPE', `capability.effects must be one of ${EFFECTS}`);
-  if (typeof c.invoke !== 'function') throw new EventError('SHAPE', 'capability.invoke required');
-  if (typeof c.disclose !== 'function') throw new EventError('SHAPE', 'capability.disclose required');
-  if (!c.output || typeof c.output.render !== 'function') {
-    throw new EventError('SHAPE', 'capability.output.render required — canonical value and rendering are separate');
-  }
-  // A capability MAY ship its own UI. Optional, and validated against this capability so a
-  // view can never name a capability its owner isn't already allowed to call.
-  if (c.view != null) validateView(c.view, c);
-  // A class-R capability that declares egress is a contradiction: R is a determinism
-  // guarantee, and a network round-trip is not deterministic.
-  if (c.class === 'R' && c.egress !== 'none') {
-    throw new EventError('CONTRADICTION', 'class R must declare egress:none');
-  }
-  return c;
-}
-
-/**
- * Validate an INVOCATION. Enforces the one rule that is easiest to forget and worst to
- * miss: a capability that is not `pure` cannot be invoked without an idempotency key,
- * because a retried delegated call would otherwise perform the side effect twice.
- */
-export function validateInvocation(inv, capability) {
-  if (!inv || typeof inv !== 'object') throw new EventError('SHAPE', 'invocation must be an object');
-  if (!str(inv.capability)) throw new EventError('SHAPE', 'invocation.capability required');
-  if (!inv.actor || !ACTOR_KINDS.includes(inv.actor.kind) || !str(inv.actor.id)) {
-    throw new EventError('SHAPE', `invocation.actor.kind must be one of ${ACTOR_KINDS}`);
-  }
-  if (!inv.scope || !SCOPE_KINDS.includes(inv.scope.kind) || !str(inv.scope.id)) {
-    throw new EventError('SHAPE', `invocation.scope.kind must be one of ${SCOPE_KINDS}`);
-  }
-  if (!Array.isArray(inv.causes)) throw new EventError('SHAPE', 'invocation.causes must be string[]');
-  const effects = capability ? capability.effects : inv.effects;
-  if (effects && effects !== 'pure' && !str(inv.idempotencyKey)) {
-    throw new EventError('IDEMPOTENCY', `invocation of a '${effects}' capability requires an idempotencyKey`);
-  }
-  return inv;
-}
-
-/**
- * Can this capability satisfy these requirements on this host?
- * Returns { ok, reasons[] } — REFUSING is a valid, expected outcome.
- *
- * `host` supplies what it can actually realize: { realizes: {R:{maxMs},M:{maxMs},...} }.
- * Class is intrinsic (a guarantee); latency is host-bound. Never fuse the two.
- */
-export function canSatisfy(capability, requirements = {}, host = null) {
-  const reasons = [];
-  const { maxLatencyMs, deterministic, egress, maxCostUsd } = requirements;
-
-  if (deterministic === true && !['R', 'M'].includes(capability.class)) {
-    reasons.push(`class ${capability.class} is not deterministic`);
-  }
-  if (egress === 'none' && capability.egress !== 'none') {
-    reasons.push(`capability egresses '${capability.egress}', requirement is 'none'`);
-  }
-  if (egress === 'redacted' && capability.egress === 'delegated') {
-    reasons.push('delegated egress is not controlled, requirement is redacted');
-  }
-  if (maxLatencyMs != null && host) {
-    const realized = host.realizes && host.realizes[capability.class];
-    if (!realized) reasons.push(`host cannot realize class ${capability.class}`);
-    else if (realized.maxMs > maxLatencyMs) {
-      reasons.push(`host realizes class ${capability.class} at ~${realized.maxMs}ms, requirement is ${maxLatencyMs}ms`);
-    }
-  }
-  if (maxCostUsd != null && capability.class === 'C' && maxCostUsd <= 0) {
-    reasons.push('cloud class requires a positive cost ceiling');
-  }
-  return { ok: reasons.length === 0, reasons };
-}
-
-/**
- * The model-facing projection — an ALLOWLIST built from exactly three fields.
- *
- * Never an omit-list. An omit-list leaks the next field someone adds; this cannot,
- * because `invoke`, `effects`, `cost`, `writes` and `egress` are never copied.
- */
-export function toModelSchema(capability) {
-  return {
-    name: capability.id,
-    description: capability.disclose().gist,
-    parameters: capability.input || { type: 'object', properties: {} },
-  };
-}
-
-/** The same allowlist over a toolset — the only supported way to build a model request. */
-export function toModelSchemas(capabilities) {
-  return capabilities.map(toModelSchema);
-}
+import{CLASSES as d,EFFECTS as p,EGRESS as w,ACTOR_KINDS as m,SCOPE_KINDS as S,EventError as s}from"./event.js";import{DATA_SCOPES as n}from"./scopes.js";import{validateView as E}from"./view.js";import{DATA_SCOPES as v}from"./scopes.js";const o=e=>typeof e=="string"&&e.length>0,a=(e,r=null)=>Array.isArray(e)&&e.every(t=>o(t)&&(!r||r.includes(t)));function g(e){if(!e||typeof e!="object")throw new s("SHAPE","capability must be an object");if(!o(e.id))throw new s("SHAPE","capability.id required");if(!o(e.version))throw new s("SHAPE","capability.version required");if(!d.includes(e.class))throw new s("SHAPE",`capability.class must be one of ${d}`);if(!a(e.requires))throw new s("SHAPE","capability.requires must be string[]");if(!a(e.provides))throw new s("SHAPE","capability.provides must be string[]");if(!a(e.reads,n))throw new s("SHAPE",`capability.reads must be within ${n}`);if(!a(e.writes,n))throw new s("SHAPE",`capability.writes must be within ${n}`);if(!w.includes(e.egress))throw new s("SHAPE",`capability.egress must be one of ${w}`);if(!p.includes(e.effects))throw new s("SHAPE",`capability.effects must be one of ${p}`);if(typeof e.invoke!="function")throw new s("SHAPE","capability.invoke required");if(typeof e.disclose!="function")throw new s("SHAPE","capability.disclose required");if(!e.output||typeof e.output.render!="function")throw new s("SHAPE","capability.output.render required — canonical value and rendering are separate");if(e.view!=null&&E(e.view,e),e.class==="R"&&e.egress!=="none")throw new s("CONTRADICTION","class R must declare egress:none");return e}function H(e,r){if(!e||typeof e!="object")throw new s("SHAPE","invocation must be an object");if(!o(e.capability))throw new s("SHAPE","invocation.capability required");if(!e.actor||!m.includes(e.actor.kind)||!o(e.actor.id))throw new s("SHAPE",`invocation.actor.kind must be one of ${m}`);if(!e.scope||!S.includes(e.scope.kind)||!o(e.scope.id))throw new s("SHAPE",`invocation.scope.kind must be one of ${S}`);if(!Array.isArray(e.causes))throw new s("SHAPE","invocation.causes must be string[]");const t=r?r.effects:e.effects;if(t&&t!=="pure"&&!o(e.idempotencyKey))throw new s("IDEMPOTENCY",`invocation of a '${t}' capability requires an idempotencyKey`);return e}function $(e,r={},t=null){const i=[],{maxLatencyMs:c,deterministic:h,egress:f,maxCostUsd:l}=r;if(h===!0&&!["R","M"].includes(e.class)&&i.push(`class ${e.class} is not deterministic`),f==="none"&&e.egress!=="none"&&i.push(`capability egresses '${e.egress}', requirement is 'none'`),f==="redacted"&&e.egress==="delegated"&&i.push("delegated egress is not controlled, requirement is redacted"),c!=null&&t){const u=t.realizes&&t.realizes[e.class];u?u.maxMs>c&&i.push(`host realizes class ${e.class} at ~${u.maxMs}ms, requirement is ${c}ms`):i.push(`host cannot realize class ${e.class}`)}return l!=null&&e.class==="C"&&l<=0&&i.push("cloud class requires a positive cost ceiling"),{ok:i.length===0,reasons:i}}function A(e){return{name:e.id,description:e.disclose().gist,parameters:e.input||{type:"object",properties:{}}}}function q(e){return e.map(A)}export{v as DATA_SCOPES,$ as canSatisfy,A as toModelSchema,q as toModelSchemas,g as validateCapability,H as validateInvocation};

package/citations.js

@@ -1,128 +1,6 @@
-// Turn the citations a model wrote into the citations a reader can click.
-//
-// Models are told to cite as markdown links and finish with a Sources section. Large ones
-// mostly comply; small ones write bare `[1]` and stop — and a user then sees numbers that
-// reference nothing, with the URLs sitting unused in a tool result they never see. That is
-// exactly what happened on a real answer about SpaceX: five sources fetched, five bracket
-// numbers rendered, no links anywhere.
-//
-// The instinct is to write a firmer instruction. But the mapping from [1] to a URL is
-// already known EXACTLY — the tool result numbered them — so this is a substitution, not a
-// judgement, and a deterministic pass cannot fail to follow it. Prompting is the wrong tool
-// for something a rule can guarantee.
-//
-// Shared rather than client-side: any client that shows model output with sources needs
-// this, and the numbering convention belongs with the tool contract that produced it.
+const g=/^\[(\d+)\]\s*\[([^\]]*)\]\(([^)\s]+)\)/gm;function k(n){const o=new Map;for(const e of String(n||"").matchAll(g)){const s=Number(e[1]);o.has(s)||o.set(s,{rank:s,title:e[2].trim(),url:e[3]})}return[...o.values()].sort((e,s)=>e.rank-s.rank)}const y=/\[(\d+(?:\s*,\s*\d+)*)\](?!\()/g;function d(n,o,{heading:e="Sources"}={}){const s=String(n??""),p=new Map((o||[]).filter(t=>t?.url).map(t=>[Number(t.rank),t]));if(!s.trim()||!p.size)return s;const r=new Set,c=s.split(/(```[\s\S]*?```|`[^`\n]*`)/g).map((t,a)=>a%2===1?t:t.replace(y,(h,m)=>{const f=m.split(",").map(u=>Number(u.trim()));return f.every(u=>p.has(u))?(f.forEach(u=>r.add(u)),f.map(u=>`([${u}](${p.get(u).url}))`).join(" ")):h})).join("");if(!r.size||new RegExp(`(^|\\n)\\s*(?:#{1,6}\\s*|\\*\\*)?${e}\\b`,"i").test(c))return c;const i=[...r].sort((t,a)=>t-a).map(t=>{const a=p.get(t);return`${t}. [${a.title||a.url}](${a.url})`}).join(`
+`);return`${c.trimEnd()}
 
-/** `[1] [Title](https://url)` — the citation index every search result opens with. */
-const INDEX_RE = /^\[(\d+)\]\s*\[([^\]]*)\]\(([^)\s]+)\)/gm;
-
-/**
- * Recover the numbered sources from a tool result.
- *
- * Parsed from the SAME text the model was shown, so the numbers can never disagree with
- * what it read — deriving them from anywhere else would reintroduce the mismatch this
- * exists to remove.
- */
-export function sourcesFromToolText(text) {
-  const out = new Map();
-  for (const m of String(text || '').matchAll(INDEX_RE)) {
-    const rank = Number(m[1]);
-    if (!out.has(rank)) out.set(rank, { rank, title: m[2].trim(), url: m[3] });
-  }
-  return [...out.values()].sort((a, b) => a.rank - b.rank);
-}
-
-// A bare citation: [1] or [1, 3] or [1,3] — but NOT a markdown link `[x](url)`, NOT a
-// footnote definition at line start, and not `[]`.
-const BARE_RE = /\[(\d+(?:\s*,\s*\d+)*)\](?!\()/g;
-
-/**
- * Rewrite bare `[n]` citations as markdown links, and append a Sources section listing
- * exactly what was cited.
- *
- * Only ever ADDS links; text the model already wrote as a link is untouched, and a number
- * with no matching source is left exactly as it is — inventing a link for `[7]` when seven
- * sources were never returned would be fabricating a citation, which is worse than an
- * unlinked number.
- */
-export function linkifyCitations(answer, sources, { heading = 'Sources' } = {}) {
-  const text = String(answer ?? '');
-  const byRank = new Map((sources || []).filter((s) => s?.url).map((s) => [Number(s.rank), s]));
-  if (!text.trim() || !byRank.size) return text;
-
-  const cited = new Set();
-  // Skip fenced code: a `[1]` inside a code block is code, not a citation.
-  const parts = text.split(/(```[\s\S]*?```|`[^`\n]*`)/g);
-  const linked = parts.map((part, i) => {
-    if (i % 2 === 1) return part;                       // the captured code spans
-    return part.replace(BARE_RE, (whole, group) => {
-      const ranks = group.split(',').map((n) => Number(n.trim()));
-      if (!ranks.every((n) => byRank.has(n))) return whole;   // unknown number → leave alone
-      ranks.forEach((n) => cited.add(n));
-      return ranks.map((n) => `([${n}](${byRank.get(n).url}))`).join(' ');
-    });
-  }).join('');
-
-  if (!cited.size) return linked;
-
-  // A Sources section the model already wrote is left alone — appending a second one is a
-  // worse outcome than a slightly differently-formatted first.
-  // Match the heading however it was written — `## Sources`, `**Sources**`, or bare. The
-  // first version only matched the bare form, so a model that bolded it got a second one.
-  if (new RegExp(`(^|\\n)\\s*(?:#{1,6}\\s*|\\*\\*)?${heading}\\b`, 'i').test(linked)) return linked;
-
-  const list = [...cited].sort((a, b) => a - b)
-    .map((n) => { const s = byRank.get(n); return `${n}. [${s.title || s.url}](${s.url})`; })
-    .join('\n');
-  return `${linked.trimEnd()}\n\n**${heading}**\n${list}\n`;
-}
-
-// ---------------------------------------------------------------------------------------
-// The collector — what a turn was GIVEN, gathered as its tools return it, and put back
-// under the answer as links. Was the extension's `citationCollector`; the desktop had none,
-// so its answers cited `[1]` with nothing to click.
-// ---------------------------------------------------------------------------------------
-
-/** Tools whose job is to RETURN material rather than to act on something. */
-export const RETRIEVAL_TOOLS = Object.freeze(new Set(['find', 'source', 'history_search', 'web_search', 'search', 'fetch', 'read_page']));
-
-const retrievalName = (name) => String(name || '').replace(/^mcp[_-]/, '').split('__')[0];
-
-/**
- * Wrap a toolset so every result is read for numbered sources.
- *
- * @param tools        `{ execute, … }`; returned as `.tools`, wrapped
- * @param onRetrieved  `({ tool, count, chars, sources }) => void` — RETRIEVAL IS INPUT. Called
- *                     per call that returned material, so the turn shows what it was given and
- *                     by which tool. A retrieval tool that returned no LINKS still returned
- *                     material (notes, past chats), and is reported with `count: 0` — silence
- *                     there would under-report exactly the private sources this makes visible.
- * @returns `{ tools, list(), apply(answer) }`
- */
-export function createCitationCollector(tools, { onRetrieved = null } = {}) {
-  const sources = new Map();
-  const collect = (name, out) => {
-    const body = typeof out === 'string' ? out : (out?.text || '');
-    if (!body) return;
-    const found = sourcesFromToolText(body);
-    for (const s of found) if (!sources.has(s.rank)) sources.set(s.rank, s);
-    if (!onRetrieved) return;
-    try {
-      if (found.length) onRetrieved({ tool: name, count: found.length, chars: body.length, sources: found.slice(0, 20).map((x) => ({ rank: x.rank, title: x.title || '', url: x.url || '' })) });
-      else if (RETRIEVAL_TOOLS.has(retrievalName(name))) onRetrieved({ tool: name, count: 0, chars: body.length, sources: [] });
-    } catch { /* reporting never breaks a turn */ }
-  };
-  const wrapped = tools && typeof tools.execute === 'function'
-    ? { ...tools, execute: async (name, input, meta) => { const out = await tools.execute(name, input, meta); collect(name, out); return out; } }
-    : tools;
-  return {
-    tools: wrapped,
-    list: () => [...sources.values()],
-    /** The answer with its `[n]` citations linked and a Sources section — or the answer untouched when nothing was retrieved. */
-    apply(answer) {
-      if (!sources.size || !answer || typeof answer !== 'string') return answer;
-      try { return linkifyCitations(answer, [...sources.values()]); } catch { return answer; }
-    },
-  };
-}
+**${e}**
+${i}
+`}const x=Object.freeze(new Set(["find","source","history_search","web_search","search","fetch","read_page"])),E=n=>String(n||"").replace(/^mcp[_-]/,"").split("__")[0];function _(n,{onRetrieved:o=null}={}){const e=new Map,s=(r,l)=>{const c=typeof l=="string"?l:l?.text||"";if(!c)return;const i=k(c);for(const t of i)e.has(t.rank)||e.set(t.rank,t);if(o)try{i.length?o({tool:r,count:i.length,chars:c.length,sources:i.slice(0,20).map(t=>({rank:t.rank,title:t.title||"",url:t.url||""}))}):x.has(E(r))&&o({tool:r,count:0,chars:c.length,sources:[]})}catch{}};return{tools:n&&typeof n.execute=="function"?{...n,execute:async(r,l,c)=>{const i=await n.execute(r,l,c);return s(r,i),i}}:n,list:()=>[...e.values()],apply(r){if(!e.size||!r||typeof r!="string")return r;try{return d(r,[...e.values()])}catch{return r}}}}export{x as RETRIEVAL_TOOLS,_ as createCitationCollector,d as linkifyCitations,k as sourcesFromToolText};

package/client-prefs.js

@@ -1,148 +1 @@
-// CLIENT PREFERENCES THAT EVERY CLIENT SHARES — which settings travel between the extension
-// and the desktop, how they are cut out of the extension's settings tree and put back, and
-// how two copies that were both edited are reconciled.
-//
-// The extension keeps its settings in chrome.storage, which nothing on the machine can read.
-// The desktop and the extension DO share one address: the gateway. So the shareable settings
-// live there as a document of SECTIONS, each stamped with when it was last written, and both
-// clients push the sections they change and take the sections the other wrote more recently.
-// Per-section last-writer-wins, not per-key: a section is one thing a person edits on one
-// screen (the MCP server list, the search engines), and merging two edits of one list by key
-// would invent a list neither of them made.
-//
-// WHAT DOES NOT TRAVEL, ON PURPOSE. Endpoints and their keys (the gateway's destinations are
-// the desktop's copy of that idea, and a key should not be copied by a sync), tokens, the
-// active agent (per surface), theme and layout (per window), anything about a browser tab.
-//
-// Pure: `now` is injected, and nothing here knows a storage API or a network.
-
-/** The sections, and where each lives in the extension's settings tree. */
-export const PREF_SECTIONS = Object.freeze([
-  { id: 'mcpServers', label: 'MCP tool servers', path: ['mcpServers'], kind: 'array' },
-  { id: 'skills', label: 'Skills', path: ['skills'], kind: 'array' },
-  { id: 'skillDirs', label: 'Skill folders', path: ['ui', 'skillDirs'], kind: 'array' },
-  { id: 'recipes', label: 'Recipes', path: ['recipes'], kind: 'array' },
-  { id: 'teams', label: 'Teams', path: ['teams'], kind: 'array' },
-  // The agent pool (agent.js). NOT `settings.agents` — that key is the extension's harness
-  // list (its bridge "agents"), which the naming rule keeps; the pool lives beside it.
-  { id: 'agents', label: 'Agents', path: ['agentPool'], kind: 'array' },
-  // SCM connections (scm-connection.js): kind, host, secret REF — never the token, which
-  // stays in the machine's keychain / the bridge's secret store and does not travel.
-  { id: 'connections', label: 'Connections', path: ['connections'], kind: 'array' },
-  // The project pages (F8 §12): the goal, its stakeholder, budget, repos, gate. Jobs and runs
-  // fold on the gateway's project record, not here.
-  { id: 'projects', label: 'Projects', path: ['projects'], kind: 'array' },
-  { id: 'webSearch', label: 'Web search', path: ['ui', 'webSearch'], kind: 'object' },
-  { id: 'tools', label: 'Tools', path: null, kind: 'object', keys: ['mcpToolsMode', 'maxToolsPerTurn', 'maxToolRoundsPerTurn', 'historyTools', 'historyContextMode', 'dataDispatch', 'toolResultMaxChars'] },
-  { id: 'suggestions', label: 'Smart suggestions', path: ['ui', 'suggestions'], kind: 'object' },
-  { id: 'topics', label: 'Topic extraction', path: ['ui', 'topicExtraction'], kind: 'object' },
-  { id: 'voice', label: 'Voice', path: ['ui', 'voice'], kind: 'object' },
-  { id: 'watch', label: 'Watch', path: ['ui', 'watch'], kind: 'object' },
-  { id: 'meetings', label: 'Meetings', path: null, kind: 'object', keys: ['meetingWindowMin', 'liveNotesIntervalMin', 'alertSound'] },
-  { id: 'redaction', label: 'Redaction (client-side)', path: ['ui', 'piiRedaction'], kind: 'object' },
-  // Internal sites (source-gate.js): which hosts are internal and how far their content may
-  // travel. A rule the desktop enforces too, or a page internal in the panel is sent
-  // anywhere from the desk.
-  { id: 'internalSites', label: 'Internal sites', path: ['privacy'], kind: 'object' },
-]);
-
-export const PREF_SECTION_IDS = Object.freeze(PREF_SECTIONS.map((s) => s.id));
-
-const clone = (v) => (v === undefined ? undefined : JSON.parse(JSON.stringify(v)));
-
-function getPath(obj, path) {
-  let cur = obj;
-  for (const k of path) { if (!cur || typeof cur !== 'object') return undefined; cur = cur[k]; }
-  return cur;
-}
-
-function setPath(obj, path, value) {
-  let cur = obj;
-  for (let i = 0; i < path.length - 1; i += 1) {
-    const k = path[i];
-    if (!cur[k] || typeof cur[k] !== 'object') cur[k] = {};
-    cur = cur[k];
-  }
-  cur[path[path.length - 1]] = value;
-}
-
-/** One section's value, read out of the extension's settings tree. `undefined` when absent. */
-export function sectionValue(settings, id) {
-  const spec = PREF_SECTIONS.find((s) => s.id === id);
-  if (!spec || !settings) return undefined;
-  if (spec.path) return clone(getPath(settings, spec.path));
-  const ui = settings.ui || {};
-  const out = {};
-  let any = false;
-  for (const k of spec.keys) if (ui[k] !== undefined) { out[k] = clone(ui[k]); any = true; }
-  return any ? out : undefined;
-}
-
-/** Every section present in the settings tree: `{ id: value }`. */
-export function pickSections(settings) {
-  const out = {};
-  for (const s of PREF_SECTIONS) {
-    const v = sectionValue(settings, s.id);
-    if (v !== undefined) out[s.id] = v;
-  }
-  return out;
-}
-
-/** The settings tree with these section values put back. Returns a new object. */
-export function applySections(settings, sections) {
-  const next = clone(settings || {}) || {};
-  for (const [id, value] of Object.entries(sections || {})) {
-    const spec = PREF_SECTIONS.find((s) => s.id === id);
-    if (!spec || value === undefined) continue;
-    if (spec.path) { setPath(next, spec.path, clone(value)); continue; }
-    if (!next.ui || typeof next.ui !== 'object') next.ui = {};
-    for (const k of spec.keys) if (value && value[k] !== undefined) next.ui[k] = clone(value[k]);
-  }
-  return next;
-}
-
-/** A stable fingerprint of a value — key order does not count as a change. */
-export function sectionHash(value) {
-  const sort = (v) => {
-    if (Array.isArray(v)) return v.map(sort);
-    if (v && typeof v === 'object') return Object.fromEntries(Object.keys(v).sort().map((k) => [k, sort(v[k])]));
-    return v;
-  };
-  try { return JSON.stringify(sort(value)); } catch { return String(value); }
-}
-
-/**
- * Reconcile two stamped copies: `{ id: { value, updatedAt } }` each.
- *
- * The newer stamp wins per section; equal stamps keep `local` (nothing to do). Returns the
- * merged document plus which sections each side contributed, so a client knows what to
- * write locally (`fromRemote`) and what to push (`fromLocal`).
- */
-export function mergeStamped(local = {}, remote = {}) {
-  const merged = {};
-  const fromRemote = [];
-  const fromLocal = [];
-  const ids = new Set([...Object.keys(local || {}), ...Object.keys(remote || {})]);
-  for (const id of ids) {
-    const l = local?.[id]; const r = remote?.[id];
-    const lt = Number(l?.updatedAt) || 0; const rt = Number(r?.updatedAt) || 0;
-    if (r && (!l || rt > lt)) { merged[id] = { value: clone(r.value), updatedAt: rt }; if (l ? sectionHash(l.value) !== sectionHash(r.value) : true) fromRemote.push(id); continue; }
-    if (l) { merged[id] = { value: clone(l.value), updatedAt: lt }; if (!r || lt > rt) fromLocal.push(id); }
-  }
-  return { merged, fromRemote, fromLocal };
-}
-
-/**
- * What a client should PUSH: sections whose value differs from what it last pushed. Each is
- * stamped `now`, so the other side sees them as newer than its own copy.
- */
-export function changedSections(sections, lastPushed = {}, { now = Date.now() } = {}) {
-  const out = {};
-  for (const [id, value] of Object.entries(sections || {})) {
-    if (!PREF_SECTION_IDS.includes(id)) continue;
-    const prev = lastPushed?.[id];
-    if (prev && prev.hash === sectionHash(value)) continue;
-    out[id] = { value: clone(value), updatedAt: now };
-  }
-  return out;
-}
+const l=Object.freeze([{id:"mcpServers",label:"MCP tool servers",path:["mcpServers"],kind:"array"},{id:"skills",label:"Skills",path:["skills"],kind:"array"},{id:"skillDirs",label:"Skill folders",path:["ui","skillDirs"],kind:"array"},{id:"recipes",label:"Recipes",path:["recipes"],kind:"array"},{id:"teams",label:"Teams",path:["teams"],kind:"array"},{id:"agents",label:"Agents",path:["agentPool"],kind:"array"},{id:"connections",label:"Connections",path:["connections"],kind:"array"},{id:"projects",label:"Projects",path:["projects"],kind:"array"},{id:"webSearch",label:"Web search",path:["ui","webSearch"],kind:"object"},{id:"tools",label:"Tools",path:null,kind:"object",keys:["mcpToolsMode","maxToolsPerTurn","maxToolRoundsPerTurn","historyTools","historyContextMode","dataDispatch","toolResultMaxChars"]},{id:"suggestions",label:"Smart suggestions",path:["ui","suggestions"],kind:"object"},{id:"topics",label:"Topic extraction",path:["ui","topicExtraction"],kind:"object"},{id:"voice",label:"Voice",path:["ui","voice"],kind:"object"},{id:"watch",label:"Watch",path:["ui","watch"],kind:"object"},{id:"meetings",label:"Meetings",path:null,kind:"object",keys:["meetingWindowMin","liveNotesIntervalMin","alertSound"]},{id:"redaction",label:"Redaction (client-side)",path:["ui","piiRedaction"],kind:"object"},{id:"internalSites",label:"Internal sites",path:["privacy"],kind:"object"}]),b=Object.freeze(l.map(n=>n.id)),c=n=>n===void 0?void 0:JSON.parse(JSON.stringify(n));function h(n,i){let e=n;for(const t of i){if(!e||typeof e!="object")return;e=e[t]}return e}function k(n,i,e){let t=n;for(let r=0;r<i.length-1;r+=1){const s=i[r];(!t[s]||typeof t[s]!="object")&&(t[s]={}),t=t[s]}t[i[i.length-1]]=e}function y(n,i){const e=l.find(o=>o.id===i);if(!e||!n)return;if(e.path)return c(h(n,e.path));const t=n.ui||{},r={};let s=!1;for(const o of e.keys)t[o]!==void 0&&(r[o]=c(t[o]),s=!0);return s?r:void 0}function j(n){const i={};for(const e of l){const t=y(n,e.id);t!==void 0&&(i[e.id]=t)}return i}function m(n,i){const e=c(n||{})||{};for(const[t,r]of Object.entries(i||{})){const s=l.find(o=>o.id===t);if(!(!s||r===void 0)){if(s.path){k(e,s.path,c(r));continue}(!e.ui||typeof e.ui!="object")&&(e.ui={});for(const o of s.keys)r&&r[o]!==void 0&&(e.ui[o]=c(r[o]))}}return e}function p(n){const i=e=>Array.isArray(e)?e.map(i):e&&typeof e=="object"?Object.fromEntries(Object.keys(e).sort().map(t=>[t,i(e[t])])):e;try{return JSON.stringify(i(n))}catch{return String(n)}}function S(n={},i={}){const e={},t=[],r=[],s=new Set([...Object.keys(n||{}),...Object.keys(i||{})]);for(const o of s){const a=n?.[o],d=i?.[o],u=Number(a?.updatedAt)||0,f=Number(d?.updatedAt)||0;if(d&&(!a||f>u)){e[o]={value:c(d.value),updatedAt:f},(!a||p(a.value)!==p(d.value))&&t.push(o);continue}a&&(e[o]={value:c(a.value),updatedAt:u},(!d||u>f)&&r.push(o))}return{merged:e,fromRemote:t,fromLocal:r}}function g(n,i={},{now:e=Date.now()}={}){const t={};for(const[r,s]of Object.entries(n||{})){if(!b.includes(r))continue;const o=i?.[r];o&&o.hash===p(s)||(t[r]={value:c(s),updatedAt:e})}return t}export{l as PREF_SECTIONS,b as PREF_SECTION_IDS,m as applySections,g as changedSections,S as mergeStamped,j as pickSections,p as sectionHash,y as sectionValue};

package/context-attachments.js

@@ -1,148 +1,12 @@
-// ATTACHED CONTEXT, AS THE MODEL SEES IT — the same on every client.
-//
-// A message carries `attachments`: pages, selections, fetched links, files, images, and the
-// user's own records. This is how they reach a model: text sources folded into the message
-// as <context> blocks, images as image blocks in the provider's wire shape, and — when the
-// turn has tools and the sources are big — a MANIFEST plus a `source` tool instead of the
-// full text, so "hi" on a long page does not pay for the page.
-//
-// Moved out of the extension's providers.js so the desktop's turn assembles attachments
-// exactly the way the panel does. Pure: nothing here fetches or renders.
+import{makeSourceStore as d,manifestText as l,readSource as f,approxTokens as p}from"./sources-retrieval.js";function h(n){let t=n.content||"";const i=(n.attachments||[]).filter(e=>e.kind!=="image");if(i.length){const e=i.map(r=>{const c=`[${r.kind||"context"}] ${r.title||r.url||""}`.trim();return`<context source="${(r.url||r.title||"").replace(/"/g,"")}">
+# ${c}
+${r.text||""}
+</context>`}).join(`
 
-import { makeSourceStore, manifestText, readSource, approxTokens } from './sources-retrieval.js';
+`);t=t?`${t}
 
-// Flatten a stored message (with attachments) into the text the model sees.
-// Image attachments are excluded here — they go to the model as image blocks
-// (see toMultimodalMessages), not as text.
-export function renderContent(m) {
-  let text = m.content || '';
-  const ctx = (m.attachments || []).filter((a) => a.kind !== 'image');
-  if (ctx.length) {
-    const blocks = ctx
-      .map((a) => {
-        const head = `[${a.kind || 'context'}] ${a.title || a.url || ''}`.trim();
-        return `<context source="${(a.url || a.title || '').replace(/"/g, '')}">\n# ${head}\n${a.text || ''}\n</context>`;
-      })
-      .join('\n\n');
-    text = text ? `${text}\n\n${blocks}` : blocks;
-  }
-  return text;
-}
+${e}`:e}return t}function y(n){return n.filter(t=>t.role==="user"||t.role==="assistant").map(t=>({role:t.role,content:h(t)}))}function g(n){return(n.attachments||[]).filter(t=>t.kind==="image"&&t.dataUrl)}function k(n,t){return n.filter(i=>i.role==="user"||i.role==="assistant").map(i=>{const e=h(i),r=i.role==="user"?g(i):[];if(r.length===0)return{role:i.role,content:e};if(t==="anthropic"){const a=[];for(const s of r){const o=/^data:([^;]+);base64,(.+)$/s.exec(s.dataUrl);o&&a.push({type:"image",source:{type:"base64",media_type:o[1],data:o[2]}})}return e&&a.push({type:"text",text:e}),{role:"user",content:a.length?a:e}}const c=[];e&&c.push({type:"text",text:e});for(const a of r)c.push({type:"image_url",image_url:{url:a.dataUrl}});return{role:"user",content:c.length?c:e}})}function $(n,t,{minTokens:i=700}={}){if(!t?.specs?.length)return null;const e=[];for(const s of n||[])for(const o of s?.attachments||[])o?.kind==="image"||!o?.text||e.push(o);if(!e.length)return null;const r=d(e.map(s=>({kind:s.kind||"context",title:s.title,url:s.url,text:s.text})));if(r.tokens<i)return null;const c=new Map(e.map((s,o)=>[s,r.entries[o]?.id]));return{messages:(n||[]).map(s=>s?.attachments?.some(o=>c.get(o))?{...s,attachments:s.attachments.map(o=>{const u=c.get(o);return u?{...o,text:`(not included — read with \`source\`: id ${u}, ~${p(o.text)} tokens)`}:o})}:s),store:r}}const m={name:"source",description:"Read an attached source (a page, tab, selection or file the user attached). Their content is NOT in the conversation — read what you need from here.",parameters:{type:"object",properties:{id:{type:"string",description:"The source id from the manifest, e.g. page-1."},query:{type:"string",description:"What you are looking for. A large source returns the matching sections rather than its first page."}},required:["id"]}};function S(n,t){const i={...m},e=[n?.system,`${l(t)}
 
-export function toChatMessages(messages) {
-  return messages
-    .filter((m) => m.role === 'user' || m.role === 'assistant')
-    .map((m) => ({ role: m.role, content: renderContent(m) }));
-}
+Their content is NOT in this conversation. Call \`source\` with an id — and a query when the source is large — to read what you need.`].filter(Boolean).join(`
 
-// Image attachments on a message: { dataUrl: 'data:<media>;base64,<...>' }.
-export function imageAttachmentsOf(m) {
-  return (m.attachments || []).filter((a) => a.kind === 'image' && a.dataUrl);
-}
-
-// Like toChatMessages, but emits multimodal content (text + image blocks) for
-// user messages that carry images, in the given provider's wire format. Falls
-// back to plain string content when there are no images. `provider` is
-// 'openai' | 'anthropic'.
-export function toMultimodalMessages(messages, provider) {
-  return messages
-    .filter((m) => m.role === 'user' || m.role === 'assistant')
-    .map((m) => {
-      const text = renderContent(m);
-      const imgs = m.role === 'user' ? imageAttachmentsOf(m) : [];
-      if (imgs.length === 0) return { role: m.role, content: text };
-      if (provider === 'anthropic') {
-        const content = [];
-        for (const a of imgs) {
-          const match = /^data:([^;]+);base64,(.+)$/s.exec(a.dataUrl);
-          if (match) content.push({ type: 'image', source: { type: 'base64', media_type: match[1], data: match[2] } });
-        }
-        if (text) content.push({ type: 'text', text });
-        return { role: 'user', content: content.length ? content : text };
-      }
-      // openai (and OpenAI-compatible vision endpoints)
-      const content = [];
-      if (text) content.push({ type: 'text', text });
-      for (const a of imgs) content.push({ type: 'image_url', image_url: { url: a.dataUrl } });
-      return { role: 'user', content: content.length ? content : text };
-    });
-}
-
-/**
- * Hand the model a MANIFEST of what is attached, and a tool to read it.
- *
- * Attachments used to be flattened into the first message — every attached tab, in full,
- * before the model had said anything. "hi" on a long page paid for the whole page, and five
- * attached tabs put five documents in the prompt to answer a question about one paragraph of
- * one of them.
- *
- * Two conditions, both necessary:
- *   - THE TURN MUST CARRY TOOLS. Deferring content a model cannot then fetch does not save
- *     tokens, it deletes the context — the worst possible outcome, and silently.
- *   - IT MUST BE WORTH A ROUND TRIP. Below the threshold the extra call costs more than the
- *     text it avoids, so small attachments still travel inline.
- *
- * Returns the rewritten messages plus a store, or null when nothing was deferred.
- */
-export function deferAttachedSources(messages, tools, { minTokens = 700 } = {}) {
-  if (!tools?.specs?.length) return null;
-  const carried = [];
-  for (const m of messages || []) {
-    for (const a of m?.attachments || []) {
-      if (a?.kind === 'image' || !a?.text) continue;
-      carried.push(a);
-    }
-  }
-  if (!carried.length) return null;
-  const store = makeSourceStore(carried.map((a) => ({
-    kind: a.kind || 'context', title: a.title, url: a.url, text: a.text,
-  })));
-  if (store.tokens < minTokens) return null;
-  // Same index, same id: the manifest and the store must agree or the model asks for
-  // something real and is told it does not exist.
-  const idFor = new Map(carried.map((a, i) => [a, store.entries[i]?.id]));
-  const out = (messages || []).map((m) => {
-    if (!m?.attachments?.some((a) => idFor.get(a))) return m;
-    return {
-      ...m,
-      attachments: m.attachments.map((a) => {
-        const id = idFor.get(a);
-        // The stub keeps the title and url — knowing WHAT is attached is what lets the model
-        // decide whether to read it, and that part is cheap.
-        return id ? { ...a, text: `(not included — read with \`source\`: id ${id}, ~${approxTokens(a.text)} tokens)` } : a;
-      }),
-    };
-  });
-  return { messages: out, store };
-}
-
-export const SOURCE_TOOL_SPEC = {
-  name: 'source',
-  description: 'Read an attached source (a page, tab, selection or file the user attached). Their content is NOT in the conversation — read what you need from here.',
-  parameters: {
-    type: 'object',
-    properties: {
-      id: { type: 'string', description: 'The source id from the manifest, e.g. page-1.' },
-      query: { type: 'string', description: 'What you are looking for. A large source returns the matching sections rather than its first page.' },
-    },
-    required: ['id'],
-  },
-};
-
-/** Add `source` to an existing toolset without disturbing what is already there. */
-export function withSourceTool(tools, store) {
-  const spec = { ...SOURCE_TOOL_SPEC };
-  const system = [
-    tools?.system,
-    `${manifestText(store)}\n\nTheir content is NOT in this conversation. Call \`source\` with an id — and a query when the source is large — to read what you need.`,
-  ].filter(Boolean).join('\n\n');
-  return {
-    ...tools,
-    specs: [...(tools?.specs || []), spec],
-    system,
-    systemParts: { ...(tools?.systemParts || {}), source: approxTokens(manifestText(store)) },
-    execute: async (name, input, meta) => (name === 'source'
-      ? JSON.stringify(readSource(store, typeof input === 'string' ? JSON.parse(input || '{}') : (input || {})))
-      : tools.execute(name, input, meta)),
-  };
-}
+`);return{...n,specs:[...n?.specs||[],i],system:e,systemParts:{...n?.systemParts||{},source:p(l(t))},execute:async(r,c,a)=>r==="source"?JSON.stringify(f(t,typeof c=="string"?JSON.parse(c||"{}"):c||{})):n.execute(r,c,a)}}export{m as SOURCE_TOOL_SPEC,$ as deferAttachedSources,g as imageAttachmentsOf,h as renderContent,y as toChatMessages,k as toMultimodalMessages,S as withSourceTool};