@rynfar/meridian 1.72.0 → 1.74.0

package/dist/antigravity-clients/opencode.js

@@ -0,0 +1,173 @@
+// OpenCode V1 plugin: use a provider named meridian-agy.
+import { createHash } from 'node:crypto'
+export default async function ({ client }) {
+  return {
+    config: async config => {
+      const provider = config.provider?.['meridian-agy']
+      if (!provider) return
+      const options = provider.options ??= {}
+      const upstream = options.fetch ?? globalThis.fetch
+      options.fetch = (input, init) => streamSafely(upstream, input, init)
+    },
+    'chat.headers': async (input, output) => {
+      if (input.model.providerID !== 'meridian-agy') return
+      for (const key of Object.keys(output.headers)) if (key.toLowerCase() === 'idempotency-key') delete output.headers[key]
+      // The header hook runs again on a processor retry. A random ID here
+      // would regenerate the response. Use the public client's active message,
+      // created before generation and retained across retries of that step.
+      const result = await client.session.messages({ path: { id: input.sessionID } })
+      if (result.error || !Array.isArray(result.data)) throw new Error('Cannot read OpenCode request identity')
+      const active = result.data.filter(({ info }) => info.role === 'assistant' && info.parentID === input.message.id && info.agent === input.agent && info.modelID === input.model.id && info.providerID === input.model.providerID && !info.time?.completed)
+      // Hidden one-shots and ambiguous concurrent steps must not share an ID.
+      if (active.length !== 1) return
+      output.headers['idempotency-key'] = createHash('sha256').update(JSON.stringify([input.sessionID, active[0].info.id])).digest('hex')
+    },
+  }
+}
+
+class DeliveryInterrupted extends Error {}
+const maxBytes = 4 * 1024 * 1024
+const encoder = new TextEncoder()
+const wire = event => encoder.encode(`event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`)
+
+async function streamSafely(upstream, input, init) {
+  const abort = new AbortController()
+  const originalSignal = init?.signal ?? (input instanceof Request ? input.signal : undefined)
+  const signal = AbortSignal.any([abort.signal, AbortSignal.timeout(300000), ...(originalSignal ? [originalSignal] : [])])
+  const response = await upstream(input, { ...init, signal })
+  if (!response.ok || !response.body || !response.headers.get('content-type')?.includes('text/event-stream')) return response
+  const readers = new Set()
+  const cancelReaders = () => { for (const reader of readers) void reader.cancel(signal.reason).catch(() => undefined) }
+  signal.addEventListener('abort', cancelReaders, { once: true })
+  let cancelled = false
+  const displayed = new Map()
+  let message
+  async function* chunks(response) {
+    const reader = response.body.getReader()
+    readers.add(reader)
+    let bytes = 0
+    try {
+      signal.throwIfAborted()
+      while (true) {
+        let next
+        try { next = await reader.read() }
+        catch (error) { signal.throwIfAborted(); throw new DeliveryInterrupted(String(error)) }
+        signal.throwIfAborted()
+        if (next.done) break
+        bytes += next.value.byteLength
+        if (bytes > maxBytes) throw new Error('Meridian response exceeds the 4 MiB client buffer')
+        yield next.value
+      }
+    } finally {
+      readers.delete(reader)
+      // Preserve an original read failure if cancellation sees an errored reader.
+      await reader.cancel().catch(() => undefined)
+      reader.releaseLock()
+    }
+  }
+  async function* events(response) {
+    const decoder = new TextDecoder()
+    let pending = ''
+    for await (const chunk of chunks(response)) {
+      pending += decoder.decode(chunk, { stream: true })
+      let match
+      while ((match = /\r?\n\r?\n/.exec(pending))) {
+        const frame = pending.slice(0, match.index)
+        pending = pending.slice(match.index + match[0].length)
+        const data = frame.split(/\r?\n/).filter(line => line.startsWith('data:')).map(line => line.slice(5).trimStart()).join('\n')
+        if (data) yield JSON.parse(data)
+      }
+    }
+    pending += decoder.decode()
+    if (pending.trim()) throw new DeliveryInterrupted('Meridian stream ended within an event')
+  }
+  async function recover() {
+    const headers = new Headers(init?.headers ?? (input instanceof Request ? input.headers : undefined))
+    if (typeof init?.body !== 'string') throw new Error('Meridian cannot recover a non-replayable request body')
+    const body = JSON.parse(init.body)
+    if (!headers.get('idempotency-key') && !body.meridian_request_id) throw new Error('Meridian recovery requires a request identity')
+    headers.set('x-meridian-replay-only', 'true')
+    headers.set('content-type', 'application/json')
+    headers.set('accept', 'application/json')
+    const saved = await upstream(input, { ...init, signal, headers, body: JSON.stringify({ ...body, stream: false }) })
+    if (!saved.ok || saved.headers.get('x-meridian-response-replayed') !== 'true') {
+      await saved.body?.cancel()
+      throw new Error(`Meridian saved-response recovery unavailable (${saved.status}); no tool calls released`)
+    }
+    const decoder = new TextDecoder()
+    let json = ''
+    for await (const chunk of chunks(saved)) json += decoder.decode(chunk, { stream: true })
+    const answer = JSON.parse(json + decoder.decode())
+    if (!answer.id || (message && answer.id !== message.id) || !Array.isArray(answer.content)) throw new Error('Meridian saved response identity changed')
+    // Validate every visible prefix before exposing any recovered suffix or tool.
+    for (const [index, shown] of displayed) {
+      const block = answer.content[index]
+      if (block?.type !== 'text' || typeof block.text !== 'string' || !block.text.startsWith(shown.text) || (shown.closed && block.text !== shown.text)) throw new Error('Meridian saved response differs from displayed text')
+    }
+    for (const block of answer.content) if (!['text', 'tool_use'].includes(block.type)) throw new Error('Meridian saved response contains an unsupported block')
+    const result = []
+    if (!message) result.push({ type: 'message_start', message: { ...answer, content: [], stop_reason: null, stop_sequence: null, usage: { ...answer.usage, output_tokens: 0 } } })
+    for (const [index, block] of answer.content.entries()) {
+      const shown = displayed.get(index)
+      if (shown?.closed) continue
+      if (!shown) result.push({ type: 'content_block_start', index, content_block: block.type === 'text' ? { type: 'text', text: '' } : { ...block, input: {} } })
+      const text = block.type === 'text' ? block.text.slice(shown?.text.length ?? 0) : JSON.stringify(block.input)
+      for (let offset = 0; offset < text.length; offset += 4096) result.push({ type: 'content_block_delta', index, delta: block.type === 'text' ? { type: 'text_delta', text: text.slice(offset, offset + 4096) } : { type: 'input_json_delta', partial_json: text.slice(offset, offset + 4096) } })
+      result.push({ type: 'content_block_stop', index })
+    }
+    result.push({ type: 'message_delta', delta: { stop_reason: answer.stop_reason, stop_sequence: answer.stop_sequence }, usage: answer.usage }, { type: 'message_stop' })
+    return result
+  }
+  const stream = new ReadableStream({
+    async start(controller) {
+      try {
+        const held = []
+        let holding = false, stopped = false
+        try {
+          for await (const event of events(response)) {
+            if (stopped) throw new Error('Meridian sent data after message_stop')
+            if (event.type === 'error') throw new Error(event.error?.message || 'Meridian stream failed')
+            if (event.type === 'ping') continue
+            if (event.type === 'message_start') {
+              if (message || !event.message?.id) throw new Error('Invalid Meridian message identity')
+              message = event.message
+            }
+            if (event.type === 'content_block_start' && event.content_block?.type !== 'text') holding = true
+            if (event.type === 'message_delta' || event.type === 'message_stop') holding = true
+            if (event.type === 'message_stop') stopped = true
+            if (holding) held.push(event)
+            else {
+              if (event.type === 'content_block_start') displayed.set(event.index, { text: event.content_block.text || '', closed: false })
+              if (event.type === 'content_block_delta') {
+                const block = displayed.get(event.index)
+                if (!block || event.delta?.type !== 'text_delta') throw new Error('Invalid Meridian text delta')
+                block.text += event.delta.text
+              }
+              if (event.type === 'content_block_stop') {
+                const block = displayed.get(event.index)
+                if (!block) throw new Error('Invalid Meridian text block')
+                block.closed = true
+              }
+              controller.enqueue(wire(event))
+            }
+          }
+          if (!stopped) throw new DeliveryInterrupted('Meridian stream ended before message_stop')
+          for (const event of held) controller.enqueue(wire(event))
+        } catch (error) {
+          signal.throwIfAborted()
+          if (!(error instanceof DeliveryInterrupted)) throw error
+          for (const event of await recover()) controller.enqueue(wire(event))
+        }
+        controller.close()
+      } catch (error) {
+        if (!cancelled) controller.error(error)
+      } finally {
+        signal.removeEventListener('abort', cancelReaders)
+      }
+    },
+    cancel(reason) { cancelled = true; abort.abort(reason) },
+  })
+  const headers = new Headers(response.headers)
+  headers.delete('content-encoding'); headers.delete('content-length')
+  return new Response(stream, { status: response.status, statusText: response.statusText, headers })
+}

