@react-grab/opencode 0.0.98 → 0.1.0-beta.0

package/dist/client.global.js

@@ -1,5 +1,2 @@
-var ReactGrabOpenCode=(function(exports){'use strict';var m=5e3,O="react-grab:agent-sessions",b=t=>{let e="",o="";for(let r of t.split(`
-`))r.startsWith("event:")?e=r.slice(6).trim():r.startsWith("data:")&&(o=r.slice(5).trim());return {eventType:e,data:o}},v=async function*(t,e){let o=t.getReader(),r=new TextDecoder,n="",s=false,a=()=>{s=true,o.cancel().catch(()=>{});};e.addEventListener("abort",a);try{if(e.aborted)throw new DOMException("Aborted","AbortError");for(;;){let d=await o.read();if(s||e.aborted)throw new DOMException("Aborted","AbortError");let{done:i,value:p}=d;p&&(n+=r.decode(p,{stream:!0}));let c;for(;(c=n.indexOf(`
-
-`))!==-1;){let{eventType:f,data:l}=b(n.slice(0,c));if(n=n.slice(c+2),f==="done")return;if(f==="error")throw new Error(l||"Agent error");l&&(yield l);}if(i)break}}finally{e.removeEventListener("abort",a);try{o.releaseLock();}catch{}}},A=t=>typeof t=="object"&&t!==null,S=(t,e,o=O)=>{let r=t.getItem(o);if(!r)throw new Error("No sessions to resume");let n;try{n=JSON.parse(r);}catch{throw new Error("Failed to parse stored sessions")}if(!A(n))throw new Error("Invalid stored sessions");let s=n[e];if(!A(s))throw new Error(`Session ${e} not found`);let a=s.context;if(!A(a))throw new Error(`Session ${e} is invalid`);let d=a.content,i=a.prompt;if(!Array.isArray(d)||typeof i!="string")throw new Error(`Session ${e} is invalid`);let p=a.options,c=a.sessionId;return {content:d,prompt:i,options:p,sessionId:typeof c=="string"?c:void 0}},y=async function*(t,e,o){let r=Date.now(),n=e.sessionId,s=t.pollIntervalMs??100,a=`${t.serverUrl}${t.agentPath??"/agent"}`,d=()=>{if(!n)return;let i=t.abortPath?.(n)??`/abort/${n}`;fetch(`${t.serverUrl}${i}`,{method:"POST"}).catch(()=>{});};o.addEventListener("abort",d);try{let i=await fetch(a,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(e),signal:o});if(!i.ok)throw new Error(`Server error: ${i.status}`);if(!i.body)throw new Error("No response body");let p=v(i.body,o)[Symbol.asyncIterator](),c=!1,f=p.next(),l=null;for(;!c;){let C=await Promise.race([f.then(u=>({type:"status",iteratorResult:u})),new Promise(u=>setTimeout(()=>u({type:"timeout"}),s))]),g=(Date.now()-r)/1e3;if(C.type==="status"){let u=C.iteratorResult;c=u.done??!1,!c&&u.value&&(l=u.value,f=p.next());}l===t.completedStatus?yield `Completed in ${g.toFixed(1)}s`:l?yield `${l} ${g.toFixed(1)}s`:yield `Working\u2026 ${g.toFixed(1)}s`;}}finally{o.removeEventListener("abort",d);}},E=(t,e=m)=>{let o=null;return async()=>{let r=Date.now();if(o&&r-o.timestamp<e)return o.result;try{let n=await t();return o={result:n,timestamp:r},n}catch{return o={result:false,timestamp:r},false}}};var w="Completed successfully";var x=`http://localhost:${6567}`,h=t=>typeof t=="object"&&t!==null&&"setAgent"in t,_=(t={})=>{let{serverUrl:e=x,getOptions:o}=t,r=s=>({...o?.()??{},...s??{}}),n=E(async()=>(await fetch(`${e}/health`,{method:"GET"})).ok,m);return {send:async function*(s,a){let d={...s,options:r(s.options)};yield*y({serverUrl:e,completedStatus:w},d,a);},resume:async function*(s,a,d){let i=S(d,s),p={content:i.content,prompt:i.prompt,options:i.options,sessionId:i.sessionId??s},c={...p,options:r(p.options)};yield "Resuming...",yield*y({serverUrl:e,completedStatus:w},c,a);},supportsResume:true,supportsFollowUp:true,checkConnection:n,undo:async()=>{try{await fetch(`${e}/undo`,{method:"POST"});}catch{}}}},R=async()=>{if(typeof window>"u")return;let t=_(),e=n=>{n.setAgent({provider:t,storage:sessionStorage});},o=window.__REACT_GRAB__;if(h(o)){e(o);return}window.addEventListener("react-grab:init",n=>{n instanceof CustomEvent&&h(n.detail)&&e(n.detail);},{once:true});let r=window.__REACT_GRAB__;h(r)&&e(r);};R();
-exports.attachAgent=R;exports.createOpenCodeAgentProvider=_;return exports;})({});
+var ReactGrabOpenCode=(function(exports){'use strict';var q=4722,x=3e3,D="token",G=(i={})=>{let n=i.serverUrl??`ws://localhost:${q}`,c=i.autoReconnect??true,E=i.reconnectIntervalMs??x,h=i.token,s=null,f=false,p=[],A=null,t=null,o=null,w=false,y=new Set,g=new Set,r=new Set,d=()=>{!c||A||w||(A=setTimeout(()=>{A=null,C().catch(()=>{});},E));},l=e=>{try{let a=JSON.parse(e.data);if(a.type==="handlers"&&a.handlers){p=a.handlers;for(let S of g)S(p);}for(let S of y)S(a);}catch{}},C=()=>s?.readyState===WebSocket.OPEN?Promise.resolve():t||(w=false,t=new Promise((e,a)=>{o=a;let S=h?`${n}?${D}=${encodeURIComponent(h)}`:n;s=new WebSocket(S),s.onopen=()=>{t=null,o=null,f=true;for(let P of r)P(true);e();},s.onmessage=l,s.onclose=()=>{o&&(o(new Error("WebSocket connection closed")),o=null),t=null,f=false,p=[];for(let P of g)P(p);for(let P of r)P(false);d();},s.onerror=()=>{t=null,o=null,f=false,a(new Error("WebSocket connection failed"));};}),t),v=()=>{w=true,A&&(clearTimeout(A),A=null),o&&(o(new Error("Connection aborted")),o=null),t=null,s?.close(),s=null,f=false,p=[];},m=()=>f,R=e=>s?.readyState===WebSocket.OPEN?(s.send(JSON.stringify(e)),true):false;return {connect:C,disconnect:v,isConnected:m,sendAgentRequest:(e,a)=>R({type:"agent-request",agentId:e,sessionId:a.sessionId,context:a}),abortAgent:(e,a)=>{R({type:"agent-abort",agentId:e,sessionId:a});},undoAgent:(e,a)=>R({type:"agent-undo",agentId:e,sessionId:a}),redoAgent:(e,a)=>R({type:"agent-redo",agentId:e,sessionId:a}),onMessage:e=>(y.add(e),()=>y.delete(e)),onHandlersChange:e=>(g.add(e),()=>g.delete(e)),onConnectionChange:e=>(r.add(e),queueMicrotask(()=>{r.has(e)&&e(f);}),()=>r.delete(e)),getAvailableHandlers:()=>p}},I=i=>{let{relayClient:n,agentId:c}=i,E=async()=>{if(!n.isConnected())try{await n.connect();}catch{return  false}return n.getAvailableHandlers().includes(c)},h=async function*(t,o){if(o.aborted)throw new DOMException("Aborted","AbortError");yield "Connecting\u2026";let w=t.sessionId??`session-${Date.now()}-${Math.random().toString(36).slice(2)}`,y={...t,sessionId:w},g=[],r=null,d=null,l=false,C=null,v=()=>{n.abortAgent(c,w),l=true,r&&(r({value:void 0,done:true}),r=null,d=null);};o.addEventListener("abort",v);let m=u=>{!u&&!l&&(C="Relay connection lost",l=true,d&&(d(new Error(C)),r=null,d=null));},R=n.onConnectionChange(m),M=n.onMessage(u=>{if(u.sessionId===w)if(u.type==="agent-status"&&u.content){if(g.push(u.content),r){let b=g.shift();b!==void 0&&(r({value:b,done:false}),r=null,d=null);}}else u.type==="agent-done"?(l=true,r&&(r({value:void 0,done:true}),r=null,d=null)):u.type==="agent-error"&&(C=u.content??"Unknown error",l=true,d&&(d(new Error(C)),r=null,d=null));});if(!n.isConnected())throw R(),M(),o.removeEventListener("abort",v),new Error("Relay connection is not open");if(!n.sendAgentRequest(c,y))throw R(),M(),o.removeEventListener("abort",v),new Error("Failed to send agent request: connection not open");try{for(;;){if(g.length>0){let b=g.shift();b!==void 0&&(yield b);continue}if(l||o.aborted)break;let u=await new Promise((b,O)=>{r=b,d=O;});if(u.done)break;yield u.value;}if(C)throw new Error(C)}finally{o.removeEventListener("abort",v),R(),M();}},s=async t=>{n.abortAgent(c,t);},f=t=>new Promise((o,w)=>{let y=false,g=()=>{y||(y=true,r(),d());},r=n.onMessage(l=>{l.sessionId===t&&(g(),l.type==="agent-done"?o():l.type==="agent-error"&&w(new Error(l.content??"Operation failed")));}),d=n.onConnectionChange(l=>{l||(g(),w(new Error("Connection lost while waiting for operation response")));});});return {send:h,abort:s,undo:async()=>{let t=`undo-${c}-${Date.now()}-${Math.random().toString(36).slice(2)}`;if(!n.undoAgent(c,t))throw new Error("Failed to send undo request: connection not open");return f(t)},redo:async()=>{let t=`redo-${c}-${Date.now()}-${Math.random().toString(36).slice(2)}`;if(!n.redoAgent(c,t))throw new Error("Failed to send redo request: connection not open");return f(t)},checkConnection:E,supportsResume:true,supportsFollowUp:true}},_=null,k=()=>typeof window>"u"?null:window.__REACT_GRAB_RELAY__?(_=window.__REACT_GRAB_RELAY__,_):(_||(_=G(),window.__REACT_GRAB_RELAY__=_),_);var L="opencode",T=i=>typeof i=="object"&&i!==null&&"registerPlugin"in i,Y=(i={})=>{let n=i.relayClient??k();if(!n)throw new Error("RelayClient is required in browser environments");return I({relayClient:n,agentId:L})},N=async()=>{if(typeof window>"u")return;let i=k();if(!i)return;try{await i.connect();}catch{return}let n=I({relayClient:i,agentId:L}),c=s=>{let f={provider:n,storage:sessionStorage},p={name:"opencode-agent",actions:[{id:"edit-with-opencode",label:"Edit with OpenCode",shortcut:"Enter",onAction:A=>{A.enterPromptMode?.(f);},agent:f}]};s.registerPlugin(p);},E=window.__REACT_GRAB__;if(T(E)){c(E);return}window.addEventListener("react-grab:init",s=>{s instanceof CustomEvent&&T(s.detail)&&c(s.detail);},{once:true});let h=window.__REACT_GRAB__;T(h)&&c(h);};N();
+exports.attachAgent=N;exports.createOpenCodeAgentProvider=Y;return exports;})({});

