@nice-code/action 0.4.4 → 0.4.6

package/build/index.js

@@ -1870,6 +1870,143 @@ class ConnectionTransportManager {
   }
 }
 
+// src/ActionRuntime/Handler/ExternalClient/ActionExternalClientHandler.ts
+class ActionExternalClientHandler extends ActionHandler {
+  externalClient;
+  handlerType = "external" /* external */;
+  cuid;
+  _defaultTimeout;
+  _transportCache = new Map;
+  transportManager = new ConnectionTransportManager(this._transportCache);
+  _incomingActionDataListeners = [];
+  actionRouter = new ActionRouter({
+    contextType: "handler_route" /* handler_route */,
+    handler: this
+  });
+  constructor({
+    runtimeCoordinate: externalClientSpecifier,
+    transports,
+    defaultTimeout
+  }) {
+    super();
+    this.externalClient = externalClientSpecifier;
+    this.cuid = nanoid4();
+    this._defaultTimeout = defaultTimeout ?? DEFAULT_TRANSPORT_TIMEOUT;
+    for (const transport of transports) {
+      const connection = transport._createConnection({
+        resolvers: {
+          onIncomingActionDataJson: (json) => {
+            for (const l of this._incomingActionDataListeners)
+              l(json);
+          }
+        }
+      });
+      connection.definition = transport;
+      this.transportManager.addTransport(connection);
+    }
+  }
+  forDomain(domain) {
+    this.actionRouter.forDomain(domain, true);
+    return this;
+  }
+  forAction(action) {
+    this.actionRouter.forAction(action, true);
+    return this;
+  }
+  forActionIds(domain, ids) {
+    this.actionRouter.forActionIds(domain, ids, true);
+    return this;
+  }
+  _setIncomingActionDataListener(listener) {
+    this._incomingActionDataListeners.push(listener);
+  }
+  async handleActionRequest(action, config) {
+    const localRuntime = config?.targetLocalRuntime ?? ActionRuntime.getDefault();
+    const localClient = localRuntime.coordinate;
+    const incomingTimeout = config?.timeout ?? this._defaultTimeout;
+    const parentCuid = peekHandlerCuid();
+    const callSite = action._callSite ?? new Error().stack;
+    const { methods, transport } = await this.transportManager.getReadyTransport({
+      action,
+      localClient,
+      externalClient: this.externalClient
+    });
+    action.context.addRouteItem({
+      runtime: localClient,
+      handler: this.toHandlerRouteItem(transport, {
+        action,
+        localClient,
+        externalClient: this.externalClient
+      }),
+      time: Date.now()
+    });
+    const runningAction = new RunningAction({
+      context: action.context,
+      request: action,
+      parentCuid,
+      callSite
+    });
+    localRuntime.registerRunningAction(runningAction);
+    const routeActionParams = {
+      action,
+      runningAction,
+      localClient,
+      externalClient: this.externalClient,
+      timeout: incomingTimeout
+    };
+    if (action.type === "request" /* request */ && methods.updateRunConfig != null) {
+      const runConfig = methods.updateRunConfig(routeActionParams);
+      routeActionParams.timeout = runConfig?.timeout ?? incomingTimeout;
+    }
+    try {
+      methods.sendActionData(routeActionParams);
+    } catch (err3) {
+      runningAction._abort(err3);
+    }
+    return runningAction;
+  }
+  async sendReturnPayload(payload, config) {
+    const localClient = config.targetLocalRuntime.coordinate;
+    try {
+      const { methods } = await this.transportManager.getReadyTransport({
+        action: payload,
+        localClient,
+        externalClient: this.externalClient
+      });
+      if (methods.sendReturnData == null)
+        return false;
+      methods.sendReturnData(payload);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  toJsonObject() {
+    return {
+      type: this.handlerType,
+      client: this.externalClient
+    };
+  }
+  toHandlerRouteItem(transport, input) {
+    return {
+      type: this.handlerType,
+      client: this.externalClient,
+      transOrd: transport.transOrd,
+      transType: transport.type,
+      transInfo: transport.getRouteInfo(input)
+    };
+  }
+  clearTransportCache() {
+    this._transportCache.clear();
+  }
+}
+var createExternalClientHandler = (config) => {
+  return new ActionExternalClientHandler(config);
+};
+// src/ActionRuntime/Handler/ExternalClient/Transport/Transport.ts
+class Transport {
+}
+
 // src/ActionRuntime/Handler/ExternalClient/Transport/helpers/addTransportStatusMetadata.ts
 function addTransportStatusMetadata(transportStatus) {
   if (transportStatus.status === "ready" /* ready */) {
@@ -1902,19 +2039,23 @@ function addTransportStatusMetadata(transportStatus) {
   };
 }
 
-// src/ActionRuntime/Handler/ExternalClient/Transport/Transport.ts
+// src/ActionRuntime/Handler/ExternalClient/Transport/TransportConnection.ts
 var transportOrd = 0;
 
-class Transport {
+class TransportConnection {
   def;
   transOrd = transportOrd++;
   type;
   initialized;
+  definition;
   constructor(def) {
     this.def = def;
     this.type = def.type;
     this.initialized = def.initialize();
   }
+  getRouteInfo(input) {
+    return this.definition?.getRouteInfo(input);
+  }
   _getCacheKey(input) {
     const parts = this.initialized.getTransportCacheKey?.(input);
     if (parts == null)
@@ -1958,8 +2099,8 @@ class Transport {
   }
 }
 
-// src/ActionRuntime/Handler/ExternalClient/Transport/Custom/TransportCustom.ts
-class TransportCustom extends Transport {
+// src/ActionRuntime/Handler/ExternalClient/Transport/Custom/CustomConnection.ts
+class CustomConnection extends TransportConnection {
   constructor(def) {
     super({
       ...def,
@@ -1975,9 +2116,65 @@ class TransportCustom extends Transport {
   }
 }
 
-// src/ActionRuntime/Handler/ExternalClient/Transport/Http/TransportHttp.ts
+// src/ActionRuntime/Handler/ExternalClient/Transport/Custom/CustomTransport.ts
+class CustomTransport extends Transport {
+  options;
+  type = "custom" /* custom */;
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  _createConnection(_ctx) {
+    const options = this.options;
+    return new CustomConnection({
+      initialize: () => ({
+        getTransportCacheKey: options.getTransportCacheKey,
+        getTransport: options.getTransport ?? (() => ({
+          status: "ready" /* ready */,
+          readyData: {
+            sendActionData: options.sendActionData,
+            sendReturnData: options.sendReturnData,
+            updateRunConfig: options.updateRunConfig,
+            closeTransport: options.closeTransport ?? (() => {})
+          }
+        }))
+      })
+    });
+  }
+  getRouteInfo(input) {
+    if (this.options.getRouteInfo != null)
+      return this.options.getRouteInfo(input);
+    return {
+      type: "custom" /* custom */,
+      summary: this.options.label ?? "custom"
+    };
+  }
+}
+// src/ActionRuntime/Handler/ExternalClient/Transport/err_nice_transport_ws.ts
+import { err as err3 } from "@nice-code/error";
+var EErrId_NiceTransport_WebSocket;
+((EErrId_NiceTransport_WebSocket2) => {
+  EErrId_NiceTransport_WebSocket2["ws_disconnected"] = "ws_disconnected";
+  EErrId_NiceTransport_WebSocket2["ws_create_failed"] = "ws_create_failed";
+  EErrId_NiceTransport_WebSocket2["ws_error"] = "ws_error";
+})(EErrId_NiceTransport_WebSocket ||= {});
+var err_nice_transport_ws = err_nice_transport.createChildDomain({
+  domain: "ws_transport",
+  schema: {
+    ["ws_disconnected" /* ws_disconnected */]: err3({
+      message: () => `WebSocket transport disconnected.`
+    }),
+    ["ws_create_failed" /* ws_create_failed */]: err3({
+      message: ({ originalError }) => `Failed to create WebSocket transport.${originalError ? ` Original error: ${originalError.message}` : ""}`
+    }),
+    ["ws_error" /* ws_error */]: err3({
+      message: ({ originalError }) => `WebSocket transport error.${originalError ? ` Original error: ${originalError.message}` : ""}`
+    })
+  }
+});
+// src/ActionRuntime/Handler/ExternalClient/Transport/Http/HttpConnection.ts
 import { castNiceError as castNiceError3, isNiceErrorObject as isNiceErrorObject2, NiceError as NiceError2 } from "@nice-code/error";
-class TransportHttp extends Transport {
+class HttpConnection extends TransportConnection {
   constructor(def) {
     super({
       ...def,
@@ -1988,7 +2185,7 @@ class TransportHttp extends Transport {
     return {
       sendActionData: (input) => {
         const request = methods.createRequest(input);
-        this.send({ ...input, params: { request }, runningAction: input.runningAction }).catch((err3) => input.runningAction._abort(err3));
+        this.send({ ...input, params: { request }, runningAction: input.runningAction }).catch((err4) => input.runningAction._abort(err4));
       },
       updateRunConfig: methods.updateRunConfig
     };
@@ -2048,7 +2245,7 @@ class TransportHttp extends Transport {
           try {
             text = await res.text();
           } catch (e) {
-            console.warn(`Failed to read error response body for failed HTTP request in TransportHttp:`, e);
+            console.warn(`Failed to read error response body for failed HTTP request in HttpConnection:`, e);
           }
           throw err_nice_transport.fromId("send_failed" /* send_failed */, {
             actionState: action.type,
@@ -2068,18 +2265,18 @@ class TransportHttp extends Transport {
         }
         runningAction._completeWithResult(action._domain.hydrateResultPayload(json));
       }
-    } catch (err3) {
+    } catch (err4) {
       if (timedOut) {
         throw err_nice_transport.fromId("timeout" /* timeout */, { timeout });
       }
-      if (err3 instanceof NiceError2) {
-        throw err3;
+      if (err4 instanceof NiceError2) {
+        throw err4;
       }
       throw err_nice_transport.fromId("send_failed" /* send_failed */, {
         actionState: action.type,
         actionId: action.id,
-        message: err3 instanceof Error ? err3.message : String(err3)
-      }).withOriginError(err3 instanceof Error ? err3 : undefined);
+        message: err4 instanceof Error ? err4.message : String(err4)
+      }).withOriginError(err4 instanceof Error ? err4 : undefined);
     } finally {
       clearTimeout(timeoutId);
       unsubscribe();
@@ -2087,29 +2284,57 @@ class TransportHttp extends Transport {
   }
 }
 
-// src/ActionRuntime/Handler/ExternalClient/Transport/err_nice_transport_ws.ts
-import { err as err3 } from "@nice-code/error";
-var EErrId_NiceTransport_WebSocket;
-((EErrId_NiceTransport_WebSocket2) => {
-  EErrId_NiceTransport_WebSocket2["ws_disconnected"] = "ws_disconnected";
-  EErrId_NiceTransport_WebSocket2["ws_create_failed"] = "ws_create_failed";
-  EErrId_NiceTransport_WebSocket2["ws_error"] = "ws_error";
-})(EErrId_NiceTransport_WebSocket ||= {});
-var err_nice_transport_ws = err_nice_transport.createChildDomain({
-  domain: "ws_transport",
-  schema: {
-    ["ws_disconnected" /* ws_disconnected */]: err3({
-      message: () => `WebSocket transport disconnected.`
-    }),
-    ["ws_create_failed" /* ws_create_failed */]: err3({
-      message: ({ originalError }) => `Failed to create WebSocket transport.${originalError ? ` Original error: ${originalError.message}` : ""}`
-    }),
-    ["ws_error" /* ws_error */]: err3({
-      message: ({ originalError }) => `WebSocket transport error.${originalError ? ` Original error: ${originalError.message}` : ""}`
-    })
+// src/ActionRuntime/Handler/ExternalClient/Transport/Http/HttpTransport.ts
+function resolveMaybe(value, input) {
+  return typeof value === "function" ? value(input) : value;
+}
+function shortPath(url) {
+  try {
+    return new URL(url).pathname || url;
+  } catch {
+    return url;
   }
-});
+}
 
+class HttpTransport extends Transport {
+  options;
+  type = "http" /* http */;
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  _resolveRequest(input) {
+    if (this.options.createRequest != null)
+      return this.options.createRequest(input);
+    return {
+      url: resolveMaybe(this.options.url, input),
+      headers: this.options.headers != null ? resolveMaybe(this.options.headers, input) : undefined
+    };
+  }
+  _createConnection(_ctx) {
+    return new HttpConnection({
+      initialize: () => ({
+        getTransportCacheKey: this.options.getTransportCacheKey,
+        getTransport: () => ({
+          status: "ready" /* ready */,
+          readyData: {
+            createRequest: (input) => this._resolveRequest(input),
+            updateRunConfig: this.options.updateRunConfig
+          }
+        })
+      })
+    });
+  }
+  getRouteInfo(input) {
+    const { url } = this._resolveRequest(input);
+    return {
+      type: "http" /* http */,
+      method: "POST",
+      url,
+      summary: `POST ${shortPath(url)}`
+    };
+  }
+}
 // src/ActionRuntime/Handler/ExternalClient/Transport/helpers/createUnsetTransportResolvers.ts
 var createUnsetTransportResolvers = (type) => ({
   onIncomingActionDataJson: (json) => {
@@ -2117,10 +2342,21 @@ var createUnsetTransportResolvers = (type) => ({
   }
 });
 
-// src/ActionRuntime/Handler/ExternalClient/Transport/WebSocket/TransportWebSocket.ts
-class TransportWebSocket extends Transport {
+// src/ActionRuntime/Handler/ExternalClient/Transport/WebSocket/ws_util.ts
+function shortWs(url) {
+  try {
+    const u = new URL(url);
+    return `${u.host}${u.pathname}`;
+  } catch {
+    return url;
+  }
+}
+
+// src/ActionRuntime/Handler/ExternalClient/Transport/WebSocket/WebSocketConnection.ts
+class WebSocketConnection extends TransportConnection {
   resolvers;
   _abortSet = new Set;
+  _liveSocketUrl;
   constructor(def, resolvers) {
     super({ ...def, type: "ws" /* ws */ });
     this.resolvers = resolvers ?? createUnsetTransportResolvers("ws" /* ws */);
@@ -2181,9 +2417,22 @@ class TransportWebSocket extends Transport {
       readyData: this._finalizeTransportMethods(transportStatusInfo.readyData)
     };
   }
+  getRouteInfo(input) {
+    const base = this.definition?.getRouteInfo(input);
+    if (base?.url != null || this._liveSocketUrl == null)
+      return base;
+    return {
+      type: "ws" /* ws */,
+      ...base,
+      url: this._liveSocketUrl,
+      summary: `ws ${shortWs(this._liveSocketUrl)}`
+    };
+  }
   _finalizeTransportMethods(wsData) {
     const ws = wsData.ws;
     const disconnectListeners = [];
+    if (ws.url != null && ws.url !== "")
+      this._liveSocketUrl = ws.url;
     const sendActionData = (inputs) => {
       const { action, runningAction, timeout } = inputs;
       if (action.type === "request" /* request */) {
@@ -2252,140 +2501,53 @@ class TransportWebSocket extends Transport {
   }
 }
 
-// src/ActionRuntime/Handler/ExternalClient/ActionExternalClientHandler.ts
-class ActionExternalClientHandler extends ActionHandler {
-  externalClient;
-  handlerType = "external" /* external */;
-  cuid;
-  _defaultTimeout;
-  _transportCache = new Map;
-  transportManager = new ConnectionTransportManager(this._transportCache);
-  _incomingActionDataListeners = [];
-  actionRouter = new ActionRouter({
-    contextType: "handler_route" /* handler_route */,
-    handler: this
-  });
-  constructor({
-    externalClientSpecifier,
-    transports,
-    defaultTimeout
-  }) {
+// src/ActionRuntime/Handler/ExternalClient/Transport/WebSocket/WebSocketTransport.ts
+function resolveMaybe2(value, input) {
+  return typeof value === "function" ? value(input) : value;
+}
+
+class WebSocketTransport extends Transport {
+  options;
+  type = "ws" /* ws */;
+  constructor(options) {
     super();
-    this.externalClient = externalClientSpecifier;
-    this.cuid = nanoid4();
-    this._defaultTimeout = defaultTimeout ?? DEFAULT_TRANSPORT_TIMEOUT;
-    for (const def of transports) {
-      if (def.type === "ws" /* ws */) {
-        this.transportManager.addTransport(new TransportWebSocket(def, {
-          onIncomingActionDataJson: (json) => {
-            for (const l of this._incomingActionDataListeners)
-              l(json);
+    this.options = options;
+  }
+  _createSocket(input) {
+    if (this.options.createWebSocket != null)
+      return this.options.createWebSocket(input);
+    if (this.options.url == null) {
+      throw new Error("WebSocketTransport requires `url` or `createWebSocket` when not using `getTransport`.");
+    }
+    return new WebSocket(resolveMaybe2(this.options.url, input));
+  }
+  _createConnection(ctx) {
+    const { url, getTransportCacheKey, getTransport } = this.options;
+    return new WebSocketConnection({
+      initialize: () => ({
+        getTransportCacheKey: getTransportCacheKey ?? (url != null ? (input) => [resolveMaybe2(url, input)] : undefined),
+        getTransport: getTransport ?? ((input) => ({
+          status: "ready" /* ready */,
+          readyData: {
+            ws: this._createSocket(input),
+            formatMessage: this.options.formatMessage,
+            updateRunConfig: this.options.updateRunConfig
           }
-        }));
-      } else if (def.type === "http" /* http */) {
-        this.transportManager.addTransport(new TransportHttp(def));
-      } else if (def.type === "custom" /* custom */) {
-        this.transportManager.addTransport(new TransportCustom(def));
-      } else {
-        throw err_nice_action.fromId("not_implemented" /* not_implemented */, {
-          label: `transport type "${def.type}"`
-        });
-      }
-    }
-  }
-  forDomain(domain) {
-    this.actionRouter.forDomain(domain, true);
-    return this;
-  }
-  forAction(action) {
-    this.actionRouter.forAction(action, true);
-    return this;
-  }
-  forActionIds(domain, ids) {
-    this.actionRouter.forActionIds(domain, ids, true);
-    return this;
-  }
-  _setIncomingActionDataListener(listener) {
-    this._incomingActionDataListeners.push(listener);
-  }
-  async handleActionRequest(action, config) {
-    const localRuntime = config?.targetLocalRuntime ?? ActionRuntime.getDefault();
-    const localClient = localRuntime.coordinate;
-    const incomingTimeout = config?.timeout ?? this._defaultTimeout;
-    const parentCuid = peekHandlerCuid();
-    const callSite = action._callSite ?? new Error().stack;
-    const { methods, transport } = await this.transportManager.getReadyTransport({
-      action,
-      localClient,
-      externalClient: this.externalClient
-    });
-    action.context.addRouteItem({
-      runtime: localClient,
-      handler: this.toHandlerRouteItem(transport),
-      time: Date.now()
-    });
-    const runningAction = new RunningAction({
-      context: action.context,
-      request: action,
-      parentCuid,
-      callSite
-    });
-    localRuntime.registerRunningAction(runningAction);
-    const routeActionParams = {
-      action,
-      runningAction,
-      localClient,
-      externalClient: this.externalClient,
-      timeout: incomingTimeout
-    };
-    if (action.type === "request" /* request */ && methods.updateRunConfig != null) {
-      const runConfig = methods.updateRunConfig(routeActionParams);
-      routeActionParams.timeout = runConfig?.timeout ?? incomingTimeout;
-    }
-    try {
-      methods.sendActionData(routeActionParams);
-    } catch (err4) {
-      runningAction._abort(err4);
-    }
-    return runningAction;
-  }
-  async sendReturnPayload(payload, config) {
-    const localClient = config.targetLocalRuntime.coordinate;
-    try {
-      const { methods } = await this.transportManager.getReadyTransport({
-        action: payload,
-        localClient,
-        externalClient: this.externalClient
-      });
-      if (methods.sendReturnData == null)
-        return false;
-      methods.sendReturnData(payload);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  toJsonObject() {
+        }))
+      })
+    }, ctx.resolvers);
+  }
+  getRouteInfo(input) {
+    if (this.options.getRouteInfo != null)
+      return this.options.getRouteInfo(input);
+    const url = this.options.url != null ? resolveMaybe2(this.options.url, input) : undefined;
     return {
-      type: this.handlerType,
-      client: this.externalClient
+      type: "ws" /* ws */,
+      url,
+      summary: url != null ? `ws ${shortWs(url)}` : "ws"
     };
   }
-  toHandlerRouteItem(transport) {
-    return {
-      type: this.handlerType,
-      client: this.externalClient,
-      transOrd: transport.transOrd,
-      transType: transport.type
-    };
-  }
-  clearTransportCache() {
-    this._transportCache.clear();
-  }
 }
-var createExternalClientHandler = (config) => {
-  return new ActionExternalClientHandler(config);
-};
 export {
   isActionPayload_Result_JsonObject,
   isActionPayload_Request_JsonObject,
@@ -2398,11 +2560,11 @@ export {
   createExternalClientHandler,
   createActionRootDomain,
   actionSchema,
-  TransportWebSocket,
-  TransportHttp,
+  WebSocketTransport,
   Transport,
   RuntimeCoordinate,
   RunningAction,
+  HttpTransport,
   ETransportType,
   ETransportStatus,
   ERunningActionUpdateType,
@@ -2413,6 +2575,7 @@ export {
   EErrId_NiceAction,
   EActionProgressType,
   EActionPayloadType,
+  CustomTransport,
   ActionSchema,
   ActionRuntime,
   ActionRootDomain,

package/build/types/ActionDefinition/Action/Payload/ActionPayload.types.d.ts

@@ -1,6 +1,6 @@
 import type { TInferActionError } from "../../..";
 import type { IActionHandler_ExternalClient_Json, IActionHandler_Local_Json } from "../../../ActionRuntime/Handler/ActionHandler.types";
-import type { ETransportType } from "../../../ActionRuntime/Handler/ExternalClient/Transport/Transport.types";
+import type { ETransportType, ITransportRouteInfo } from "../../../ActionRuntime/Handler/ExternalClient/Transport/Transport.types";
 import type { IActionDomain, TInferInputFromSchema, TInferOutputFromSchema } from "../../Domain/ActionDomain.types";
 import type { EActionForm, IActionBase, IActionBase_JsonObject } from "../ActionBase.types";
 import type { ActionContext } from "../Context/ActionContext";
@@ -25,6 +25,7 @@ export interface IActionPayload_Base<DT extends EActionPayloadType, DOM extends
 export type IActionRouteItemHandler = IActionHandler_Local_Json | (IActionHandler_ExternalClient_Json & {
     transType: ETransportType;
     transOrd: number;
+    transInfo?: ITransportRouteInfo;
 });
 /**
  *  [                        ]

package/build/types/ActionRuntime/Handler/ExternalClient/ActionExternalClientHandler.d.ts

@@ -10,7 +10,8 @@ import { RuntimeCoordinate } from "../../RuntimeCoordinate";
 import { ActionHandler } from "../ActionHandler";
 import { EActionHandlerType, type IActionHandler_ExternalClient, type IActionHandler_ExternalClient_Json, type IHandleActionOptions } from "../ActionHandler.types";
 import type { IActionExternalClientRequestHandlerConfig } from "./ActionExternalClientHandler.types";
-import type { Transport } from "./Transport/Transport";
+import { type ITransportRouteActionParams } from "./Transport/Transport.types";
+import type { TransportConnection } from "./Transport/TransportConnection";
 export declare class ActionExternalClientHandler extends ActionHandler<EActionHandlerType.external> implements IActionHandler_ExternalClient {
     readonly externalClient: RuntimeCoordinate;
     readonly handlerType = EActionHandlerType.external;
@@ -20,7 +21,7 @@ export declare class ActionExternalClientHandler extends ActionHandler<EActionHa
     private transportManager;
     private _incomingActionDataListeners;
     readonly actionRouter: ActionRouter<true>;
-    constructor({ externalClientSpecifier, transports, defaultTimeout, }: IActionExternalClientRequestHandlerConfig);
+    constructor({ runtimeCoordinate: externalClientSpecifier, transports, defaultTimeout, }: IActionExternalClientRequestHandlerConfig);
     forDomain<FOR_DOM extends IActionDomain>(domain: ActionDomain<FOR_DOM>): this;
     forAction<ACT_DOM extends IActionDomain, ID extends keyof ACT_DOM["actionSchema"] & string>(action: ActionCore<ACT_DOM, ID>): this;
     forActionIds<ACT_DOM extends IActionDomain, IDS extends ReadonlyArray<keyof ACT_DOM["actionSchema"] & string>>(domain: ActionDomain<ACT_DOM>, ids: IDS): this;
@@ -37,7 +38,7 @@ export declare class ActionExternalClientHandler extends ActionHandler<EActionHa
         targetLocalRuntime: ActionRuntime;
     }): Promise<boolean>;
     toJsonObject(): IActionHandler_ExternalClient_Json;
-    toHandlerRouteItem(transport: Transport): IActionRouteItemHandler;
+    toHandlerRouteItem(transport: TransportConnection, input: ITransportRouteActionParams): IActionRouteItemHandler;
     clearTransportCache(): void;
 }
 export declare const createExternalClientHandler: (config: IActionExternalClientRequestHandlerConfig) => ActionExternalClientHandler;

package/build/types/ActionRuntime/Handler/ExternalClient/ActionExternalClientHandler.types.d.ts

@@ -1,7 +1,7 @@
 import type { RuntimeCoordinate } from "../../RuntimeCoordinate";
-import type { TActionTransportDef } from "./Transport/Transport.combined.types";
+import type { Transport } from "./Transport/Transport";
 export interface IActionExternalClientRequestHandlerConfig {
     defaultTimeout?: number;
-    externalClientSpecifier: RuntimeCoordinate;
-    transports: TActionTransportDef[];
+    runtimeCoordinate: RuntimeCoordinate;
+    transports: Transport[];
 }

package/build/types/ActionRuntime/Handler/ExternalClient/Transport/ConnectionTransportManager.d.ts

@@ -1,9 +1,9 @@
-import type { Transport } from "./Transport";
 import { type IActionTransportReady, type ITransportRouteActionParams, type TTransportCache } from "./Transport.types";
+import type { TransportConnection } from "./TransportConnection";
 export declare class ConnectionTransportManager {
     private _cache;
     private _transports;
     constructor(_cache: TTransportCache);
-    addTransport(transport: Transport): void;
+    addTransport(transport: TransportConnection): void;
     getReadyTransport(routeActionParams: ITransportRouteActionParams): Promise<IActionTransportReady>;
 }