package/dist/antigravity-clients/pi.js

@@ -0,0 +1,21 @@
+// Load with Pi's -e option, using a provider named meridian-agy.
+import { createHash, randomUUID } from 'node:crypto'
+export default function (pi) {
+  let pending
+  const reset = () => { pending = undefined }
+  // A new prompt or session operation is a new intent, even with identical text.
+  for (const event of ['before_agent_start', 'session_start', 'session_shutdown', 'session_before_switch', 'session_before_fork', 'session_before_tree', 'session_before_compact']) pi.on(event, reset)
+  pi.on('turn_end', event => {
+    if (event.message.stopReason === 'error' && pending) pending.retry = true
+    else reset()
+  })
+  pi.on('before_provider_request', (event, ctx) => {
+    if (ctx.model?.provider !== 'meridian-agy') { reset(); return }
+    const fingerprint = createHash('sha256').update(JSON.stringify(event.payload)).digest('hex')
+    // Pi removes a failed assistant message before its agent-level retry.
+    // Keep the ID only for that exact request; never cache conversation content.
+    if (!pending?.retry || pending.fingerprint !== fingerprint) pending = { fingerprint, id: randomUUID(), retry: false }
+    pending.retry = false
+    return { ...event.payload, meridian_request_id: pending.id }
+  })
+}

