@maiaos/sdk 0.1.0-canary.44938d4.manual.1

package/dist/index.js

@@ -0,0 +1,243 @@
+import { executionCatalogGetResultSchema, installedHarnessListResultSchema, integrationApplyCodexResultSchema, integrationApplyPiRpcResultSchema, integrationPlanCodexResultSchema, integrationPlanPiRpcResultSchema, integrationRemoveCodexResultSchema, integrationRemovePiRpcResultSchema, integrationStatusCodexResultSchema, integrationStatusPiRpcResultSchema, invocationContextShowResultSchema, liveTerminalCloseResultSchema, liveTerminalControllerAcquireResultSchema, liveTerminalControllerReleaseResultSchema, liveTerminalControllerRequestResultSchema, liveTerminalControllerRequestShowResultSchema, liveTerminalResizeResultSchema, liveTerminalSignalResultSchema, liveTerminalWriteResultSchema, localNodeOperationErrorCodeSchema, localNodeRequestPayloadSchema, localNodeShutdownResultSchema, localNodeStatusResultSchema, MAIA_PROTOCOL_VERSION, monitorBootstrapCreateResultSchema, orchestrationDispatchSettleTerminalResultSchema, orchestrationDispatchShowResultSchema, orchestrationInboxAckResultSchema, orchestrationInboxCheckResultSchema, orchestrationQuestionCancelResultSchema, orchestrationQuestionOpenResultSchema, orchestrationQuestionReplyResultSchema, orchestrationRunCreateResultSchema, orchestrationRunListResultSchema, orchestrationRunShowResultSchema, orchestrationTaskListResultSchema, orchestrationTaskShowResultSchema, projectListResultSchema, projectRegisterResultSchema, projectShowResultSchema, protocolErrorEnvelopeSchema, protocolRequestEnvelopeSchema, protocolSuccessEnvelopeSchema, receiptGetResultSchema, receiptListResultSchema, runtimeProbeResultSchema, sessionCreateResultSchema, sessionEventsListResultSchema, sessionListResultSchema, sessionShowResultSchema, sessionStartResultSchema, terminalCreateResultSchema, terminalEventsListResultSchema, terminalListResultSchema, terminalReadResultSchema, terminalShowResultSchema, turnInterruptResultSchema, turnSendResultSchema, turnShowResultSchema, workspaceExecutionConfigureResultSchema, workspaceExecutionShowResultSchema, workspaceListResultSchema, workspaceRepositoryAttachResultSchema, workspaceShowResultSchema, } from "@maiaos/protocol";
+export { capabilityDescriptorSchema, capabilityListSchema, capabilityNameSchema, createProtocolEnvelopeSchema, createRequestEnvelopeSchema, createRuntimeSchema, createSuccessEnvelopeSchema, DEFAULT_ORCHESTRATION_CHECK_PAGE_SIZE, DEFAULT_ORCHESTRATION_LIST_PAGE_SIZE, DEFAULT_ORCHESTRATION_TASK_LIST_PAGE_SIZE, DEFAULT_RECEIPT_LIST_PAGE_SIZE, EXECUTION_SCHEMA_VERSION, executionCatalogGetParametersSchema, executionCatalogGetResultSchema, executionProfileSchema, executionProviderDescriptorSchema, inspectOrchestrationRunCreateAdmission, installedHarnessListParametersSchema, installedHarnessListResultSchema, integrationApplyCodexParametersSchema, integrationApplyCodexResultSchema, integrationApplyPiRpcParametersSchema, integrationApplyPiRpcResultSchema, integrationAuthorizationSchema, integrationAuthorizationStatusItemSchema, integrationPlanCodexParametersSchema, integrationPlanCodexResultSchema, integrationPlanPiRpcParametersSchema, integrationPlanPiRpcResultSchema, integrationRemoveCodexParametersSchema, integrationRemoveCodexResultSchema, integrationRemovePiRpcParametersSchema, integrationRemovePiRpcResultSchema, integrationStatusCodexParametersSchema, integrationStatusCodexResultSchema, integrationStatusPiRpcParametersSchema, integrationStatusPiRpcResultSchema, INVOCATION_CONTEXT_ACTOR_LOCAL_USER, INVOCATION_CONTEXT_ALLOWED_ACTION_SHOW, INVOCATION_CONTEXT_CLIENT_PRINCIPAL_ID, INVOCATION_CONTEXT_ERROR_NODE_UNAVAILABLE, INVOCATION_CONTEXT_ERROR_OVERRIDE_FORBIDDEN, INVOCATION_CONTEXT_SCHEMA_VERSION, invocationContextShowParametersSchema, invocationContextShowResultSchema, liveTerminalCloseParametersSchema, liveTerminalCloseResultSchema, liveTerminalControllerAcquireParametersSchema, liveTerminalControllerAcquireResultSchema, liveTerminalControllerReleaseParametersSchema, liveTerminalControllerReleaseResultSchema, liveTerminalControllerRequestParametersSchema, liveTerminalControllerRequestResultSchema, liveTerminalControllerRequestShowParametersSchema, liveTerminalControllerRequestShowResultSchema, liveTerminalCreateParametersSchema, liveTerminalCreateResultSchema, liveTerminalResizeParametersSchema, liveTerminalResizeResultSchema, liveTerminalSignalParametersSchema, liveTerminalSignalResultSchema, liveTerminalWriteParametersSchema, liveTerminalWriteResultSchema, LOCAL_DEFAULT_POLICY_ID, LOCAL_HOST_PROFILE_ID, LOCAL_HOST_PROVIDER_ID, localNodeEndpointSchema, localNodeOperationErrorCodeSchema, localNodeRequestPayloadSchema, localNodeShutdownResultSchema, localNodeStatusResultSchema, MAIA_PROTOCOL_VERSION, MAX_ORCHESTRATION_CHECK_PAGE_SIZE, MAX_ORCHESTRATION_LIST_PAGE_SIZE, MAX_ORCHESTRATION_TASK_LIST_PAGE_SIZE, MAX_RECEIPT_LIST_PAGE_SIZE, MAX_RECEIPT_LIST_RESULT_BYTES, MAX_TERMINAL_COLUMNS, MAX_TERMINAL_CONTROLLER_LEASE_MS, MAX_TERMINAL_GENERATION, MAX_TERMINAL_INPUT_CHUNK_BYTES, MAX_TERMINAL_INPUT_SEQUENCE, MAX_TERMINAL_ROWS, MAX_TURN_INPUT_BYTES, MIN_TERMINAL_COLUMNS, MIN_TERMINAL_CONTROLLER_LEASE_MS, MIN_TERMINAL_ROWS, monitorBootstrapCreateResultSchema, orchestrationDispatchSettleTerminalParametersSchema, orchestrationDispatchSettleTerminalResultSchema, orchestrationDispatchShowParametersSchema, orchestrationDispatchShowResultSchema, orchestrationInboxAckParametersSchema, orchestrationInboxAckResultSchema, orchestrationInboxCheckParametersSchema, orchestrationInboxCheckResultSchema, orchestrationQuestionCancelParametersSchema, orchestrationQuestionCancelResultSchema, orchestrationQuestionOpenParametersSchema, orchestrationQuestionOpenResultSchema, orchestrationQuestionReplyParametersSchema, orchestrationQuestionReplyResultSchema, orchestrationRunCreateParametersSchema, orchestrationRunCreateResultSchema, orchestrationRunListParametersSchema, orchestrationRunListResultSchema, orchestrationRunShowParametersSchema, orchestrationRunShowResultSchema, orchestrationTaskGraphSchema, orchestrationTaskListParametersSchema, orchestrationTaskListResultSchema, orchestrationTaskShowParametersSchema, orchestrationTaskShowResultSchema, orchestrationTaskSummarySchema, placementPolicySchema, projectListParametersSchema, projectListResultSchema, projectRegisterParametersSchema, projectRegisterResultSchema, projectSchema, projectShowParametersSchema, projectShowResultSchema, protocolErrorCodeSchema, protocolErrorEnvelopeSchema, protocolErrorSchema, protocolIdentifierSchema, protocolMessageKindSchema, protocolRequestEnvelopeSchema, protocolSuccessEnvelopeSchema, protocolVersionSchema, receiptGetParametersSchema, receiptListCursorSchema, receiptListItemSchema, receiptListParametersSchema, receiptListResultSchema, repositorySchema, runtimeProbeParametersSchema, runtimeProbeResultSchema, sessionCreateParametersSchema, sessionCreateResultSchema, sessionEventSchema, sessionEventsListParametersSchema, sessionEventsListResultSchema, sessionListParametersSchema, sessionListResultSchema, sessionSchema, sessionShowParametersSchema, sessionShowResultSchema, sessionStartParametersSchema, sessionStartResultSchema, terminalChunkSchema, terminalCreateParametersSchema, terminalCreateResultSchema, terminalEventSchema, terminalEventsListParametersSchema, terminalEventsListResultSchema, terminalListParametersSchema, terminalListResultSchema, terminalReadParametersSchema, terminalReadResultSchema, terminalSchema, terminalShowParametersSchema, terminalShowResultSchema, turnInputSchema, turnInterruptParametersSchema, turnInterruptResultSchema, turnSchema, turnSendParametersSchema, turnSendResultSchema, turnShowParametersSchema, turnShowResultSchema, turnTokenUsageSchema, workspaceCheckoutSchema, workspaceExecutionBindingSchema, workspaceExecutionConfigureParametersSchema, workspaceExecutionConfigureResultSchema, workspaceExecutionResolutionSchema, workspaceExecutionSelectionSchema, workspaceExecutionShowParametersSchema, workspaceExecutionShowResultSchema, workspaceListParametersSchema, workspaceListResultSchema, workspaceRepositoryAttachParametersSchema, workspaceRepositoryAttachResultSchema, workspaceSchema, workspaceShowParametersSchema, workspaceShowResultSchema, } from "@maiaos/protocol";
+export class MaiaClientError extends Error {
+    code;
+    remoteError;
+    constructor(code, message, options) {
+        super(message, options);
+        this.name = "MaiaClientError";
+        this.code = code;
+        this.remoteError = options?.remoteError;
+    }
+}
+const requireMatchingCorrelation = (response, requestMessageId) => {
+    if (response.correlationId !== requestMessageId) {
+        throw new MaiaClientError("correlation_mismatch", "The Maia response did not match the request message.");
+    }
+};
+const createRequestEnvelope = (request) => {
+    try {
+        const envelope = {
+            kind: "request",
+            messageId: request.messageId,
+            payload: request.inputSchema.parse(request.payload),
+            protocolVersion: MAIA_PROTOCOL_VERSION,
+        };
+        protocolRequestEnvelopeSchema.parse(envelope);
+        return envelope;
+    }
+    catch (error) {
+        throw new MaiaClientError("invalid_request", "The Maia request failed runtime validation.", { cause: error });
+    }
+};
+const parseSuccessResult = (rawResponse, requestMessageId) => {
+    try {
+        const response = protocolSuccessEnvelopeSchema.parse(rawResponse);
+        requireMatchingCorrelation(response, requestMessageId);
+        return response.payload.result;
+    }
+    catch (error) {
+        if (error instanceof MaiaClientError) {
+            throw error;
+        }
+        throw new MaiaClientError("invalid_response", "The Maia response envelope failed runtime validation.", { cause: error });
+    }
+};
+const parseOutput = (outputSchema, output) => {
+    try {
+        return outputSchema.parse(output);
+    }
+    catch (error) {
+        throw new MaiaClientError("invalid_response", "The Maia response payload failed runtime validation.", { cause: error });
+    }
+};
+const rejectRemoteError = (rawResponse, requestMessageId) => {
+    const response = protocolErrorEnvelopeSchema.safeParse(rawResponse);
+    if (response.success) {
+        requireMatchingCorrelation(response.data, requestMessageId);
+        const localCode = localNodeOperationErrorCodeSchema.safeParse(response.data.payload.error.code);
+        throw new MaiaClientError(localCode.success ? localCode.data : "remote_error", response.data.payload.error.message, { remoteError: response.data.payload.error });
+    }
+};
+const requestTransport = async (transport, envelope, signal) => {
+    if (cancellationRequested(signal)) {
+        throw new MaiaClientError("cancelled", "The Maia request was cancelled.");
+    }
+    try {
+        const options = signal === undefined ? undefined : { signal };
+        return await transport.request(envelope, options);
+    }
+    catch (error) {
+        if (error instanceof MaiaClientError)
+            throw error;
+        if (cancellationRequested(signal)) {
+            throw new MaiaClientError("cancelled", "The Maia request was cancelled.", {
+                cause: error,
+            });
+        }
+        throw new MaiaClientError("transport_failure", "The Maia transport request failed.", { cause: error });
+    }
+};
+const cancellationRequested = (signal) => signal?.aborted ?? false;
+const executeRequest = async (transport, request) => {
+    const requestEnvelope = createRequestEnvelope(request);
+    const rawResponse = await requestTransport(transport, requestEnvelope, request.signal);
+    rejectRemoteError(rawResponse, request.messageId);
+    return parseOutput(request.outputSchema, parseSuccessResult(rawResponse, request.messageId));
+};
+export const createMaiaClient = (transport) => ({
+    request: (request) => executeRequest(transport, request),
+});
+const makeLocalNodeRequester = (client) => (payload, outputSchema, { messageId, signal }) => client.request({
+    inputSchema: localNodeRequestPayloadSchema,
+    messageId,
+    outputSchema,
+    payload,
+    signal,
+});
+const makeInvocationContextOperations = (request) => ({
+    showCurrentContext: (parameters, options) => request({ method: "context.show", parameters }, invocationContextShowResultSchema, options),
+});
+const makeLifecycleOperations = (request) => ({
+    createMonitorBootstrap: (options) => request({ method: "monitor.bootstrap.create", parameters: {} }, monitorBootstrapCreateResultSchema, options),
+    shutdown: (options) => request({ method: "node.shutdown", parameters: {} }, localNodeShutdownResultSchema, options),
+    status: (options) => request({ method: "node.status", parameters: {} }, localNodeStatusResultSchema, options),
+});
+const makeExecutionOperations = (request) => ({
+    configureWorkspaceExecution: (parameters, options) => request({ method: "workspace.execution.configure", parameters }, workspaceExecutionConfigureResultSchema, options),
+    readExecutionCatalog: (parameters, options) => request({ method: "execution.catalog.get", parameters }, executionCatalogGetResultSchema, options),
+    showWorkspaceExecution: (parameters, options) => request({ method: "workspace.execution.show", parameters }, workspaceExecutionShowResultSchema, options),
+});
+const makeProjectOperations = (request) => ({
+    listProjects: (parameters, options) => request({ method: "project.list", parameters }, projectListResultSchema, options),
+    registerProject: (parameters, options) => request({ method: "project.register", parameters }, projectRegisterResultSchema, options),
+    showProject: (parameters, options) => request({ method: "project.show", parameters }, projectShowResultSchema, options),
+});
+const makeWorkspaceOperations = (request) => ({
+    attachWorkspaceRepository: (parameters, options) => request({ method: "workspace.repository.attach", parameters }, workspaceRepositoryAttachResultSchema, options),
+    listWorkspaces: (parameters, options) => request({ method: "workspace.list", parameters }, workspaceListResultSchema, options),
+    showWorkspace: (parameters, options) => request({ method: "workspace.show", parameters }, workspaceShowResultSchema, options),
+});
+const makeReceiptOperations = (request) => ({
+    getReceipt: (parameters, options) => request({ method: "receipt.get", parameters }, receiptGetResultSchema, options),
+    listReceipts: (parameters, options) => request({ method: "receipt.list", parameters }, receiptListResultSchema, options),
+});
+const makeIntegrationAuthorizationApplyOperations = (request) => ({
+    applyCodexIntegration: (parameters, options) => request({ method: "integration.apply.codex", parameters }, integrationApplyCodexResultSchema, options),
+    applyPiRpcIntegration: (parameters, options) => request({ method: "integration.apply.pi-rpc", parameters }, integrationApplyPiRpcResultSchema, options),
+});
+const makeIntegrationAuthorizationRemoveOperations = (request) => ({
+    removeCodexIntegration: (parameters, options) => request({ method: "integration.remove.codex", parameters }, integrationRemoveCodexResultSchema, options),
+    removePiRpcIntegration: (parameters, options) => request({ method: "integration.remove.pi-rpc", parameters }, integrationRemovePiRpcResultSchema, options),
+});
+const makeIntegrationAuthorizationPlanOperations = (request) => ({
+    planCodexIntegration: (parameters, options) => request({ method: "integration.plan.codex", parameters }, integrationPlanCodexResultSchema, options),
+    planPiRpcIntegration: (parameters, options) => request({ method: "integration.plan.pi-rpc", parameters }, integrationPlanPiRpcResultSchema, options),
+});
+const makeIntegrationAuthorizationStatusOperations = (request) => ({
+    statusCodexIntegration: (parameters, options) => request({ method: "integration.status.codex", parameters }, integrationStatusCodexResultSchema, options),
+    statusPiRpcIntegration: (parameters, options) => request({ method: "integration.status.pi-rpc", parameters }, integrationStatusPiRpcResultSchema, options),
+});
+const makeIntegrationAuthorizationOperations = (request) => ({
+    ...makeIntegrationAuthorizationApplyOperations(request),
+    ...makeIntegrationAuthorizationPlanOperations(request),
+    ...makeIntegrationAuthorizationRemoveOperations(request),
+    ...makeIntegrationAuthorizationStatusOperations(request),
+});
+const makeRuntimeOperations = (request) => ({
+    listInstalledHarnesses: (parameters, options) => request({ method: "harness.installed.list", parameters }, installedHarnessListResultSchema, options),
+    probeRuntime: (parameters, options) => request({ method: "runtime.probe", parameters }, runtimeProbeResultSchema, options),
+});
+const makeSessionCommandOperations = (request) => ({
+    createSession: (parameters, options) => request({ method: "session.create", parameters }, sessionCreateResultSchema, options),
+    startSession: (parameters, options) => request({ method: "session.start", parameters }, sessionStartResultSchema, options),
+});
+const makeSessionQueryOperations = (request) => ({
+    listSessionEvents: (parameters, options) => request({ method: "session.events.list", parameters }, sessionEventsListResultSchema, options),
+    listSessions: (parameters, options) => request({ method: "session.list", parameters }, sessionListResultSchema, options),
+    showSession: (parameters, options) => request({ method: "session.show", parameters }, sessionShowResultSchema, options),
+});
+const makeTurnOperations = (request) => ({
+    interruptTurn: (parameters, options) => request({ method: "turn.interrupt", parameters }, turnInterruptResultSchema, options),
+    sendTurn: (parameters, options) => request({ method: "turn.send", parameters }, turnSendResultSchema, options),
+    showTurn: (parameters, options) => request({ method: "turn.show", parameters }, turnShowResultSchema, options),
+});
+const makeTerminalControllerOperations = (request) => ({
+    acquireTerminalController: (parameters, options) => request({ method: "terminal.controller.acquire", parameters }, liveTerminalControllerAcquireResultSchema, options),
+    releaseTerminalController: (parameters, options) => request({ method: "terminal.controller.release", parameters }, liveTerminalControllerReleaseResultSchema, options),
+    requestTerminalController: (parameters, options) => request({ method: "terminal.controller.request", parameters }, liveTerminalControllerRequestResultSchema, options),
+});
+const makeTerminalMutationOperations = (request) => ({
+    closeTerminal: (parameters, options) => request({ method: "terminal.session.close", parameters }, liveTerminalCloseResultSchema, options),
+    resizeTerminal: (parameters, options) => request({ method: "terminal.session.resize", parameters }, liveTerminalResizeResultSchema, options),
+    signalTerminal: (parameters, options) => request({ method: "terminal.session.signal", parameters }, liveTerminalSignalResultSchema, options),
+});
+const makeTerminalWriteOperation = (request) => ({
+    writeTerminalInput: (parameters, options) => request({ method: "terminal.input.write", parameters }, liveTerminalWriteResultSchema, options),
+});
+const makeTerminalCreateOperation = (request) => ({
+    createTerminal: (parameters, options) => request({ method: "terminal.create", parameters }, terminalCreateResultSchema, options),
+});
+const makeTerminalQueryOperations = (request) => ({
+    listTerminalEvents: (parameters, options) => request({ method: "terminal.events.list", parameters }, terminalEventsListResultSchema, options),
+    listTerminals: (parameters, options) => request({ method: "terminal.list", parameters }, terminalListResultSchema, options),
+    showTerminal: (parameters, options) => request({ method: "terminal.show", parameters }, terminalShowResultSchema, options),
+});
+const makeTerminalControllerQueryOperation = (request) => ({
+    showTerminalControllerRequest: (parameters, options) => request({ method: "terminal.controller.request.show", parameters }, liveTerminalControllerRequestShowResultSchema, options),
+});
+const makeTerminalReadOperation = (request) => ({
+    readTerminal: (parameters, options) => request({ method: "terminal.read", parameters }, terminalReadResultSchema, options),
+});
+const makeOrchestrationRunOperations = (request) => ({
+    createOrchestrationRun: (parameters, options) => request({ method: "run.create", parameters }, orchestrationRunCreateResultSchema, options),
+    listOrchestrationRuns: (parameters, options) => request({ method: "run.list", parameters }, orchestrationRunListResultSchema, options),
+    showOrchestrationRun: (parameters, options) => request({ method: "run.show", parameters }, orchestrationRunShowResultSchema, options),
+});
+const makeOrchestrationTaskOperations = (request) => ({
+    listOrchestrationTasks: (parameters, options) => request({ method: "run.task.list", parameters }, orchestrationTaskListResultSchema, options),
+    showOrchestrationTask: (parameters, options) => request({ method: "run.task.show", parameters }, orchestrationTaskShowResultSchema, options),
+});
+const makeOrchestrationInboxOperations = (request) => ({
+    acknowledgeOrchestrationDelivery: (parameters, options) => request({ method: "run.inbox.ack", parameters }, orchestrationInboxAckResultSchema, options),
+    checkOrchestrationInbox: (parameters, options) => request({ method: "run.inbox.check", parameters }, orchestrationInboxCheckResultSchema, options),
+});
+const makeOrchestrationQuestionOperations = (request) => ({
+    cancelOrchestrationQuestion: (parameters, options) => request({ method: "run.question.cancel", parameters }, orchestrationQuestionCancelResultSchema, options),
+    openOrchestrationQuestion: (parameters, options) => request({ method: "run.question.open", parameters }, orchestrationQuestionOpenResultSchema, options),
+    replyOrchestrationQuestion: (parameters, options) => request({ method: "run.question.reply", parameters }, orchestrationQuestionReplyResultSchema, options),
+});
+const makeOrchestrationSettlementOperation = (request) => ({
+    settleOrchestrationDispatchTerminal: (parameters, options) => request({ method: "run.dispatch.settle-terminal", parameters }, orchestrationDispatchSettleTerminalResultSchema, options),
+});
+const makeOrchestrationDispatchShowOperation = (request) => ({
+    showOrchestrationDispatch: (parameters, options) => request({ method: "run.dispatch.show", parameters }, orchestrationDispatchShowResultSchema, options),
+});
+const makeLocalNodeClient = (request) => ({
+    ...makeExecutionOperations(request),
+    ...makeIntegrationAuthorizationOperations(request),
+    ...makeInvocationContextOperations(request),
+    ...makeLifecycleOperations(request),
+    ...makeOrchestrationInboxOperations(request),
+    ...makeOrchestrationQuestionOperations(request),
+    ...makeOrchestrationRunOperations(request),
+    ...makeOrchestrationTaskOperations(request),
+    ...makeOrchestrationDispatchShowOperation(request),
+    ...makeOrchestrationSettlementOperation(request),
+    ...makeProjectOperations(request),
+    ...makeReceiptOperations(request),
+    ...makeRuntimeOperations(request),
+    ...makeSessionCommandOperations(request),
+    ...makeSessionQueryOperations(request),
+    ...makeTerminalControllerOperations(request),
+    ...makeTerminalControllerQueryOperation(request),
+    ...makeTerminalCreateOperation(request),
+    ...makeTerminalMutationOperations(request),
+    ...makeTerminalQueryOperations(request),
+    ...makeTerminalReadOperation(request),
+    ...makeTerminalWriteOperation(request),
+    ...makeTurnOperations(request),
+    ...makeWorkspaceOperations(request),
+});
+export const createLocalNodeClient = (transport) => makeLocalNodeClient(makeLocalNodeRequester(createMaiaClient(transport)));
+//# sourceMappingURL=index.js.map

