@matuto-ai/opencode-broker-connector 0.1.1 → 0.4.0

package/src/v2-plugin.mjs

@@ -0,0 +1,192 @@
+import { randomUUID, createHash } from 'node:crypto';
+import { realpathSync } from 'node:fs';
+import { canonical } from '../vendor/broker/src/protocol.mjs';
+import { createOpenCodeAdapter } from './opencode-adapter.mjs';
+import { createV2Delivery, v2SessionBinding, V2_HOST_VERSION } from './v2-delivery.mjs';
+import { openV2Inbox } from './v2-inbox.mjs';
+import { withV2Lock } from './v2-lock.mjs';
+import { installationDirectory } from './installation.mjs';
+import { createToolScope } from './tool-scope.mjs';
+import { createV2Setup, V2_SETUP_TOOLS } from './v2-setup.mjs';
+
+const validID = value => typeof value === 'string' && /^[A-Za-z0-9_.:-]{1,256}$/.test(value);
+const display = value => JSON.stringify(value).replace(/[\u007f-\u009f\u2028\u2029\u202a-\u202e\u2066-\u2069]/gu,
+  char => `\\u${char.codePointAt(0).toString(16).padStart(4, '0')}`);
+
+/** Optional V2-only setup. Never migrates, attaches to, or upgrades a classic host.
+ * No receive/ack fallback is registered: incoming delivery is native automatic.
+ */
+export async function setupV2Plugin({ ctx, reference, tool, loadSettings, clientFactory,
+  setupOptions = {}, setupEnabled = true, deliveryFactory = createV2Delivery, adapterFactory = createOpenCodeAdapter, onDiagnostic = () => {} }) {
+  if (ctx?.app?.version !== V2_HOST_VERSION || ['get', 'synthetic', 'context', 'hook'].some(k => typeof ctx?.session?.[k] !== 'function')
+    || typeof ctx?.storage?.get !== 'function' || typeof ctx?.storage?.set !== 'function' || typeof ctx?.storage?.scan !== 'function'
+    || typeof ctx?.tool?.transform !== 'function' || typeof ctx?.event?.subscribe !== 'function') throw new Error('psst_v2_host_capability_unavailable');
+  const directory = realpathSync(ctx.location.directory);
+  const hostID = await withV2Lock(setupOptions.directory ?? installationDirectory(), 'host-anchor', async () => {
+    let value = await ctx.storage.get('psst-v2-host-id');
+    if (value === undefined) { value = randomUUID(); await ctx.storage.set('psst-v2-host-id', value); }
+    return value;
+  });
+  const registryPrefix = 'psst-v2-session:' + createHash('sha256').update(canonical({ directory, workspaceID: ctx.location.workspaceID ?? null })).digest('hex') + ':';
+  if (!validID(hostID)) throw new Error('psst_v2_host_binding_unavailable');
+  const sessions = new Map(), blocked = new Set(), controller = new AbortController(), registrations = [], toolScope = createToolScope();
+  let disposed = false, events, setup;
+  const diagnostic = code => { try { onDiagnostic({ code }); } catch {} };
+  async function getInfo(sessionID, signal = controller.signal) {
+    if (!validID(sessionID) || signal.aborted || disposed) throw new Error('v2_session_mismatch');
+    const bounded = AbortSignal.any([signal, AbortSignal.timeout(2000)]);
+    let listener;
+    const info = await Promise.race([
+      ctx.session.get({ sessionID }, { signal: bounded }),
+      new Promise((_, reject) => { listener = () => reject(new Error('v2_session_unavailable'));
+        if (bounded.aborted) listener(); else bounded.addEventListener('abort', listener, { once: true }); }),
+    ]).finally(() => bounded.removeEventListener('abort', listener));
+    if (bounded.aborted || disposed || info?.id !== sessionID || info.parentID || info.time?.archived
+      || realpathSync(info.location.directory) !== directory || info.location.workspaceID !== ctx.location.workspaceID) throw new Error('v2_session_mismatch');
+    return info;
+  }
+  async function close(sessionID) {
+    const state = sessions.get(sessionID);
+    if (!state) return;
+    if (state.closing) return state.closing;
+    state.controller.abort();
+    state.closing = (async () => {
+      await state.starting?.catch(() => {});
+      await state.delivery?.stop();
+      await state.adapter?.stop();
+      if (!state.adapter) state.inbox?.close();
+      if (sessions.get(sessionID) === state) sessions.delete(sessionID);
+    })();
+    return state.closing;
+  }
+  async function connect(sessionID) {
+    if (disposed || blocked.has(sessionID)) throw new Error('v2_plugin_closed');
+    let state = sessions.get(sessionID);
+    if (state) { await state.starting; if (state.closing) throw new Error('v2_session_closing'); return state; }
+    if (sessions.size >= 64) throw new Error('v2_session_limit');
+    state = { controller: new AbortController(), lifetime: Symbol('v2 host session') };
+    sessions.set(sessionID, state);
+    state.starting = (async () => {
+      const info = await getInfo(sessionID, state.controller.signal);
+      const nativeBinding = v2SessionBinding(info, hostID);
+      const settings = await loadSettings();
+      if (!settings || disposed || state.controller.signal.aborted) throw new Error('psst_connect_required');
+      const valid = async () => {
+        if (disposed || state.controller.signal.aborted || sessions.get(sessionID) !== state
+          || settings.enrollment && Date.parse(settings.enrollment.expiresAt) <= Date.now()) return null;
+        try {
+          const now = await getInfo(sessionID, state.controller.signal);
+          return canonical(v2SessionBinding(now, hostID)) === canonical(nativeBinding) ? now : null;
+        } catch { return null; }
+      };
+      state.inbox = openV2Inbox({ reference, settings, binding: nativeBinding });
+      await ctx.storage.set(registryPrefix + sessionID, { sessionID, binding: nativeBinding, enabled: true });
+      if (!await valid()) throw new Error('v2_session_mismatch');
+      state.client = clientFactory ? clientFactory(state.inbox) : new reference.BrokerClient({ ...settings.broker, inbox: state.inbox });
+      const binding = { sessionID, directory, worktree: directory, lifetime: state.lifetime, signal: state.controller.signal };
+      state.adapter = adapterFactory({ reference, tool, client: state.client, binding,
+        currentBinding: async () => await valid() ? binding : null, closeSessionOnStop: false,
+        operationContext: context => ({ operationId: canonical({ hostID, sessionID, messageID: context.messageID, callID: context.callID }), operationStartedAt: context.operationStartedAt }),
+        onDiagnostic: entry => {
+          diagnostic(entry.code);
+          if (['unauthenticated', 'forbidden'].includes(entry.code)) { blocked.add(sessionID); queueMicrotask(() => void close(sessionID).catch(() => {})); }
+        } });
+      await state.adapter.start({ name: settings.name ?? 'OpenCode V2', model: { provider: null, id: null, source: 'unknown' }, project: null });
+      if (!await valid()) throw new Error('v2_session_mismatch');
+      state.delivery = deliveryFactory({ session: ctx.session, inbox: state.inbox, binding: nativeBinding,
+        signal: state.controller.signal, verify: valid, onDiagnostic: entry => { state.deliveryStatus = entry.code; diagnostic(entry.code); } });
+      state.delivery.start();
+      return state;
+    })();
+    try { return await state.starting; }
+    catch (error) {
+      state.controller.abort(); await state.delivery?.stop(); await state.adapter?.stop();
+      if (!state.adapter) state.inbox?.close();
+      if (sessions.get(sessionID) === state) sessions.delete(sessionID);
+      throw error;
+    }
+  }
+  const catalog = reference.TOOL_DEFINITIONS.filter(def => def.name !== 'broker_receive');
+  async function dispose() {
+    if (disposed) return;
+    disposed = true; controller.abort();
+    for (const state of sessions.values()) state.controller.abort();
+    await setup?.stop();
+    await toolScope.close();
+    await Promise.all([...sessions.keys()].map(close));
+    await Promise.all(registrations.map(item => item.dispose()));
+    await events?.catch(() => {});
+  }
+  const status = sessionID => { const state = sessions.get(sessionID); return { host_version: V2_HOST_VERSION, mode: 'native_automatic', connected: !!state?.delivery, client_id: state?.client?.inbox?.identity?.client_id ?? null, last_delivery_status: state?.deliveryStatus ?? null, receipt_semantics: 'durable_native_admission_not_model_read' }; };
+  if (setupEnabled) setup = createV2Setup({ storage: ctx.storage, verify: async id => { try { return await getInfo(id); } catch { return null; } }, connect, status, signal: controller.signal, ...setupOptions });
+  try {
+    registrations.push(await ctx.tool.transform(editor => {
+      // Preflight the entire catalog before mutating the host editor.
+      for (const definition of [...(setup ? V2_SETUP_TOOLS : []), ...catalog]) if (editor.get(definition.name)) throw new Error('psst_v2_tool_conflict');
+      for (const definition of setup ? V2_SETUP_TOOLS : []) {
+        if (editor.get(definition.name)) throw new Error('psst_v2_tool_conflict');
+        editor.add({ ...definition, async execute(args, context) {
+          try { return { content: display(await setup.invoke(definition.name, args, context)) }; }
+          catch { return { content: display({ state: 'setup_blocked', next_step: 'Check setup status; do not paste credentials or automatically replace the request.' }) }; }
+        } });
+      }
+      for (const definition of catalog) {
+        if (editor.get(definition.name)) throw new Error('psst_v2_tool_conflict');
+        editor.add({ name: definition.name, description: definition.description, input: definition.inputSchema,
+          async execute(args, context) {
+            return toolScope.run(async operationSignal => {
+            try {
+              if (!(context?.signal instanceof AbortSignal) || context.signal.aborted || !validID(context.messageID) || !validID(context.id)) throw new Error('v2_session_mismatch');
+              const state = await connect(context.sessionID);
+              let operationStartedAt;
+              if (['broker_send', 'broker_resend'].includes(definition.name)) {
+                const bounded = AbortSignal.any([context.signal, operationSignal, controller.signal, AbortSignal.timeout(2000)]);
+                let listener;
+                const messages = await Promise.race([ctx.session.context({ sessionID: context.sessionID }, { signal: bounded }),
+                  new Promise((_, reject) => { listener = () => reject(new Error('v2_context_unavailable')); if (bounded.aborted) listener(); else bounded.addEventListener('abort', listener, { once: true }); })
+                ]).finally(() => bounded.removeEventListener('abort', listener));
+                const message = messages.find(item => item.id === context.messageID && item.type === 'assistant');
+                const call = message?.content?.find(item => item.type === 'tool' && item.id === context.id && item.name === definition.name);
+                operationStartedAt = call?.time?.created;
+                if (!Number.isSafeInteger(operationStartedAt) || operationStartedAt <= 0) throw new Error('v2_original_tool_timestamp_unavailable');
+              }
+              const content = await state.adapter.tools[definition.name].execute(args, { sessionID: context.sessionID,
+                messageID: context.messageID, callID: context.id, ...(operationStartedAt ? { operationStartedAt } : {}), directory, worktree: directory, abort: AbortSignal.any([context.signal, operationSignal, controller.signal]) });
+              return { content };
+            } catch { return { content: display({ error: { code: 'session_mismatch', effect: 'unknown' } }) }; }
+            }, context?.signal).catch(() => ({ content: display({ error: { code: 'session_mismatch', effect: 'unknown' } }) }));
+          } });
+      }
+    }));
+    // Prompt observation only, no mutation of human draft, selection or prompt.
+    registrations.push(await ctx.session.hook('prompt', event => { void connect(event.sessionID).catch(() => diagnostic('v2_connection_unavailable')); }));
+    events = (async () => {
+      for await (const event of ctx.event.subscribe({ signal: controller.signal })) {
+        if (disposed) break;
+        if (event.type === 'location.shutdown' && event.location?.directory === directory) { void dispose(); break; }
+        const sessionID = event.data?.sessionID;
+        setup?.event(event);
+        const state = sessions.get(sessionID);
+        state?.delivery?.event(event);
+        if (['session.deleted', 'session.archived', 'session.moved'].includes(event.type)) {
+          blocked.add(sessionID);
+          if (validID(sessionID)) await ctx.storage.set(registryPrefix + sessionID, { sessionID, enabled: false });
+          await close(sessionID);
+        }
+        if (event.type === 'session.created') void connect(sessionID).catch(() => diagnostic('v2_connection_unavailable'));
+      }
+    })().catch(() => { if (!disposed) { diagnostic('v2_event_stream_unavailable'); void dispose(); } });
+    let cursor, restoreCount = 0;
+    do {
+      const saved = await ctx.storage.scan({ prefix: registryPrefix, limit: 64, ...(cursor ? { after: cursor } : {}) });
+      for (const entry of saved.entries) {
+        const record = entry.value;
+        if (record?.enabled === true && validID(record.sessionID) && restoreCount < 64) { restoreCount++; void connect(record.sessionID).catch(() => diagnostic('v2_restore_unavailable')); }
+        else if (validID(record?.sessionID) && record?.enabled === false) blocked.add(record.sessionID);
+      }
+      cursor = saved.next;
+    } while (cursor && restoreCount < 64 && !disposed);
+    void setup?.resume().catch(() => diagnostic('v2_setup_restore_unavailable'));
+    return { dispose, connect, status };
+  } catch (error) { await dispose(); throw error; }
+}