package/dist/client.js

@@ -1,228 +1,414 @@
-// ../utils/dist/client.js
-var CONNECTION_CHECK_TTL_MS = 5e3;
-var STORAGE_KEY = "react-grab:agent-sessions";
-var parseSSEEvent = (eventBlock) => {
-  let eventType = "";
-  let data = "";
-  for (const line of eventBlock.split("\n")) {
-    if (line.startsWith("event:")) eventType = line.slice(6).trim();
-    else if (line.startsWith("data:")) data = line.slice(5).trim();
-  }
-  return { eventType, data };
-};
-var streamSSE = async function* (stream, signal) {
-  const reader = stream.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  let aborted = false;
-  const onAbort = () => {
-    aborted = true;
-    reader.cancel().catch(() => {
-    });
+// ../relay/dist/client.js
+var DEFAULT_RELAY_PORT = 4722;
+var DEFAULT_RECONNECT_INTERVAL_MS = 3e3;
+var RELAY_TOKEN_PARAM = "token";
+var createRelayClient = (options = {}) => {
+  const serverUrl = options.serverUrl ?? `ws://localhost:${DEFAULT_RELAY_PORT}`;
+  const autoReconnect = options.autoReconnect ?? true;
+  const reconnectIntervalMs = options.reconnectIntervalMs ?? DEFAULT_RECONNECT_INTERVAL_MS;
+  const token = options.token;
+  let webSocketConnection = null;
+  let isConnectedState = false;
+  let availableHandlers = [];
+  let reconnectTimeoutId = null;
+  let pendingConnectionPromise = null;
+  let pendingConnectionReject = null;
+  let isIntentionalDisconnect = false;
+  const messageCallbacks = /* @__PURE__ */ new Set();
+  const handlersChangeCallbacks = /* @__PURE__ */ new Set();
+  const connectionChangeCallbacks = /* @__PURE__ */ new Set();
+  const scheduleReconnect = () => {
+    if (!autoReconnect || reconnectTimeoutId || isIntentionalDisconnect) return;
+    reconnectTimeoutId = setTimeout(() => {
+      reconnectTimeoutId = null;
+      connect().catch(() => {
+      });
+    }, reconnectIntervalMs);
   };
-  signal.addEventListener("abort", onAbort);
-  try {
-    if (signal.aborted) {
-      throw new DOMException("Aborted", "AbortError");
-    }
-    while (true) {
-      const result = await reader.read();
-      if (aborted || signal.aborted) {
-        throw new DOMException("Aborted", "AbortError");
+  const handleMessage = (event) => {
+    try {
+      const message = JSON.parse(event.data);
+      if (message.type === "handlers" && message.handlers) {
+        availableHandlers = message.handlers;
+        for (const callback of handlersChangeCallbacks) {
+          callback(availableHandlers);
+        }
       }
-      const { done, value } = result;
-      if (value) buffer += decoder.decode(value, { stream: true });
-      let boundary;
-      while ((boundary = buffer.indexOf("\n\n")) !== -1) {
-        const { eventType, data } = parseSSEEvent(buffer.slice(0, boundary));
-        buffer = buffer.slice(boundary + 2);
-        if (eventType === "done") return;
-        if (eventType === "error") throw new Error(data || "Agent error");
-        if (data) yield data;
+      for (const callback of messageCallbacks) {
+        callback(message);
       }
-      if (done) break;
-    }
-  } finally {
-    signal.removeEventListener("abort", onAbort);
-    try {
-      reader.releaseLock();
     } catch {
     }
-  }
-};
-var isRecord = (value) => typeof value === "object" && value !== null;
-var getStoredAgentContext = (storage, sessionId, storageKey = STORAGE_KEY) => {
-  const rawSessions = storage.getItem(storageKey);
-  if (!rawSessions) throw new Error("No sessions to resume");
-  let parsed;
-  try {
-    parsed = JSON.parse(rawSessions);
-  } catch {
-    throw new Error("Failed to parse stored sessions");
-  }
-  if (!isRecord(parsed)) throw new Error("Invalid stored sessions");
-  const storedSession = parsed[sessionId];
-  if (!isRecord(storedSession)) {
-    throw new Error(`Session ${sessionId} not found`);
-  }
-  const context = storedSession.context;
-  if (!isRecord(context)) throw new Error(`Session ${sessionId} is invalid`);
-  const content = context.content;
-  const prompt = context.prompt;
-  if (!Array.isArray(content) || typeof prompt !== "string") {
-    throw new Error(`Session ${sessionId} is invalid`);
-  }
-  const options = context.options;
-  const storedSessionId = context.sessionId;
+  };
+  const connect = () => {
+    if (webSocketConnection?.readyState === WebSocket.OPEN) {
+      return Promise.resolve();
+    }
+    if (pendingConnectionPromise) {
+      return pendingConnectionPromise;
+    }
+    isIntentionalDisconnect = false;
+    pendingConnectionPromise = new Promise((resolve, reject) => {
+      pendingConnectionReject = reject;
+      const connectionUrl = token ? `${serverUrl}?${RELAY_TOKEN_PARAM}=${encodeURIComponent(token)}` : serverUrl;
+      webSocketConnection = new WebSocket(connectionUrl);
+      webSocketConnection.onopen = () => {
+        pendingConnectionPromise = null;
+        pendingConnectionReject = null;
+        isConnectedState = true;
+        for (const callback of connectionChangeCallbacks) {
+          callback(true);
+        }
+        resolve();
+      };
+      webSocketConnection.onmessage = handleMessage;
+      webSocketConnection.onclose = () => {
+        if (pendingConnectionReject) {
+          pendingConnectionReject(new Error("WebSocket connection closed"));
+          pendingConnectionReject = null;
+        }
+        pendingConnectionPromise = null;
+        isConnectedState = false;
+        availableHandlers = [];
+        for (const callback of handlersChangeCallbacks) {
+          callback(availableHandlers);
+        }
+        for (const callback of connectionChangeCallbacks) {
+          callback(false);
+        }
+        scheduleReconnect();
+      };
+      webSocketConnection.onerror = () => {
+        pendingConnectionPromise = null;
+        pendingConnectionReject = null;
+        isConnectedState = false;
+        reject(new Error("WebSocket connection failed"));
+      };
+    });
+    return pendingConnectionPromise;
+  };
+  const disconnect = () => {
+    isIntentionalDisconnect = true;
+    if (reconnectTimeoutId) {
+      clearTimeout(reconnectTimeoutId);
+      reconnectTimeoutId = null;
+    }
+    if (pendingConnectionReject) {
+      pendingConnectionReject(new Error("Connection aborted"));
+      pendingConnectionReject = null;
+    }
+    pendingConnectionPromise = null;
+    webSocketConnection?.close();
+    webSocketConnection = null;
+    isConnectedState = false;
+    availableHandlers = [];
+  };
+  const isConnected = () => isConnectedState;
+  const sendMessage = (message) => {
+    if (webSocketConnection?.readyState === WebSocket.OPEN) {
+      webSocketConnection.send(JSON.stringify(message));
+      return true;
+    }
+    return false;
+  };
+  const sendAgentRequest = (agentId, context) => {
+    return sendMessage({
+      type: "agent-request",
+      agentId,
+      sessionId: context.sessionId,
+      context
+    });
+  };
+  const abortAgent = (agentId, sessionId) => {
+    sendMessage({
+      type: "agent-abort",
+      agentId,
+      sessionId
+    });
+  };
+  const undoAgent = (agentId, sessionId) => {
+    return sendMessage({
+      type: "agent-undo",
+      agentId,
+      sessionId
+    });
+  };
+  const redoAgent = (agentId, sessionId) => {
+    return sendMessage({
+      type: "agent-redo",
+      agentId,
+      sessionId
+    });
+  };
+  const onMessage = (callback) => {
+    messageCallbacks.add(callback);
+    return () => messageCallbacks.delete(callback);
+  };
+  const onHandlersChange = (callback) => {
+    handlersChangeCallbacks.add(callback);
+    return () => handlersChangeCallbacks.delete(callback);
+  };
+  const onConnectionChange = (callback) => {
+    connectionChangeCallbacks.add(callback);
+    queueMicrotask(() => {
+      if (connectionChangeCallbacks.has(callback)) {
+        callback(isConnectedState);
+      }
+    });
+    return () => connectionChangeCallbacks.delete(callback);
+  };
+  const getAvailableHandlers = () => availableHandlers;
   return {
-    content,
-    prompt,
-    options,
-    sessionId: typeof storedSessionId === "string" ? storedSessionId : void 0
+    connect,
+    disconnect,
+    isConnected,
+    sendAgentRequest,
+    abortAgent,
+    undoAgent,
+    redoAgent,
+    onMessage,
+    onHandlersChange,
+    onConnectionChange,
+    getAvailableHandlers
   };
 };
-var streamAgentStatusFromServer = async function* (options, context, signal) {
-  const startTime = Date.now();
-  const sessionId = context.sessionId;
-  const pollIntervalMs = options.pollIntervalMs ?? 100;
-  const agentUrl = `${options.serverUrl}${options.agentPath ?? "/agent"}`;
-  const handleAbort = () => {
-    if (!sessionId) return;
-    const abortPath = options.abortPath?.(sessionId) ?? `/abort/${sessionId}`;
-    fetch(`${options.serverUrl}${abortPath}`, { method: "POST" }).catch(
-      () => {
+var createRelayAgentProvider = (options) => {
+  const { relayClient, agentId } = options;
+  const checkConnection = async () => {
+    if (!relayClient.isConnected()) {
+      try {
+        await relayClient.connect();
+      } catch {
+        return false;
       }
-    );
-  };
-  signal.addEventListener("abort", handleAbort);
-  try {
-    const response = await fetch(agentUrl, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(context),
-      signal
-    });
-    if (!response.ok) {
-      throw new Error(`Server error: ${response.status}`);
     }
-    if (!response.body) {
-      throw new Error("No response body");
+    return relayClient.getAvailableHandlers().includes(agentId);
+  };
+  const send = async function* (context, signal) {
+    if (signal.aborted) {
+      throw new DOMException("Aborted", "AbortError");
     }
-    const iterator = streamSSE(response.body, signal)[Symbol.asyncIterator]();
+    yield "Connecting\u2026";
+    const sessionId = context.sessionId ?? `session-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    const contextWithSession = {
+      ...context,
+      sessionId
+    };
+    const messageQueue = [];
+    let resolveNextMessage = null;
+    let rejectNextMessage = null;
     let isDone = false;
-    let pendingNext = iterator.next();
-    let lastStatus = null;
-    while (!isDone) {
-      const result = await Promise.race([
-        pendingNext.then((iteratorResult) => ({
-          type: "status",
-          iteratorResult
-        })),
-        new Promise(
-          (resolve) => setTimeout(() => resolve({ type: "timeout" }), pollIntervalMs)
-        )
-      ]);
-      const elapsedSeconds = (Date.now() - startTime) / 1e3;
-      if (result.type === "status") {
-        const iteratorResult = result.iteratorResult;
-        isDone = iteratorResult.done ?? false;
-        if (!isDone && iteratorResult.value) {
-          lastStatus = iteratorResult.value;
-          pendingNext = iterator.next();
+    let errorMessage = null;
+    const handleAbort = () => {
+      relayClient.abortAgent(agentId, sessionId);
+      isDone = true;
+      if (resolveNextMessage) {
+        resolveNextMessage({ value: void 0, done: true });
+        resolveNextMessage = null;
+        rejectNextMessage = null;
+      }
+    };
+    signal.addEventListener("abort", handleAbort);
+    const handleConnectionChange = (connected) => {
+      if (!connected && !isDone) {
+        errorMessage = "Relay connection lost";
+        isDone = true;
+        if (rejectNextMessage) {
+          rejectNextMessage(new Error(errorMessage));
+          resolveNextMessage = null;
+          rejectNextMessage = null;
         }
       }
-      if (lastStatus === options.completedStatus) {
-        yield `Completed in ${elapsedSeconds.toFixed(1)}s`;
-      } else if (lastStatus) {
-        yield `${lastStatus} ${elapsedSeconds.toFixed(1)}s`;
-      } else {
-        yield `Working\u2026 ${elapsedSeconds.toFixed(1)}s`;
+    };
+    const unsubscribeConnection = relayClient.onConnectionChange(
+      handleConnectionChange
+    );
+    const unsubscribeMessage = relayClient.onMessage((message) => {
+      if (message.sessionId !== sessionId) return;
+      if (message.type === "agent-status" && message.content) {
+        messageQueue.push(message.content);
+        if (resolveNextMessage) {
+          const nextMessage = messageQueue.shift();
+          if (nextMessage !== void 0) {
+            resolveNextMessage({ value: nextMessage, done: false });
+            resolveNextMessage = null;
+            rejectNextMessage = null;
+          }
+        }
+      } else if (message.type === "agent-done") {
+        isDone = true;
+        if (resolveNextMessage) {
+          resolveNextMessage({ value: void 0, done: true });
+          resolveNextMessage = null;
+          rejectNextMessage = null;
+        }
+      } else if (message.type === "agent-error") {
+        errorMessage = message.content ?? "Unknown error";
+        isDone = true;
+        if (rejectNextMessage) {
+          rejectNextMessage(new Error(errorMessage));
+          resolveNextMessage = null;
+          rejectNextMessage = null;
+        }
       }
+    });
+    if (!relayClient.isConnected()) {
+      unsubscribeConnection();
+      unsubscribeMessage();
+      signal.removeEventListener("abort", handleAbort);
+      throw new Error("Relay connection is not open");
+    }
+    const didSendRequest = relayClient.sendAgentRequest(agentId, contextWithSession);
+    if (!didSendRequest) {
+      unsubscribeConnection();
+      unsubscribeMessage();
+      signal.removeEventListener("abort", handleAbort);
+      throw new Error("Failed to send agent request: connection not open");
     }
-  } finally {
-    signal.removeEventListener("abort", handleAbort);
-  }
-};
-var createCachedConnectionChecker = (checkConnection, ttlMs = CONNECTION_CHECK_TTL_MS) => {
-  let cache = null;
-  return async () => {
-    const now = Date.now();
-    if (cache && now - cache.timestamp < ttlMs) return cache.result;
     try {
-      const result = await checkConnection();
-      cache = { result, timestamp: now };
-      return result;
-    } catch {
-      cache = { result: false, timestamp: now };
-      return false;
+      while (true) {
+        if (messageQueue.length > 0) {
+          const next = messageQueue.shift();
+          if (next !== void 0) {
+            yield next;
+          }
+          continue;
+        }
+        if (isDone || signal.aborted) {
+          break;
+        }
+        const result = await new Promise(
+          (resolve, reject) => {
+            resolveNextMessage = resolve;
+            rejectNextMessage = reject;
+          }
+        );
+        if (result.done) break;
+        yield result.value;
+      }
+      if (errorMessage) {
+        throw new Error(errorMessage);
+      }
+    } finally {
+      signal.removeEventListener("abort", handleAbort);
+      unsubscribeConnection();
+      unsubscribeMessage();
+    }
+  };
+  const abort = async (sessionId) => {
+    relayClient.abortAgent(agentId, sessionId);
+  };
+  const waitForOperationResponse = (sessionId) => {
+    return new Promise((resolve, reject) => {
+      let didCleanup = false;
+      const cleanup = () => {
+        if (didCleanup) return;
+        didCleanup = true;
+        unsubscribeMessage();
+        unsubscribeConnection();
+      };
+      const unsubscribeMessage = relayClient.onMessage((message) => {
+        if (message.sessionId !== sessionId) return;
+        cleanup();
+        if (message.type === "agent-done") {
+          resolve();
+        } else if (message.type === "agent-error") {
+          reject(new Error(message.content ?? "Operation failed"));
+        }
+      });
+      const unsubscribeConnection = relayClient.onConnectionChange((connected) => {
+        if (!connected) {
+          cleanup();
+          reject(new Error("Connection lost while waiting for operation response"));
+        }
+      });
+    });
+  };
+  const undo = async () => {
+    const sessionId = `undo-${agentId}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    const didSend = relayClient.undoAgent(agentId, sessionId);
+    if (!didSend) {
+      throw new Error("Failed to send undo request: connection not open");
     }
+    return waitForOperationResponse(sessionId);
+  };
+  const redo = async () => {
+    const sessionId = `redo-${agentId}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    const didSend = relayClient.redoAgent(agentId, sessionId);
+    if (!didSend) {
+      throw new Error("Failed to send redo request: connection not open");
+    }
+    return waitForOperationResponse(sessionId);
+  };
+  return {
+    send,
+    abort,
+    undo,
+    redo,
+    checkConnection,
+    supportsResume: true,
+    supportsFollowUp: true
   };
 };
-
-// src/constants.ts
-var DEFAULT_PORT = 6567;
-var COMPLETED_STATUS = "Completed successfully";
+var defaultRelayClient = null;
+var getDefaultRelayClient = () => {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  if (window.__REACT_GRAB_RELAY__) {
+    defaultRelayClient = window.__REACT_GRAB_RELAY__;
+    return defaultRelayClient;
+  }
+  if (!defaultRelayClient) {
+    defaultRelayClient = createRelayClient();
+    window.__REACT_GRAB_RELAY__ = defaultRelayClient;
+  }
+  return defaultRelayClient;
+};
 
 // src/client.ts
-var DEFAULT_SERVER_URL = `http://localhost:${DEFAULT_PORT}`;
-var isReactGrabApi = (value) => typeof value === "object" && value !== null && "setAgent" in value;
-var createOpenCodeAgentProvider = (options = {}) => {
-  const { serverUrl = DEFAULT_SERVER_URL, getOptions } = options;
-  const mergeOptions = (contextOptions) => ({
-    ...getOptions?.() ?? {},
-    ...contextOptions ?? {}
+var AGENT_ID = "opencode";
+var isReactGrabApi = (value) => typeof value === "object" && value !== null && "registerPlugin" in value;
+var createOpenCodeAgentProvider = (providerOptions = {}) => {
+  const relayClient = providerOptions.relayClient ?? getDefaultRelayClient();
+  if (!relayClient) {
+    throw new Error("RelayClient is required in browser environments");
+  }
+  return createRelayAgentProvider({
+    relayClient,
+    agentId: AGENT_ID
   });
-  const checkConnection = createCachedConnectionChecker(async () => {
-    const response = await fetch(`${serverUrl}/health`, { method: "GET" });
-    return response.ok;
-  }, CONNECTION_CHECK_TTL_MS);
-  return {
-    send: async function* (context, signal) {
-      const combinedContext = {
-        ...context,
-        options: mergeOptions(context.options)
-      };
-      yield* streamAgentStatusFromServer(
-        { serverUrl, completedStatus: COMPLETED_STATUS },
-        combinedContext,
-        signal
-      );
-    },
-    resume: async function* (sessionId, signal, storage) {
-      const storedContext = getStoredAgentContext(storage, sessionId);
-      const context = {
-        content: storedContext.content,
-        prompt: storedContext.prompt,
-        options: storedContext.options,
-        sessionId: storedContext.sessionId ?? sessionId
-      };
-      const combinedContext = {
-        ...context,
-        options: mergeOptions(context.options)
-      };
-      yield "Resuming...";
-      yield* streamAgentStatusFromServer(
-        { serverUrl, completedStatus: COMPLETED_STATUS },
-        combinedContext,
-        signal
-      );
-    },
-    supportsResume: true,
-    supportsFollowUp: true,
-    checkConnection,
-    undo: async () => {
-      try {
-        await fetch(`${serverUrl}/undo`, { method: "POST" });
-      } catch {
-      }
-    }
-  };
 };
 var attachAgent = async () => {
   if (typeof window === "undefined") return;
-  const provider = createOpenCodeAgentProvider();
+  const relayClient = getDefaultRelayClient();
+  if (!relayClient) return;
+  try {
+    await relayClient.connect();
+  } catch {
+    return;
+  }
+  const provider = createRelayAgentProvider({
+    relayClient,
+    agentId: AGENT_ID
+  });
   const attach = (api) => {
-    api.setAgent({ provider, storage: sessionStorage });
+    const agent = { provider, storage: sessionStorage };
+    const plugin = {
+      name: "opencode-agent",
+      actions: [
+        {
+          id: "edit-with-opencode",
+          label: "Edit with OpenCode",
+          shortcut: "Enter",
+          onAction: (actionContext) => {
+            actionContext.enterPromptMode?.(agent);
+          },
+          agent
+        }
+      ]
+    };
+    api.registerPlugin(plugin);
   };
   const existingApi = window.__REACT_GRAB__;
   if (isReactGrabApi(existingApi)) {