@react-grab/copilot 0.1.16

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Aiden Bai
+
+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/dist/cli.cjs

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+'use strict';
+
+var child_process = require('child_process');
+var fs = require('fs');
+var path = require('path');
+
+var realScriptPath = fs.realpathSync(process.argv[1]);
+var scriptDir = path.dirname(realScriptPath);
+var serverPath = path.join(scriptDir, "server.cjs");
+var child = child_process.spawn(
+  process.execPath,
+  ["-e", `require(${JSON.stringify(serverPath)}).startServer()`],
+  {
+    detached: true,
+    stdio: "inherit"
+  }
+);
+child.unref();
+process.exit(0);

package/dist/cli.d.cts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+import { spawn } from 'child_process';
+import { realpathSync } from 'fs';
+import { dirname, join } from 'path';
+
+var realScriptPath = realpathSync(process.argv[1]);
+var scriptDir = dirname(realScriptPath);
+var serverPath = join(scriptDir, "server.cjs");
+var child = spawn(
+  process.execPath,
+  ["-e", `require(${JSON.stringify(serverPath)}).startServer()`],
+  {
+    detached: true,
+    stdio: "inherit"
+  }
+);
+child.unref();
+process.exit(0);

package/dist/client.cjs

@@ -0,0 +1,451 @@
+'use strict';
+
+// ../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);
+  };
+  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);
+        }
+      }
+      for (const callback of messageCallbacks) {
+        callback(message);
+      }
+    } catch {
+    }
+  };
+  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 {
+    connect,
+    disconnect,
+    isConnected,
+    sendAgentRequest,
+    abortAgent,
+    undoAgent,
+    redoAgent,
+    onMessage,
+    onHandlersChange,
+    onConnectionChange,
+    getAvailableHandlers
+  };
+};
+var createRelayAgentProvider = (options) => {
+  const { relayClient, agentId } = options;
+  const checkConnection = async () => {
+    if (!relayClient.isConnected()) {
+      try {
+        await relayClient.connect();
+      } catch {
+        return false;
+      }
+    }
+    return relayClient.getAvailableHandlers().includes(agentId);
+  };
+  const send = async function* (context, signal) {
+    if (signal.aborted) {
+      throw new DOMException("Aborted", "AbortError");
+    }
+    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 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, { once: true });
+    const handleConnectionChange = (connected) => {
+      if (!connected && !isDone) {
+        errorMessage = "Relay connection lost";
+        isDone = true;
+        if (rejectNextMessage) {
+          rejectNextMessage(new Error(errorMessage));
+          resolveNextMessage = null;
+          rejectNextMessage = null;
+        }
+      }
+    };
+    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");
+    }
+    try {
+      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
+  };
+};
+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;
+};
+var isReactGrabApi = (value) => typeof value === "object" && value !== null && "registerPlugin" in value;
+var createProviderClientPlugin = (config) => {
+  const createAgentProvider = (providerOptions = {}) => {
+    const relayClient = providerOptions.relayClient ?? getDefaultRelayClient();
+    if (!relayClient) {
+      throw new Error("RelayClient is required in browser environments");
+    }
+    return createRelayAgentProvider({
+      relayClient,
+      agentId: config.agentId
+    });
+  };
+  const attachAgent2 = async () => {
+    if (typeof window === "undefined") return;
+    const relayClient = getDefaultRelayClient();
+    if (!relayClient) return;
+    try {
+      await relayClient.connect();
+    } catch {
+      return;
+    }
+    const provider = createRelayAgentProvider({
+      relayClient,
+      agentId: config.agentId
+    });
+    const attach = (api) => {
+      const agent = { provider, storage: sessionStorage };
+      api.registerPlugin({
+        name: config.pluginName,
+        actions: [
+          {
+            id: config.actionId,
+            label: config.actionLabel,
+            shortcut: "Enter",
+            onAction: (actionContext) => {
+              actionContext.enterPromptMode?.(agent);
+            },
+            agent
+          }
+        ]
+      });
+    };
+    const existingApi = window.__REACT_GRAB__;
+    if (isReactGrabApi(existingApi)) {
+      attach(existingApi);
+      return;
+    }
+    window.addEventListener(
+      "react-grab:init",
+      (event) => {
+        if (!(event instanceof CustomEvent)) return;
+        if (!isReactGrabApi(event.detail)) return;
+        attach(event.detail);
+      },
+      { once: true }
+    );
+    const apiAfterListener = window.__REACT_GRAB__;
+    if (isReactGrabApi(apiAfterListener)) {
+      attach(apiAfterListener);
+    }
+  };
+  return { createAgentProvider, attachAgent: attachAgent2 };
+};
+
+// src/client.ts
+var { createAgentProvider: createCopilotAgentProvider, attachAgent } = createProviderClientPlugin({
+  agentId: "copilot",
+  pluginName: "copilot-agent",
+  actionId: "edit-with-copilot",
+  actionLabel: "Edit with Copilot"
+});
+attachAgent();
+
+exports.attachAgent = attachAgent;
+exports.createCopilotAgentProvider = createCopilotAgentProvider;