package/dist/local-transport-channels.d.ts

@@ -0,0 +1,7 @@
+import { type LocalNodeEndpoint } from "@maiaos/protocol";
+export type LocalNodeTransportOptions = {
+    readonly controlEndpoint?: LocalNodeEndpoint;
+    readonly credentialPath: string;
+    readonly endpoint: LocalNodeEndpoint;
+};
+//# sourceMappingURL=local-transport-channels.d.ts.map

package/dist/local-transport-channels.js

@@ -0,0 +1,22 @@
+import { localNodeRequestChannel, localNodeRequestPayloadSchema, } from "@maiaos/protocol";
+import * as Semaphore from "effect/Semaphore";
+const MAX_CONTROL_IN_FLIGHT_REQUESTS = 2;
+const MAX_ORDINARY_IN_FLIGHT_REQUESTS = 8;
+const requestChannel = (envelope) => {
+    const request = localNodeRequestPayloadSchema.safeParse(envelope.payload);
+    return request.success ? localNodeRequestChannel(request.data) : "ordinary";
+};
+export const createLocalNodeTransportChannels = (options) => {
+    const ordinaryConcurrency = Semaphore.makeUnsafe(MAX_ORDINARY_IN_FLIGHT_REQUESTS);
+    const controlConcurrency = Semaphore.makeUnsafe(MAX_CONTROL_IN_FLIGHT_REQUESTS);
+    return (envelope) => {
+        const channel = requestChannel(envelope);
+        return {
+            channel,
+            concurrency: channel === "control" && options.controlEndpoint !== undefined
+                ? controlConcurrency
+                : ordinaryConcurrency,
+        };
+    };
+};
+//# sourceMappingURL=local-transport-channels.js.map

package/dist/node.d.ts

@@ -0,0 +1,17 @@
+import { type LocalNodeConnectionDescriptor } from "@maiaos/protocol";
+import { type LocalNodeClient, type LocalNodeStatusResult, type MaiaTransport } from "./index.js";
+import { type LocalNodeTransportOptions } from "./local-transport-channels.js";
+export type { LocalNodeTransportOptions } from "./local-transport-channels.js";
+export declare const createLocalNodeTransport: (options: LocalNodeTransportOptions) => MaiaTransport;
+export type LocalNodeDiscoveryOptions = {
+    readonly profile?: string;
+    readonly runtimeRootOverride?: string;
+    readonly signal?: AbortSignal;
+};
+export type LocalNodeConnection = {
+    readonly client: LocalNodeClient;
+    readonly descriptor: LocalNodeConnectionDescriptor;
+    readonly status: LocalNodeStatusResult;
+};
+export declare const connectLocalNode: (options?: LocalNodeDiscoveryOptions) => Promise<LocalNodeConnection>;
+//# sourceMappingURL=node.d.ts.map