package/dist/antigravitySetup-35pd5xqn.js

@@ -0,0 +1,191 @@
+import {
+  findOpencodeConfigPath
+} from "./cli-82e2m44k.js";
+import"./cli-p9swy5t3.js";
+
+// src/proxy/antigravitySetup.ts
+import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { randomUUID } from "node:crypto";
+import { applyEdits, modify, parse } from "jsonc-parser";
+var marker = `// Managed by meridian setup --antigravity.
+`;
+var object = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+function record(value, label) {
+  if (value === undefined)
+    return {};
+  if (!object(value))
+    throw new Error(`${label} must be an object; configuration was left untouched`);
+  return value;
+}
+function readConfig(path, client) {
+  const text = existsSync(path) ? readFileSync(path, "utf8") : `{}
+`;
+  const errors = [];
+  const config = parse(text, errors, { allowTrailingComma: client === "opencode", disallowComments: client === "pi" });
+  if (errors.length || !object(config))
+    throw new Error(`Cannot parse ${path}; configuration was left untouched`);
+  return { text, config };
+}
+function parseAntigravitySetupArgs(args) {
+  const values = new Map;
+  const flags = new Set;
+  for (let index = 0;index < args.length; index++) {
+    const key = args[index];
+    if (key === "--antigravity" || key === "--set-default") {
+      flags.add(key);
+      continue;
+    }
+    if (!["--client", "--url", "--model", "--config-dir", "--api-key-env"].includes(key))
+      throw new Error(`Unknown Antigravity setup option: ${key}`);
+    const value = args[++index];
+    if (!value || value.startsWith("--") || values.has(key))
+      throw new Error(`${key} requires one value`);
+    values.set(key, value);
+  }
+  const client = values.get("--client");
+  if (client !== "pi" && client !== "opencode")
+    throw new Error("Choose --client pi or --client opencode (OpenCode V1)");
+  const url = values.get("--url"), model = values.get("--model");
+  if (!url || !model)
+    throw new Error("Provide --url <Antigravity base URL> and --model <account model slug>");
+  return { client, url, model, configDir: values.get("--config-dir"), apiKeyEnv: values.get("--api-key-env"), setDefault: flags.has("--set-default") };
+}
+function setupAntigravityClient(options, entryUrl) {
+  const url = new URL(options.url);
+  if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash)
+    throw new Error("Use an HTTP(S) base URL without credentials, query or fragment");
+  const base = url.href.replace(/\/+$/, "").replace(/\/v1$/, "");
+  if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,199}$/.test(options.model))
+    throw new Error("Invalid account model slug");
+  if (options.apiKeyEnv && !/^[A-Za-z_][A-Za-z0-9_]*$/.test(options.apiKeyEnv))
+    throw new Error("Invalid API-key environment variable name");
+  const entry = fileURLToPath(entryUrl);
+  const source = entry.endsWith(".ts") ? join(dirname(entry), "..", "examples", options.client === "pi" ? "pi-extension" : "opencode-plugin", "antigravity-retry.js") : join(dirname(entry), "antigravity-clients", `${options.client}.js`);
+  if (!existsSync(source))
+    throw new Error(`Bundled ${options.client} integration missing; rebuild or reinstall Meridian`);
+  const directory = options.configDir ? resolve(options.configDir) : options.client === "pi" ? resolve(process.env.PI_CODING_AGENT_DIR || join(homedir(), ".pi", "agent")) : dirname(findOpencodeConfigPath());
+  const configPath = options.client === "pi" ? join(directory, "models.json") : existsSync(join(directory, "opencode.jsonc")) && !existsSync(join(directory, "opencode.json")) ? join(directory, "opencode.jsonc") : join(directory, "opencode.json");
+  const integrationPath = join(directory, options.client === "pi" ? "extensions" : "plugins", "meridian-antigravity.js");
+  if (existsSync(integrationPath) && !readFileSync(integrationPath, "utf8").startsWith(marker))
+    throw new Error(`Unmanaged integration at ${integrationPath}; move it before setup`);
+  const integrationDirectory = dirname(integrationPath);
+  const signature = readFileSync(source, "utf8").split(`
+`)[0];
+  if (existsSync(integrationDirectory)) {
+    for (const name of readdirSync(integrationDirectory)) {
+      const path = join(integrationDirectory, name);
+      if (path !== integrationPath && /\.[cm]?js$/.test(name) && lstatSync(path).isFile() && readFileSync(path, "utf8").includes(signature))
+        throw new Error(`Another Antigravity integration exists at ${path}; remove that manual copy before setup`);
+    }
+  }
+  const { text, config } = readConfig(configPath, options.client);
+  if (options.client === "opencode") {
+    const policies = [config];
+    const sibling = join(directory, configPath.endsWith(".jsonc") ? "opencode.json" : "opencode.jsonc");
+    if (existsSync(sibling)) {
+      const other = readConfig(sibling, "opencode").config;
+      policies.push(other);
+      if (record(other.provider, "Sibling providers")["meridian-agy"] !== undefined)
+        throw new Error(`Antigravity is also configured in ${sibling}; resolve the duplicate before setup`);
+    }
+    for (const policy of policies)
+      for (const field of ["enabled_providers", "disabled_providers"]) {
+        const value = policy[field];
+        if (value !== undefined && (!Array.isArray(value) || value.some((item) => typeof item !== "string")))
+          throw new Error(`${field} must be an array of provider IDs`);
+        if (Array.isArray(value) && (field === "enabled_providers" ? !value.includes("meridian-agy") : value.includes("meridian-agy")))
+          throw new Error(`${field} excludes meridian-agy; update that explicit provider policy before setup`);
+      }
+  }
+  const edits = [];
+  const root = options.client === "pi" ? "providers" : "provider";
+  const providers = record(config[root], root);
+  const provider = record(providers["meridian-agy"], "Antigravity provider");
+  const put = (path, value) => edits.push({ path, value });
+  if (options.client === "pi") {
+    if (provider.models !== undefined && !Array.isArray(provider.models))
+      throw new Error("Pi models must be an array");
+    const models = Array.isArray(provider.models) ? [...provider.models] : [];
+    const matches = models.flatMap((model, index2) => object(model) && model.id === options.model ? [index2] : []);
+    if (matches.length > 1)
+      throw new Error("Duplicate Pi model IDs; resolve them before setup");
+    const index = matches[0] ?? models.length;
+    models[index] = { ...record(models[index], "Pi model"), id: options.model, name: `Antigravity ${options.model}`, reasoning: false, input: ["text", "image"], contextWindow: 128000, maxTokens: 4096 };
+    put([root, "meridian-agy", "api"], "anthropic-messages");
+    put([root, "meridian-agy", "baseUrl"], base);
+    put([root, "meridian-agy", "apiKey"], options.apiKeyEnv ?? provider.apiKey ?? "local-placeholder");
+    put([root, "meridian-agy", "models"], models);
+  } else {
+    const providerOptions = record(provider.options, "Antigravity provider options");
+    const model = record(record(provider.models, "Antigravity models")[options.model], "Antigravity model");
+    put([root, "meridian-agy", "npm"], "@ai-sdk/anthropic");
+    put([root, "meridian-agy", "name"], "Antigravity through Meridian");
+    put([root, "meridian-agy", "options", "baseURL"], `${base}/v1`);
+    put([root, "meridian-agy", "options", "apiKey"], options.apiKeyEnv ? `{env:${options.apiKeyEnv}}` : providerOptions.apiKey ?? "local-placeholder");
+    put([root, "meridian-agy", "models", options.model], { ...model, name: `Antigravity ${options.model}`, limit: { ...record(model.limit, "Model limits"), context: 128000, output: 4096 }, temperature: false, reasoning: false, tool_call: true, modalities: { input: ["text", "image"], output: ["text"] } });
+    if (options.setDefault) {
+      put(["model"], `meridian-agy/${options.model}`);
+      put(["small_model"], `meridian-agy/${options.model}`);
+    }
+  }
+  let updated = text;
+  for (const edit of edits)
+    updated = applyEdits(updated, modify(updated, edit.path, edit.value, { formattingOptions: { insertSpaces: true, tabSize: 2 } }));
+  const writes = [{ path: integrationPath, text: marker + readFileSync(source, "utf8") }, { path: configPath, text: updated }];
+  if (options.client === "pi" && options.setDefault) {
+    const path = join(directory, "settings.json");
+    const settings = readConfig(path, "pi");
+    let value = settings.text;
+    for (const [key, selected] of [["defaultProvider", "meridian-agy"], ["defaultModel", options.model], ["defaultThinkingLevel", "off"]])
+      value = applyEdits(value, modify(value, [key], selected, { formattingOptions: { insertSpaces: true, tabSize: 2 } }));
+    writes.push({ path, text: value });
+  }
+  const prepared = writes.map((write) => {
+    if (existsSync(write.path) && !lstatSync(write.path).isFile())
+      throw new Error(`Refusing to replace a non-regular file: ${write.path}`);
+    const original = existsSync(write.path) ? readFileSync(write.path, "utf8") : undefined;
+    return { ...write, original, mode: original === undefined ? 384 : lstatSync(write.path).mode & 511, backup: `${write.path}.bak-${randomUUID()}` };
+  }).filter((write) => write.text !== write.original);
+  const backups = [], changed = [];
+  try {
+    for (const write of prepared) {
+      mkdirSync(dirname(write.path), { recursive: true });
+      if (write.original !== undefined) {
+        writeFileSync(write.backup, write.original, { flag: "wx", mode: 384 });
+        backups.push(write.backup);
+      }
+    }
+    for (const write of prepared) {
+      if ((existsSync(write.path) ? readFileSync(write.path, "utf8") : undefined) !== write.original)
+        throw new Error(`Configuration changed during setup: ${write.path}`);
+      const temporary = `${write.path}.tmp-${randomUUID()}`;
+      try {
+        writeFileSync(temporary, write.text, { flag: "wx", mode: write.mode });
+        renameSync(temporary, write.path);
+      } finally {
+        if (existsSync(temporary))
+          unlinkSync(temporary);
+      }
+      changed.push(write.path);
+    }
+  } catch (error) {
+    for (const path of changed.reverse()) {
+      const write = prepared.find((item) => item.path === path);
+      if (write.original === undefined)
+        unlinkSync(path);
+      else {
+        chmodSync(write.backup, write.mode);
+        renameSync(write.backup, path);
+      }
+    }
+    throw error;
+  }
+  return { client: options.client, configPath, integrationPath, changed, backups, baseUrl: base, model: options.model };
+}
+export {
+  setupAntigravityClient,
+  parseAntigravitySetupArgs
+};

package/dist/cli-1jstkdj9.js

@@ -0,0 +1,30 @@
+import {
+  __esm
+} from "./cli-p9swy5t3.js";
+
+// src/env.ts
+function env(suffix) {
+  return process.env[`MERIDIAN_${suffix}`] ?? process.env[`CLAUDE_PROXY_${suffix}`];
+}
+function envBool(suffix) {
+  const val = env(suffix);
+  return val === "1" || val === "true" || val === "yes";
+}
+function resolvePassthrough(defaultValue) {
+  const val = env("PASSTHROUGH");
+  if (val === "1" || val === "true" || val === "yes")
+    return true;
+  if (val === "0" || val === "false" || val === "no")
+    return false;
+  return defaultValue;
+}
+function envInt(suffix, defaultValue) {
+  const val = env(suffix);
+  if (!val)
+    return defaultValue;
+  const parsed = parseInt(val, 10);
+  return Number.isFinite(parsed) ? parsed : defaultValue;
+}
+var init_env = () => {};
+
+export { env, envBool, resolvePassthrough, envInt, init_env };