package/src/v2-setup.mjs

@@ -0,0 +1,133 @@
+import { canonical } from '../vendor/broker/src/protocol.mjs';
+import { loadApprovalHelper } from './approval-helper.mjs';
+import { installationDirectory, readSelection, readPending, savePending, updatePending, selectInstallation } from './installation.mjs';
+import { withV2Lock } from './v2-lock.mjs';
+import { createToolScope } from './tool-scope.mjs';
+import { setTimeout as delay } from 'node:timers/promises';
+
+const publicState = value => ({ state: value?.state ?? 'setup_needed',
+  ...(value?.requestId ? { request_id: value.requestId } : {}),
+  ...(value?.approvalUrl ? { approval_url: value.approvalUrl } : {}),
+  ...(value?.requestExpiresAt ? { request_expires_at: value.requestExpiresAt } : {}) });
+export const V2_SETUP_TOOLS = [
+  { name: 'broker_setup', description: 'Explicit user-requested URL-only Psst setup. Provide only the HTTPS broker URL. Creates or resumes one private request for human approval in the broker admin UI. Never call on startup or replace an existing denied/expired request automatically.',
+    input: { type: 'object', properties: { broker_url: { type: 'string', maxLength: 2048 } }, required: ['broker_url'], additionalProperties: false } },
+  { name: 'broker_setup_status', description: 'Read public Psst setup/connection status. Does not create approval requests or disclose credentials/private files.',
+    input: { type: 'object', properties: {}, required: [], additionalProperties: false } },
+  { name: 'broker_cancel_setup', description: 'Pause this session\'s local pending Psst setup. Preserves the prior authorization and durable request; does not revoke credentials.',
+    input: { type: 'object', properties: {}, required: [], additionalProperties: false } },
+];
+
+/** One explicit URL flow per installation; subsequent continuation is GET-only.
+ * Helper writes are awaited/drained even after host cancellation: the durable
+ * original request must be reconciled rather than recreated.
+ */
+export function createV2Setup({ storage, verify, connect, status, signal, directory = installationDirectory(),
+  loadHelper = loadApprovalHelper, select = selectInstallation, pollMs = 2000 }) {
+  if (!Number.isSafeInteger(pollMs) || pollMs < 10) throw new Error('setup_interval_invalid');
+  const scope = createToolScope(), lifetime = new AbortController();
+  let running, owner, ownerController = new AbortController(), beginning=false, last={state:'setup_needed'}, stopped=false;
+  const alive = () => !stopped && !signal.aborted && !lifetime.signal.aborted;
+  const binding = info => canonical({ id: info.id, projectID: info.projectID, location: info.location, created: info.time.created });
+  const bound = async id => { if (!alive() || owner?.sessionID === id && ownerController.signal.aborted) return false; const info = await verify(id); return !!info && (!owner?.binding || owner.sessionID !== id || binding(info) === owner.binding); };
+  async function pauseOwned() {
+    if (!owner) return;
+    const pending=readPending(directory);
+    if (pending?.flowId===owner.flowId) updatePending({directory,flowId:owner.flowId,paused:true});
+  }
+  async function finish(result, pending, sessionID, operationSignal) {
+    if (!await bound(sessionID)) return;
+    if (operationSignal?.aborted) { await pauseOwned(); return; }
+    const activePending = readPending(directory);
+    if (!activePending || activePending.paused || activePending.flowId !== pending.flowId) return;
+    if (result.requestId!==pending.requestId) throw new Error('approval_request_mismatch');
+    last=publicState(result);
+    if (result.state==='approved') {
+      try { await select({directory,connectionFile:result.connectionFile,expectedRevision:pending.expectedRevision,pendingFlowId:pending.flowId,verify:()=>bound(sessionID),signal:AbortSignal.any([signal,lifetime.signal,ownerController.signal,...(operationSignal ? [operationSignal] : [])])}); }
+      finally { if (operationSignal?.aborted || ownerController.signal.aborted) await pauseOwned(); }
+      if (!operationSignal?.aborted && await bound(sessionID)) await connect(sessionID);
+    } else if (result.state!=='pending') updatePending({directory,flowId:pending.flowId,paused:true});
+  }
+  function watch(pending, sessionID) {
+    if (running) return;
+    running=(async()=>{
+      const helper=await loadHelper();
+      while(await bound(sessionID)) {
+        const current=readPending(directory);
+        if(!current||current.flowId!==pending.flowId||current.paused)return;
+        const options={directory,brokerUrl:current.brokerUrl,clientType:'opencode'};
+        let waitMs = pollMs;
+        try {
+          const result=await helper.pollApproval(options); // never begin/create here
+          if(!await bound(sessionID))return;
+          await finish(result,current,sessionID);
+          if(result.state!=='pending')return;
+        } catch(error) { if(!error.retryable){last={state:'setup_blocked'};return;} waitMs=Math.min(300000,Math.max(pollMs,error.retryAfterMs||pollMs)); }
+        await delay(waitMs,undefined,{signal:AbortSignal.any([signal,lifetime.signal])}).catch(()=>{});
+      }
+    })().catch(()=>{last={state:'setup_blocked'};}).finally(()=>{running=null;});
+  }
+  async function invoke(name,args,context) {
+    return scope.run(async operationSignal=>{
+      if(!(context?.signal instanceof AbortSignal)||context.signal.aborted||!await bound(context.sessionID))throw new Error('session_mismatch');
+      if(name==='broker_cancel_setup') {
+        if(owner?.sessionID===context.sessionID) { await pauseOwned(); last={...last,state:'paused'}; }
+        return {...last,...status(context.sessionID)};
+      }
+      if(name==='broker_setup_status') return {...last,...status(context.sessionID)};
+      if(name!=='broker_setup'||!args||Object.keys(args).join(',')!=='broker_url')throw new Error('invalid_configuration');
+      const url=new URL(args.broker_url);
+      if(typeof args.broker_url!=='string'||args.broker_url.length>2048||/[\x00-\x20\x7f]/.test(args.broker_url)
+        ||url.protocol!=='https:'||url.username||url.password||url.search||url.hash||url.pathname!=='/')throw new Error('https_origin_required');
+      if(beginning||running||owner&&owner.sessionID!==context.sessionID)throw new Error('setup_owner_conflict');
+      beginning=true;
+      try { return await withV2Lock(directory, 'setup', async () => {
+      const priorOwner = await storage.get('psst-v2-setup-owner');
+      const activePending = readPending(directory);
+      if (activePending && !activePending.paused && priorOwner?.flowId === activePending.flowId && priorOwner.sessionID !== context.sessionID) throw new Error('setup_owner_conflict');
+      const helper=await loadHelper();
+      const options={directory,brokerUrl:url.href,clientType:'opencode'};
+      const previous=helper.readApprovalState(options);
+      if(previous&&previous.state!=='pending')return {...publicState(previous),...status(context.sessionID),replacement_requires_explicit_setup_repair:true};
+      const selected=readSelection(directory);
+      const pending=savePending({directory,brokerUrl:url.href,expectedRevision:selected?.revision??null,requestId:previous?.requestId??null});
+      owner={flowId:pending.flowId,sessionID:context.sessionID,binding:binding(await verify(context.sessionID))};
+      ownerController = new AbortController();
+      await storage.set('psst-v2-setup-owner',owner);
+      // Abort before begin means definitely no host request. After begin may be
+      // ambiguous and must retain the helper's private ID and candidate token.
+      if(operationSignal.aborted||!await bound(context.sessionID)){await pauseOwned();throw new Error('setup_cancelled');}
+      let result;
+      try { result=await helper.beginApproval(options); }
+      catch(error) {
+        const saved=helper.readApprovalState(options);
+        if(saved?.requestId) { updatePending({directory,flowId:pending.flowId,requestId:saved.requestId}); last=publicState(saved);
+          if(error.retryable && !operationSignal.aborted && await bound(context.sessionID)) watch({...pending,requestId:saved.requestId},context.sessionID);
+          else if(operationSignal.aborted || !await bound(context.sessionID)) await pauseOwned();
+        }
+        throw error;
+      }
+      if(previous?.requestId&&result.requestId!==previous.requestId)throw new Error('approval_request_mismatch');
+      updatePending({directory,flowId:pending.flowId,requestId:result.requestId});
+      const current={...pending,requestId:result.requestId};
+      if(operationSignal.aborted||!await bound(context.sessionID)){await pauseOwned();return{state:'paused',request_id:result.requestId};}
+      await finish(result,current,context.sessionID,operationSignal);
+      if(result.state==='pending')watch(current,context.sessionID);
+      return {...publicState(result),...status(context.sessionID)};
+      }); } finally { beginning=false; }
+    },context.signal);
+  }
+  async function resume() {
+    // Explicit durable requests only; never infer a request from an empty install.
+    const saved=await storage.get('psst-v2-setup-owner');
+    if(!saved||typeof saved.sessionID!=='string')return;
+    const pending=readPending(directory);
+    if(!pending||pending.paused||pending.flowId!==saved.flowId||!pending.requestId)return;
+    owner=saved;if(await bound(saved.sessionID))watch(pending,saved.sessionID);
+  }
+  return {invoke,resume,event(event){
+    if (owner?.sessionID === event?.data?.sessionID && ['session.deleted','session.archived','session.moved'].includes(event.type)) {
+      ownerController.abort(); void pauseOwned().catch(()=>{});
+    }
+  },async stop(){stopped=true;lifetime.abort();await scope.close();await running;}};
+}

package/v2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bruno Orsolon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/v2/README.md

@@ -0,0 +1,17 @@
+# Psst for native OpenCode V2 2.2.5
+
+This server-only candidate is installed with OpenCode's native plugin manager,
+using this repository's `v2` subdirectory at an immutable commit. It declares an
+immutable dependency on the reviewed connector runtime; it does not rely on
+files outside this package, install OpenCode, or load the classic TUI extension.
+The root dependency's `./v2` export is distinct from this wrapper: no dependency
+cycle or classic default export is involved.
+
+After installation, ask the native agent to run `broker_setup` with only your
+broker HTTPS URL. Approve the exact request in the broker admin page. Startup
+reuses approved configuration; it never creates enrollment requests. No token or
+connection-file handoff is required.
+
+Supported native host: **2.2.5 only**. This is not a migration of classic sessions,
+a registry release, authenticated-model proof, or complete issue #8 acceptance.
+See the repository's `docs/native-v2.md` for the installation command and evidence.

package/v2/index.mjs

@@ -0,0 +1,2 @@
+// Import the explicit V2 export, not the classic default or this wrapper again.
+export { default } from '@matuto-ai/opencode-broker-connector/v2';