package/dist/client.d.cts

@@ -0,0 +1,9 @@
+import * as _react_grab_relay_client from '@react-grab/relay/client';
+export { AgentCompleteResult } from 'react-grab/core';
+
+declare const createCopilotAgentProvider: (providerOptions?: {
+    relayClient?: _react_grab_relay_client.RelayClient;
+}) => _react_grab_relay_client.AgentProvider;
+declare const attachAgent: () => Promise<void>;
+
+export { attachAgent, createCopilotAgentProvider };

package/dist/client.d.ts

@@ -0,0 +1,9 @@
+import * as _react_grab_relay_client from '@react-grab/relay/client';
+export { AgentCompleteResult } from 'react-grab/core';
+
+declare const createCopilotAgentProvider: (providerOptions?: {
+    relayClient?: _react_grab_relay_client.RelayClient;
+}) => _react_grab_relay_client.AgentProvider;
+declare const attachAgent: () => Promise<void>;
+
+export { attachAgent, createCopilotAgentProvider };

package/dist/client.global.js

@@ -0,0 +1,2 @@
+var ReactGrabCopilot=(function(exports){'use strict';var q=4722,O=3e3,D="token",x=(s={})=>{let r=s.serverUrl??`ws://localhost:${q}`,w=s.autoReconnect??true,A=s.reconnectIntervalMs??O,h=s.token,i=null,f=false,p=[],d=null,e=null,t=null,C=false,y=new Set,g=new Set,o=new Set,c=()=>{!w||d||C||(d=setTimeout(()=>{d=null,b().catch(()=>{});},A));},l=n=>{try{let a=JSON.parse(n.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{}},b=()=>i?.readyState===WebSocket.OPEN?Promise.resolve():e||(C=false,e=new Promise((n,a)=>{t=a;let S=h?`${r}?${D}=${encodeURIComponent(h)}`:r;i=new WebSocket(S),i.onopen=()=>{e=null,t=null,f=true;for(let m of o)m(true);n();},i.onmessage=l,i.onclose=()=>{t&&(t(new Error("WebSocket connection closed")),t=null),e=null,f=false,p=[];for(let m of g)m(p);for(let m of o)m(false);c();},i.onerror=()=>{e=null,t=null,f=false,a(new Error("WebSocket connection failed"));};}),e),R=()=>{C=true,d&&(clearTimeout(d),d=null),t&&(t(new Error("Connection aborted")),t=null),e=null,i?.close(),i=null,f=false,p=[];},M=()=>f,v=n=>i?.readyState===WebSocket.OPEN?(i.send(JSON.stringify(n)),true):false;return {connect:b,disconnect:R,isConnected:M,sendAgentRequest:(n,a)=>v({type:"agent-request",agentId:n,sessionId:a.sessionId,context:a}),abortAgent:(n,a)=>{v({type:"agent-abort",agentId:n,sessionId:a});},undoAgent:(n,a)=>v({type:"agent-undo",agentId:n,sessionId:a}),redoAgent:(n,a)=>v({type:"agent-redo",agentId:n,sessionId:a}),onMessage:n=>(y.add(n),()=>y.delete(n)),onHandlersChange:n=>(g.add(n),()=>g.delete(n)),onConnectionChange:n=>(o.add(n),queueMicrotask(()=>{o.has(n)&&n(f);}),()=>o.delete(n)),getAvailableHandlers:()=>p}},L=s=>{let{relayClient:r,agentId:w}=s,A=async()=>{if(!r.isConnected())try{await r.connect();}catch{return  false}return r.getAvailableHandlers().includes(w)},h=async function*(e,t){if(t.aborted)throw new DOMException("Aborted","AbortError");yield "Connecting\u2026";let C=e.sessionId??`session-${Date.now()}-${Math.random().toString(36).slice(2)}`,y={...e,sessionId:C},g=[],o=null,c=null,l=false,b=null,R=()=>{r.abortAgent(w,C),l=true,o&&(o({value:void 0,done:true}),o=null,c=null);};t.addEventListener("abort",R,{once:true});let M=u=>{!u&&!l&&(b="Relay connection lost",l=true,c&&(c(new Error(b)),o=null,c=null));},v=r.onConnectionChange(M),I=r.onMessage(u=>{if(u.sessionId===C)if(u.type==="agent-status"&&u.content){if(g.push(u.content),o){let E=g.shift();E!==void 0&&(o({value:E,done:false}),o=null,c=null);}}else u.type==="agent-done"?(l=true,o&&(o({value:void 0,done:true}),o=null,c=null)):u.type==="agent-error"&&(b=u.content??"Unknown error",l=true,c&&(c(new Error(b)),o=null,c=null));});if(!r.isConnected())throw v(),I(),t.removeEventListener("abort",R),new Error("Relay connection is not open");if(!r.sendAgentRequest(w,y))throw v(),I(),t.removeEventListener("abort",R),new Error("Failed to send agent request: connection not open");try{for(;;){if(g.length>0){let E=g.shift();E!==void 0&&(yield E);continue}if(l||t.aborted)break;let u=await new Promise((E,k)=>{o=E,c=k;});if(u.done)break;yield u.value;}if(b)throw new Error(b)}finally{t.removeEventListener("abort",R),v(),I();}},i=async e=>{r.abortAgent(w,e);},f=e=>new Promise((t,C)=>{let y=false,g=()=>{y||(y=true,o(),c());},o=r.onMessage(l=>{l.sessionId===e&&(g(),l.type==="agent-done"?t():l.type==="agent-error"&&C(new Error(l.content??"Operation failed")));}),c=r.onConnectionChange(l=>{l||(g(),C(new Error("Connection lost while waiting for operation response")));});});return {send:h,abort:i,undo:async()=>{let e=`undo-${w}-${Date.now()}-${Math.random().toString(36).slice(2)}`;if(!r.undoAgent(w,e))throw new Error("Failed to send undo request: connection not open");return f(e)},redo:async()=>{let e=`redo-${w}-${Date.now()}-${Math.random().toString(36).slice(2)}`;if(!r.redoAgent(w,e))throw new Error("Failed to send redo request: connection not open");return f(e)},checkConnection:A,supportsResume:true,supportsFollowUp:true}},_=null,T=()=>typeof window>"u"?null:window.__REACT_GRAB_RELAY__?(_=window.__REACT_GRAB_RELAY__,_):(_||(_=x(),window.__REACT_GRAB_RELAY__=_),_),P=s=>typeof s=="object"&&s!==null&&"registerPlugin"in s,N=s=>({createAgentProvider:(A={})=>{let h=A.relayClient??T();if(!h)throw new Error("RelayClient is required in browser environments");return L({relayClient:h,agentId:s.agentId})},attachAgent:async()=>{if(typeof window>"u")return;let A=T();if(!A)return;try{await A.connect();}catch{return}let h=L({relayClient:A,agentId:s.agentId}),i=d=>{let e={provider:h,storage:sessionStorage};d.registerPlugin({name:s.pluginName,actions:[{id:s.actionId,label:s.actionLabel,shortcut:"Enter",onAction:t=>{t.enterPromptMode?.(e);},agent:e}]});},f=window.__REACT_GRAB__;if(P(f)){i(f);return}window.addEventListener("react-grab:init",d=>{d instanceof CustomEvent&&P(d.detail)&&i(d.detail);},{once:true});let p=window.__REACT_GRAB__;P(p)&&i(p);}});var {createAgentProvider:Y,attachAgent:U}=N({agentId:"copilot",pluginName:"copilot-agent",actionId:"edit-with-copilot",actionLabel:"Edit with Copilot"});U();
+exports.attachAgent=U;exports.createCopilotAgentProvider=Y;return exports;})({});