@karma42/agent 0.0.0-stage → 0.1.0-beta.2

package/runtime/control-v2.mjs

@@ -0,0 +1,358 @@
+// Runtime control stays outside model turns. One request at a time; fatal refusals stop the model.
+import { setTimeout as sleep } from 'node:timers/promises';
+
+export class ControlV2 {
+  constructor(url, token, { pollSeconds = 20, takeover = false, runtime, requestSignal, onFatal = () => {}, log = () => {} } = {}) {
+    Object.assign(this, { url, token, pollSeconds: Math.max(10, pollSeconds), takeover, runtime, requestSignal, onFatal, log });
+    this.phase = 'idle';
+    this.lastPhaseAt = 0;
+    this.lastTurn = undefined;
+    this.news = null;
+    this.projectState = null;
+    this.fatal = null;
+    this.closed = false;
+    this.queue = Promise.resolve();
+    this.abort = new AbortController();
+  }
+
+  async request(path, body) {
+    const response = await fetch(`${this.url}/v2${path}`, {
+      method: body ? 'POST' : 'GET',
+      headers: { authorization: `Bearer ${this.token}`, ...(body ? { 'content-type': 'application/json' } : {}) },
+      body: body ? JSON.stringify(body) : undefined,
+      signal: this.requestSignal && !path.endsWith('/phase')
+        ? AbortSignal.any([AbortSignal.timeout(30_000), this.requestSignal]) : AbortSignal.timeout(30_000),
+    });
+    const data = await response.json();
+    if (!response.ok) {
+      const error = new Error(`${data.error ?? response.status}: ${data.message ?? 'Runtime request refused.'}`);
+      error.code = data.error;
+      error.fatal = response.status === 401 || response.status === 409 || (response.status >= 400 && response.status < 500 && response.status !== 429);
+      error.retryAfter = Number(data.retry_after_seconds ?? response.headers.get('retry-after') ?? 1);
+      throw error;
+    }
+    return data;
+  }
+
+  async start() {
+    const run = await this.request('/runs', { runner_version: this.runtime ? `kit-${this.runtime.kitHash.slice(0, 12)}` : 'kit-v2', takeover: this.takeover, ...(this.runtime ? { runtime: this.runtime } : {}) });
+    if (run.protocol !== 2) throw new Error('Protocol mismatch: this runner needs protocol 2.');
+    this.runId = run.run_id;
+    this.pollSeconds = Math.max(this.pollSeconds, run.poll_seconds);
+    while (!this.closed && !this.news) {
+      const delay = await this.observe();
+      if (!this.news) await sleep(delay * 1000, undefined, { signal: this.abort.signal });
+    }
+    if (!this.closed) this.loop = this.monitor();
+  }
+
+  serialize(action) {
+    const task = this.queue.then(action);
+    this.queue = task.catch(() => {});
+    return task;
+  }
+
+  async cycle() {
+    return this.serialize(async () => {
+      this.news = null; // Fail closed while contact is uncertain: no new model turn.
+      const reportDue = Date.now() - this.lastPhaseAt >= 60_000;
+      const news = await this.request('/wait', {
+        run_id: this.runId,
+        ...(reportDue ? { report: { phase: this.phase, ...(this.lastTurn ? { last_turn: this.lastTurn } : {}),
+          ...(this.activity ? { activity: this.activity } : {}) } } : {}),
+      });
+      // Advance only after the combined request succeeds. A lost response retries the report;
+      // the server deduplicates its usage sequence and checks the run on every request.
+      if (reportDue) this.lastPhaseAt = Date.now();
+      const state = `started=${news.project.started}, paused=${news.project.paused}`;
+      if (state !== this.projectState) {
+        this.log(`Project state: ${state}.`);
+        this.projectState = state;
+      }
+      this.news = news;
+    });
+  }
+
+  // Startup and ongoing contact share the same refusal/retry policy. A run can be
+  // registered while its first wait is rate-limited after a recent restart.
+  async observe() {
+    try {
+      await this.cycle();
+      return this.pollSeconds;
+    } catch (error) {
+      this.news = null;
+      if (error.fatal) {
+        this.fatal = error;
+        this.onFatal(error);
+        throw error;
+      }
+      this.log(`Runtime contact failed (${error.message}); no new turn until contact recovers.`);
+      return Math.max(this.pollSeconds, Number.isFinite(error.retryAfter) ? error.retryAfter : 0);
+    }
+  }
+
+  async monitor() {
+    let delay = this.pollSeconds;
+    while (!this.closed) {
+      try {
+        await sleep(delay * 1000, undefined, { signal: this.abort.signal });
+        if (this.closed) break;
+        delay = await this.observe();
+      } catch (error) {
+        if (this.closed || error.fatal) break;
+        throw error;
+      }
+    }
+  }
+
+  async setPhase(phase, lastTurn, reportRuntime = false) {
+    if (lastTurn) this.lastTurn = lastTurn;
+    if (this.fatal) throw this.fatal;
+    this.phase = phase;
+    return this.serialize(async () => {
+      await this.request(`/runs/${this.runId}/phase`, {
+        phase, ...(this.lastTurn ? { last_turn: this.lastTurn } : {}), ...(this.activity ? { activity: this.activity } : {}), ...(reportRuntime && this.runtime ? { runtime: this.runtime } : {}),
+      });
+      this.lastPhaseAt = Date.now();
+    });
+  }
+
+  // A null reason is a local fault the server records as unknown.
+  async close(reason = 'operator') {
+    if (this.closed) return;
+    this.closed = true;
+    this.abort.abort();
+    if (this.runId && (!this.fatal || this.fatal.code === 'runtime_update_required')) {
+      try {
+        await this.serialize(() => this.request(`/runs/${this.runId}/phase`, { phase: 'stopping', ...(reason ? { reason } : {}), ...(this.lastTurn ? { last_turn: this.lastTurn } : {}) }));
+      } catch (error) { this.log(`Final stop report could not be saved: ${error.message}`); }
+    }
+    await this.loop;
+  }
+}
+
+// Single-writer local intent journal, owned by the foreground runner (OPE-20).
+// The MCP child accesses it through an authenticated loopback bridge, never by writing the file.
+import { createServer } from 'node:http';
+import { createHash, randomBytes } from 'node:crypto';
+import { existsSync, readFileSync, statSync, writeFileSync, renameSync, openSync, fsyncSync, closeSync, rmSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+const JOURNAL_BYTES = 2 * 1024 * 1024;
+const JOURNAL_SLOTS = 128;
+const SEND_ID = /^[A-Za-z0-9_-]{1,64}$/;
+const digest = text => createHash('sha256').update(text).digest('hex');
+const refusalResult = text => ({ content: [{ type: 'text', text }], isError: true });
+function normalizedSend(args) {
+  if (!args || typeof args.client_message_id !== 'string' || !SEND_ID.test(args.client_message_id) || !Array.isArray(args.to) || args.to.length < 1 || args.to.length > 20
+    || args.to.some(id => typeof id !== 'string' || !/^[A-Za-z0-9_-]{1,100}$/.test(id)) || typeof args.body !== 'string'
+    || !args.body.trim() || args.body.length > 2000 || (args.thread_id !== undefined && (typeof args.thread_id !== 'string' || !/^[A-Za-z0-9_-]{1,100}$/.test(args.thread_id)))
+    || Object.keys(args).some(key => !['to', 'body', 'thread_id', 'client_message_id'].includes(key))) throw new TypeError('Invalid deferred send arguments.');
+  return { to: [...new Set(args.to)].sort(), body: args.body, ...(args.thread_id === undefined ? {} : { thread_id: args.thread_id }), client_message_id: args.client_message_id };
+}
+
+export class DeferredSends {
+  constructor(file, identity, now = Date.now) {
+    Object.assign(this, { file, identity, now });
+    this.data = { version: 1, identity, pending: [], notices: [] };
+    if (existsSync(file)) {
+      if (statSync(file).size > JOURNAL_BYTES) throw new Error('Deferred send journal is too large; inspect it before restarting.');
+      const data = JSON.parse(readFileSync(file, 'utf8'));
+      if (data.version !== 1 || data.identity !== identity || !Array.isArray(data.pending) || !Array.isArray(data.notices)
+        || data.pending.length + data.notices.length > JOURNAL_SLOTS) throw new Error('Deferred sends belong to another connection or have an unsupported format.');
+      const ids = new Set();
+      for (const entry of data.pending) {
+        if (ids.has(entry.id) || normalizedSend(entry.args).client_message_id !== entry.id || entry.fingerprint !== digest(JSON.stringify(normalizedSend(entry.args)))
+          || !Number.isSafeInteger(entry.nextAt) || entry.nextAt < 0 || !Number.isSafeInteger(entry.attempts) || entry.attempts < 0 || typeof entry.deferred !== 'boolean') throw new Error('Invalid deferred send journal.');
+        ids.add(entry.id); entry.deferred = true; // an unfinished pre-crash request has an ambiguous result
+      }
+      for (const note of data.notices) if (!SEND_ID.test(note.id) || !['delivered', 'failed'].includes(note.status)
+        || !Number.isSafeInteger(note.at) || note.at < 0 || typeof note.code !== 'string' || !/^[A-Za-z0-9_-]{1,100}$/.test(note.code)) throw new Error('Invalid deferred send notice.');
+      this.data = data;
+    }
+  }
+  save() {
+    const text = JSON.stringify(this.data);
+    if (Buffer.byteLength(text) > JOURNAL_BYTES) throw new Error('Deferred send journal is full.');
+    const draft = `${this.file}.${process.pid}.${randomBytes(8).toString('hex')}.tmp`;
+    try {
+      const fd = openSync(draft, 'wx', 0o600);
+      try { writeFileSync(fd, text); fsyncSync(fd); } finally { closeSync(fd); }
+      renameSync(draft, this.file);
+      const directory = openSync(dirname(this.file), 'r');
+      try { fsyncSync(directory); } finally { closeSync(directory); }
+    } finally { rmSync(draft, { force: true }); }
+  }
+  add(args) {
+    args = normalizedSend(args);
+    const fingerprint = digest(JSON.stringify(args));
+    const prior = this.data.pending.find(entry => entry.id === args.client_message_id);
+    if (prior) {
+      if (prior.fingerprint !== fingerprint) throw new TypeError('This pending client message ID already has different content.');
+      return { entry: prior, existing: true };
+    }
+    if (this.data.pending.length + this.data.notices.length >= JOURNAL_SLOTS) throw new TypeError('Deferred send journal is full; handle its pending results first.');
+    const entry = { id: args.client_message_id, args, fingerprint, nextAt: this.now(), attempts: 0, deferred: false };
+    this.data.pending.push(entry); this.save();
+    return { entry, existing: false };
+  }
+  defer(entry, seconds) {
+    entry.deferred = true;
+    entry.nextAt = this.now() + Math.ceil(seconds * 1000);
+    this.save();
+  }
+  complete(entry, status, code) {
+    this.data.pending = this.data.pending.filter(item => item.id !== entry.id);
+    if (entry.deferred) this.data.notices.push({ id: entry.id, status, code, at: this.now() });
+    this.save();
+  }
+  notices() { return this.data.notices.map(note => ({ ...note })); }
+  acknowledge(notes) {
+    const seen = new Set(notes.map(note => JSON.stringify(note)));
+    this.data.notices = this.data.notices.filter(note => !seen.has(JSON.stringify(note)));
+    this.save();
+  }
+}
+
+// Fixed categories keep telemetry bounded and prevent arbitrary tool names/arguments from
+// becoming stored metadata. Only numeric sizes cross the runtime reporting boundary.
+const contextCategory = name => {
+  if (name === 'get_project') return 'project';
+  if (['find_agents', 'find_work'].includes(name)) return 'discovery';
+  if (name === 'get_updates') return 'updates';
+  if (name === 'read_thread') return 'threads';
+  if (name === 'send_message') return 'messaging';
+  if (['record_work_intent', 'list_work_intents'].includes(name)) return 'checkpoints';
+  if (['get_issue_coordination', 'coordinate_issue'].includes(name)) return 'coordination';
+  return 'other';
+};
+
+export class DeferredMcp {
+  constructor(control, file, { now = Date.now, onDeferred = () => {}, log = () => {} } = {}) {
+    Object.assign(this, { control, now, onDeferred, log });
+    this.journal = new DeferredSends(file, digest(JSON.stringify([control.url, control.token])), now);
+    this.secret = randomBytes(32).toString('hex'); this.queue = Promise.resolve(); this.closed = false; this.fault = null;
+  }
+  beginContext() { this.context = { catalogRequests: 0, catalogBytes: 0, tools: new Map() }; }
+  endContext() {
+    const context = this.context; this.context = null;
+    return { catalogRequests: context?.catalogRequests ?? 0, catalogBytes: context?.catalogBytes ?? 0,
+      tools: [...(context?.tools.values() ?? [])].map(item => ({ ...item })) };
+  }
+  recordContext(context, rpc, reply) {
+    if (!context || context !== this.context) return; // completed outside this model boundary
+    if (rpc.method === 'tools/list' && Array.isArray(reply?.result?.tools)) {
+      context.catalogRequests++; context.catalogBytes += Buffer.byteLength(JSON.stringify(reply.result.tools));
+    }
+    if (rpc.method !== 'tools/call') return;
+    const category = contextCategory(rpc.params?.name);
+    const item = context.tools.get(category) ?? { category, calls: 0, argumentBytes: 0, responseTextBytes: 0, refusals: 0 };
+    item.calls++; item.argumentBytes += Buffer.byteLength(JSON.stringify(rpc.params?.arguments ?? {}));
+    const content = reply?.result?.content;
+    if (Array.isArray(content)) item.responseTextBytes += content.reduce((n, part) => n + (part.type === 'text' && typeof part.text === 'string' ? Buffer.byteLength(part.text) : 0), 0);
+    if (reply?.result?.isError || reply?.error) item.refusals++;
+    context.tools.set(category, item);
+  }
+  serialize(action) { const task = this.queue.then(() => { if (this.fault) throw this.fault; return action(); }); this.queue = task.catch(error => { if (!this.closed) { this.fault = error; this.onDeferred(); } }); return task; }
+  canSend() { return !this.closed && !this.control.closed && !this.control.fatal && this.control.news?.project?.started && !this.control.news.project.paused; }
+  pendingResult(entry) { return { content: [{ type: 'text', text: JSON.stringify({ status: 'pending', client_message_id: entry.id, retry_at: entry.nextAt, instruction: 'The runner saved this send and will retry without model usage. Finish this turn; do not send a replacement message.' }) }] }; }
+  async forward(rpc) {
+    const response = await fetch(`${this.control.url}/v2/mcp`, {
+      method: 'POST', headers: { authorization: `Bearer ${this.control.token}`, 'x-pilot-run': this.control.runId,
+        'content-type': 'application/json', accept: 'application/json, text/event-stream' },
+      body: JSON.stringify(rpc), signal: AbortSignal.timeout(15_000),
+    });
+    let text = '', bytes = 0; const decoder = new TextDecoder();
+    for await (const chunk of response.body ?? []) {
+      bytes += chunk.byteLength;
+      if (bytes > JOURNAL_BYTES) throw new Error('MCP response exceeds the local bridge bound.');
+      text += decoder.decode(chunk, { stream: true });
+    }
+    text += decoder.decode();
+    if (!text && response.ok && rpc.id === undefined) return null;
+    const data = JSON.parse(text.split('\n').find(line => line.startsWith('data:'))?.slice(5) ?? text);
+    if (!response.ok || typeof data.error === 'string') {
+      if (rpc.method === 'tools/call') return { jsonrpc: '2.0', id: rpc.id, result: refusalResult(`${data.error ?? 'internal_error'}: ${data.message ?? 'Remote call refused.'} (retry_after_seconds: ${data.retry_after_seconds ?? 20})`) };
+      throw new Error('Remote MCP request refused.');
+    }
+    return data;
+  }
+  async attempt(entry, rpc, observed = () => true) {
+    if (!this.canSend()) {
+      this.journal.defer(entry, this.control.pollSeconds ?? 20); this.onDeferred();
+      return this.pendingResult(entry);
+    }
+    entry.attempts = Math.min(Number.MAX_SAFE_INTEGER, entry.attempts + 1); this.journal.save(); // preserve identity before an ambiguous network boundary
+    let reply;
+    try { reply = await this.forward(rpc); } catch {
+      this.journal.defer(entry, Math.min(3600, 20 * 2 ** Math.min(entry.attempts - 1, 7))); this.onDeferred();
+      return this.pendingResult(entry);
+    }
+    if (!observed()) entry.deferred = true; // the model disconnected before receiving the result
+    const result = reply?.result;
+    const text = result?.content?.find(item => item.type === 'text')?.text ?? '';
+    const code = text.split(':')[0];
+    if (result?.isError && ['rate_limited', 'project_busy', 'recipient_backlog', 'internal_error', 'paused', 'not_started'].includes(code)) {
+      const seconds = Number(/retry_after_seconds:\s*(\d+(?:\.\d+)?)/.exec(text)?.[1] ?? 20);
+      this.journal.defer(entry, Math.max(1, Math.min(86400, seconds))); this.onDeferred();
+      return this.pendingResult(entry);
+    }
+    if (result?.isError) { this.journal.complete(entry, 'failed', /^[A-Za-z0-9_-]{1,100}$/.test(code) ? code : 'refused'); return result; }
+    let value;
+    try { value = JSON.parse(text); } catch { /* ambiguous protocol success is retried using the same id */ }
+    if (!value?.message || typeof value.message.id !== 'string') {
+      this.journal.defer(entry, 20); this.onDeferred(); return this.pendingResult(entry);
+    }
+    const wasDeferred = entry.deferred;
+    this.journal.complete(entry, 'delivered', 'accepted');
+    if (wasDeferred) this.log('Deferred send delivered.');
+    return result;
+  }
+  async call(rpc, observed = () => true) {
+    if (rpc.method !== 'tools/call' || rpc.params?.name !== 'send_message') return this.forward(rpc);
+    return this.serialize(async () => {
+      if (this.closed) throw new Error('Local MCP bridge stopped.');
+      let added;
+      try { added = this.journal.add(rpc.params.arguments); } catch (error) {
+        if (!(error instanceof TypeError)) throw error;
+        return { jsonrpc: '2.0', id: rpc.id, result: refusalResult(`bad_input: ${error.message}`) };
+      }
+      const result = added.existing ? (this.onDeferred(), this.pendingResult(added.entry)) : await this.attempt(added.entry, { ...rpc, params: { ...rpc.params, arguments: added.entry.args } }, observed);
+      return { jsonrpc: '2.0', id: rpc.id, result };
+    });
+  }
+  async retryDue() {
+    return this.serialize(async () => {
+      for (const entry of [...this.journal.data.pending]) {
+        if (!this.canSend()) break;
+        if (entry.nextAt > this.now()) continue;
+        await this.attempt(entry, { jsonrpc: '2.0', id: `retry-${entry.id}`, method: 'tools/call', params: { name: 'send_message', arguments: entry.args } });
+      }
+    });
+  }
+  async listen() {
+    this.server = createServer(async (req, res) => {
+      if (this.closed || req.url !== '/mcp' || req.headers.authorization !== `Bearer ${this.secret}`) { res.writeHead(401); res.end(); return; }
+      if (req.method !== 'POST') { res.writeHead(405, { Allow: 'POST' }); res.end(); return; }
+      try {
+        let text = '', bytes = 0; req.setEncoding('utf8');
+        for await (const chunk of req) { bytes += Buffer.byteLength(chunk); if (bytes > 128 * 1024) { res.writeHead(413); res.end(); return; } text += chunk.toString('utf8'); }
+        const rpc = JSON.parse(text);
+        if (rpc.jsonrpc !== '2.0' || typeof rpc.method !== 'string') throw new Error('Invalid MCP request.');
+        const context = this.context;
+        const reply = await this.call(rpc, () => !res.destroyed);
+        if (!res.destroyed) this.recordContext(context, rpc, reply);
+        if (reply === null || rpc.id === undefined) { res.writeHead(204); res.end(); }
+        else { res.writeHead(200, { 'content-type': 'application/json' }); res.end(JSON.stringify(reply)); }
+      } catch { if (!res.headersSent) res.writeHead(500, { 'content-type': 'application/json' }); res.end(JSON.stringify({ jsonrpc: '2.0', id: null, error: { code: -32603, message: 'Local MCP bridge could not complete the request.' } })); }
+    });
+    this.server.requestTimeout = 30_000; this.server.headersTimeout = 10_000;
+    await new Promise((resolve, reject) => { this.server.once('error', reject); this.server.listen(0, '127.0.0.1', resolve); });
+    return { type: 'http', url: `http://127.0.0.1:${this.server.address().port}/mcp`, headers: { Authorization: `Bearer ${this.secret}` } };
+  }
+  async close() {
+    this.closed = true;
+    if (this.server) { this.server.closeAllConnections(); await new Promise(resolve => this.server.close(resolve)); }
+    await this.queue;
+  }
+}

package/runtime/launcher.mjs

@@ -0,0 +1,55 @@
+// Small foreground supervisor. Its protocol is explicit; incompatible updates require a
+// launcher update, never an unbounded chain of downloaded bootstrap replacements.
+import { spawn } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { setTimeout as sleep } from 'node:timers/promises';
+import { fetchRuntime, installRelease } from './runtime.mjs';
+
+export async function supervise({ service, agentName, repoDir, home, env = {} }) {
+  const state = join(home, agentName);
+  let child, stopped = false;
+  const abort = new AbortController();
+  const stop = signal => { stopped = true; abort.abort(); child?.kill(signal); };
+  const handlers = Object.fromEntries(['SIGINT', 'SIGTERM', 'SIGHUP'].map(signal => [signal, () => stop(signal)]));
+  for (const [signal, handler] of Object.entries(handlers)) process.on(signal, handler);
+  let failures = 0;
+  try {
+    while (!stopped) {
+      let selected;
+      try {
+        const token = readFileSync(join(state, 'token'), 'utf8').trim();
+        selected = await fetchRuntime(service, token);
+        failures = 0;
+      } catch (error) {
+        if (stopped) break;
+        if (error.fatal || /Unsupported|integrity|identity mismatch/.test(error.message)) throw error;
+        console.info(`Runtime selection unavailable; retrying before starting work (${error.message}).`);
+        await sleep(Math.min(60, 10 * 2 ** Math.min(failures++, 3)) * 1000, undefined, { signal: abort.signal });
+        continue;
+      }
+      if (stopped) break;
+      const kit = selected.release ? installRelease(state, selected.release) : join(state, 'kit');
+      if (selected.release) console.info(`Runtime release ${selected.release.id.slice(0, 12)}: ${selected.reason}`);
+      const provider = env.PILOT_PROVIDER ?? process.env.PILOT_PROVIDER ?? 'claude';
+      if (!['claude', 'codex'].includes(provider)) throw new Error('Select the local provider explicitly: claude or codex.');
+      const code = await new Promise((resolve, reject) => {
+        child = spawn(process.execPath, [join(kit, 'runner.mjs'), service, agentName, repoDir], {
+          stdio: 'inherit', env: { ...process.env, ...env, PILOT_HOME: home,
+            PILOT_RUNTIME_FILE: selected.release ? join(kit, 'applied.json') : '', PILOT_RUNTIME_MANAGED: '1' },
+        });
+        child.once('error', reject);
+        child.once('exit', (code, signal) => resolve(signal && stopped ? 0 : code ?? 1));
+      });
+      child = null;
+      if (stopped || code !== 75) return stopped ? 0 : code;
+      console.info('Adopting the selected runtime; repository and project remain in place.');
+    }
+    return 0;
+  } catch (error) {
+    if (stopped && error.name === 'AbortError') return 0;
+    console.error(error.message); return 1;
+  } finally {
+    for (const [signal, handler] of Object.entries(handlers)) process.off(signal, handler);
+  }
+}

package/runtime/manifest.json

@@ -0,0 +1,12 @@
+{
+  "source": "pilot/agent-kit",
+  "files": {
+    "runner.mjs": "984d2eabc54f2561397a04c851c29f8362d83e9521063222c2a3ce2725e3e06f",
+    "control-v2.mjs": "02e325b642669b8f29c7b25582b1afaf4b74cbc63d2b463c11bf02abac90ca12",
+    "runtime.mjs": "bceb586f369ca373f919ab848ace6968518d15c49057798778c6bfed3e76d8fc",
+    "launcher.mjs": "4254a649e02597f21b5f3c1b146490554a19cc9919933a3dfdc55113cbf140aa",
+    "claude-settings.json": "bf3bfaaf38de37cda60a7dc48cb8c186c1864df61bd5ff500715ee2d1db4333e",
+    "AGENT_PROMPT_V2.md": "1a4f28e8105db39d384b63ef32cf06a9b14057da2e12fd2d0a0c0f3f1ca02d80",
+    "providers.mjs": "90e70acd1d2363f28584c8ccbc5cce7f9851c4aae1864309ff408822050a10ef"
+  }
+}