@meridian-flow/runtime 0.1.2 → 0.3.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +7 -6
- package/dist/gateway/adapters/anthropic/request-map.js +4 -6
- package/dist/gateway/adapters/anthropic/stream-collect.d.ts +0 -9
- package/dist/gateway/adapters/anthropic/stream-collect.js +0 -5
- package/dist/gateway/adapters/openai/stream-collect.js +1 -2
- package/dist/gateway/adapters/provider-http-error.d.ts +5 -1
- package/dist/gateway/adapters/provider-http-error.js +9 -2
- package/dist/gateway/domain/types.d.ts +14 -8
- package/dist/gateway/helpers/messages.d.ts +2 -2
- package/dist/gateway/mock-script.d.ts +36 -36
- package/dist/mcp/client.d.ts +2 -0
- package/dist/mcp/client.js +279 -0
- package/dist/mcp/content.d.ts +7 -0
- package/dist/mcp/content.js +54 -0
- package/dist/mcp/fault.d.ts +6 -0
- package/dist/mcp/fault.js +48 -0
- package/dist/mcp/index.d.ts +4 -0
- package/dist/mcp/index.js +3 -0
- package/dist/mcp/pin.d.ts +31 -0
- package/dist/mcp/pin.js +153 -0
- package/dist/mcp/reply-limit.d.ts +14 -0
- package/dist/mcp/reply-limit.js +59 -0
- package/dist/mcp/session.d.ts +96 -0
- package/dist/mcp/session.js +280 -0
- package/dist/mcp/types.d.ts +182 -0
- package/dist/mcp/types.js +1 -0
- package/package.json +19 -12
|
@@ -0,0 +1,48 @@
|
|
|
1
|
+
import { ProtocolError, SdkError, SdkErrorCode, SdkHttpError, UnauthorizedError, } from "@modelcontextprotocol/client";
|
|
2
|
+
function describe(error) {
|
|
3
|
+
if (!(error instanceof Error))
|
|
4
|
+
return String(error).slice(0, 500);
|
|
5
|
+
const cause = error.cause instanceof Error ? `: ${error.cause.message}` : "";
|
|
6
|
+
return `${error.message}${cause}`.slice(0, 500);
|
|
7
|
+
}
|
|
8
|
+
/** What the SDK or the network threw when no reply arrived, as an `unreachable` reason. */
|
|
9
|
+
export function faultOf(error, phase) {
|
|
10
|
+
const message = describe(error);
|
|
11
|
+
const other = phase === "start" ? "start_failed" : "bad_reply";
|
|
12
|
+
if (error instanceof UnauthorizedError)
|
|
13
|
+
return { reason: "unauthorized", httpStatus: 401, message };
|
|
14
|
+
if (error instanceof SdkHttpError) {
|
|
15
|
+
const status = error.status;
|
|
16
|
+
if (status === 401)
|
|
17
|
+
return { reason: "unauthorized", httpStatus: status, message };
|
|
18
|
+
if (status === 403)
|
|
19
|
+
return { reason: "forbidden", httpStatus: status, message };
|
|
20
|
+
if (status === 429)
|
|
21
|
+
return { reason: "rate_limited", httpStatus: status, message };
|
|
22
|
+
if (status >= 500)
|
|
23
|
+
return { reason: "server_error", httpStatus: status, message };
|
|
24
|
+
return { reason: other, httpStatus: status, message };
|
|
25
|
+
}
|
|
26
|
+
if (error instanceof SdkError) {
|
|
27
|
+
if (error.code === SdkErrorCode.RequestTimeout)
|
|
28
|
+
return { reason: phase === "start" ? "connect_timeout" : "call_timeout", message };
|
|
29
|
+
if (error.code === SdkErrorCode.ConnectionClosed || error.code === SdkErrorCode.NotConnected)
|
|
30
|
+
return { reason: phase === "start" ? "start_failed" : "disconnected", message };
|
|
31
|
+
return { reason: "bad_reply", message };
|
|
32
|
+
}
|
|
33
|
+
// fetch rejects with a TypeError for a refused, reset or unresolvable connection.
|
|
34
|
+
if (error instanceof TypeError)
|
|
35
|
+
return { reason: phase === "start" ? "start_failed" : "disconnected", message };
|
|
36
|
+
if (error instanceof SyntaxError || error instanceof ProtocolError)
|
|
37
|
+
return { reason: "bad_reply", message };
|
|
38
|
+
return { reason: other, message };
|
|
39
|
+
}
|
|
40
|
+
/** The server said it does not know this session (a 404, or a 400 "not initialized"): the call did not run. */
|
|
41
|
+
export function sessionForgotten(error) {
|
|
42
|
+
if (!(error instanceof SdkHttpError))
|
|
43
|
+
return false;
|
|
44
|
+
if (error.status === 404)
|
|
45
|
+
return true;
|
|
46
|
+
const { text } = error.data;
|
|
47
|
+
return error.status === 400 && typeof text === "string" && /initializ|session/i.test(text);
|
|
48
|
+
}
|
|
@@ -0,0 +1,31 @@
|
|
|
1
|
+
import type { Listing, Pin, PinnedTool, PinProblem, ToolDefinition } from "./types.js";
|
|
2
|
+
/** Keeps the named tools, exactly as the server listed them, or says what cannot be offered. */
|
|
3
|
+
export declare function pin(listing: Listing, choose: {
|
|
4
|
+
tools: string[];
|
|
5
|
+
pinnedAt: string;
|
|
6
|
+
}): {
|
|
7
|
+
pin: Pin;
|
|
8
|
+
} | {
|
|
9
|
+
problems: PinProblem[];
|
|
10
|
+
};
|
|
11
|
+
/** sha256 (hex) of the pin's canonical JSON: key order does not change it. */
|
|
12
|
+
export declare function pinHash(pinned: Pin): string;
|
|
13
|
+
/**
|
|
14
|
+
* The model's tool definitions for a pin. The schema is carried as listed, never parsed into
|
|
15
|
+
* another schema library and back. `modelName` decides the name the model sees; the default is
|
|
16
|
+
* the server's.
|
|
17
|
+
*/
|
|
18
|
+
export declare function toTools(pinned: Pin, opts?: {
|
|
19
|
+
modelName?: (tool: string) => string;
|
|
20
|
+
}): {
|
|
21
|
+
tools: ToolDefinition[];
|
|
22
|
+
} | {
|
|
23
|
+
problems: PinProblem[];
|
|
24
|
+
};
|
|
25
|
+
/** One line per tool: the host's id and the first sentence of the pinned description. */
|
|
26
|
+
export declare function toCatalogue(entries: {
|
|
27
|
+
id: string;
|
|
28
|
+
tool: PinnedTool;
|
|
29
|
+
}[]): string;
|
|
30
|
+
/** A tool's description and input schema as text, for a model that asks to read it. */
|
|
31
|
+
export declare function describeTool(id: string, tool: PinnedTool): string;
|
package/dist/mcp/pin.js
ADDED
|
@@ -0,0 +1,153 @@
|
|
|
1
|
+
import { createHash } from "node:crypto";
|
|
2
|
+
/** Providers (Anthropic, OpenAI) take this pattern; 64 characters is the safe length. */
|
|
3
|
+
const MODEL_NAME = /^[A-Za-z0-9_-]{1,64}$/;
|
|
4
|
+
const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
|
|
5
|
+
function toolProblem(tool) {
|
|
6
|
+
const invalid = (text) => ({ kind: "invalid_tool", text });
|
|
7
|
+
if (typeof tool.name !== "string" || tool.name === "")
|
|
8
|
+
return invalid("it has no name");
|
|
9
|
+
const schema = tool.inputSchema;
|
|
10
|
+
if (!isObject(schema) || schema.type !== "object")
|
|
11
|
+
return invalid("its inputSchema is not an object schema");
|
|
12
|
+
if (tool.description !== undefined && typeof tool.description !== "string")
|
|
13
|
+
return invalid("its description is not a string");
|
|
14
|
+
const execution = tool.execution;
|
|
15
|
+
if (isObject(execution) && execution.taskSupport === "required")
|
|
16
|
+
return {
|
|
17
|
+
kind: "task_required",
|
|
18
|
+
text: "it needs MCP's task protocol, which this client does not speak",
|
|
19
|
+
};
|
|
20
|
+
return undefined;
|
|
21
|
+
}
|
|
22
|
+
/** Keeps the named tools, exactly as the server listed them, or says what cannot be offered. */
|
|
23
|
+
export function pin(listing, choose) {
|
|
24
|
+
const problems = [];
|
|
25
|
+
const tools = [];
|
|
26
|
+
const chosen = new Set();
|
|
27
|
+
for (const name of choose.tools) {
|
|
28
|
+
if (chosen.has(name)) {
|
|
29
|
+
problems.push({
|
|
30
|
+
tool: name,
|
|
31
|
+
problem: "duplicate_choice",
|
|
32
|
+
message: `"${name}" is chosen twice`,
|
|
33
|
+
});
|
|
34
|
+
continue;
|
|
35
|
+
}
|
|
36
|
+
chosen.add(name);
|
|
37
|
+
const listed = listing.tools.find((tool) => isObject(tool) && tool.name === name);
|
|
38
|
+
if (!listed) {
|
|
39
|
+
problems.push({
|
|
40
|
+
tool: name,
|
|
41
|
+
problem: "not_listed",
|
|
42
|
+
message: `the server does not list "${name}"`,
|
|
43
|
+
});
|
|
44
|
+
continue;
|
|
45
|
+
}
|
|
46
|
+
const problem = toolProblem(listed);
|
|
47
|
+
if (problem) {
|
|
48
|
+
problems.push({
|
|
49
|
+
tool: name,
|
|
50
|
+
problem: problem.kind,
|
|
51
|
+
message: `"${name}" cannot be offered: ${problem.text}`,
|
|
52
|
+
});
|
|
53
|
+
continue;
|
|
54
|
+
}
|
|
55
|
+
tools.push({ name, listed });
|
|
56
|
+
}
|
|
57
|
+
if (problems.length > 0)
|
|
58
|
+
return { problems };
|
|
59
|
+
const { server, protocolVersion, instructions } = listing;
|
|
60
|
+
return {
|
|
61
|
+
pin: {
|
|
62
|
+
format: 1,
|
|
63
|
+
server: { name: server.name, version: server.version, protocolVersion },
|
|
64
|
+
pinnedAt: choose.pinnedAt,
|
|
65
|
+
...(instructions === undefined ? {} : { instructions }),
|
|
66
|
+
tools,
|
|
67
|
+
},
|
|
68
|
+
};
|
|
69
|
+
}
|
|
70
|
+
function canonical(value) {
|
|
71
|
+
if (Array.isArray(value))
|
|
72
|
+
return `[${value.map(canonical).join(",")}]`;
|
|
73
|
+
if (isObject(value)) {
|
|
74
|
+
const keys = Object.keys(value)
|
|
75
|
+
.filter((key) => value[key] !== undefined)
|
|
76
|
+
.sort();
|
|
77
|
+
return `{${keys.map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(",")}}`;
|
|
78
|
+
}
|
|
79
|
+
return JSON.stringify(value);
|
|
80
|
+
}
|
|
81
|
+
/** sha256 (hex) of the pin's canonical JSON: key order does not change it. */
|
|
82
|
+
export function pinHash(pinned) {
|
|
83
|
+
return createHash("sha256")
|
|
84
|
+
.update(canonical(pinned))
|
|
85
|
+
.digest("hex");
|
|
86
|
+
}
|
|
87
|
+
function description(tool) {
|
|
88
|
+
const { description, title } = tool.listed;
|
|
89
|
+
if (typeof description === "string")
|
|
90
|
+
return description;
|
|
91
|
+
return typeof title === "string" ? title : "";
|
|
92
|
+
}
|
|
93
|
+
/**
|
|
94
|
+
* The model's tool definitions for a pin. The schema is carried as listed, never parsed into
|
|
95
|
+
* another schema library and back. `modelName` decides the name the model sees; the default is
|
|
96
|
+
* the server's.
|
|
97
|
+
*/
|
|
98
|
+
export function toTools(pinned, opts) {
|
|
99
|
+
const problems = [];
|
|
100
|
+
const names = new Set();
|
|
101
|
+
const tools = [];
|
|
102
|
+
for (const tool of pinned.tools) {
|
|
103
|
+
const name = opts?.modelName ? opts.modelName(tool.name) : tool.name;
|
|
104
|
+
if (!MODEL_NAME.test(name)) {
|
|
105
|
+
problems.push({
|
|
106
|
+
tool: tool.name,
|
|
107
|
+
problem: "bad_model_name",
|
|
108
|
+
message: `"${name}" is not a name providers accept (letters, digits, "_" and "-", up to 64)`,
|
|
109
|
+
});
|
|
110
|
+
}
|
|
111
|
+
else if (names.has(name)) {
|
|
112
|
+
problems.push({
|
|
113
|
+
tool: tool.name,
|
|
114
|
+
problem: "duplicate_model_name",
|
|
115
|
+
message: `two tools would be called "${name}"`,
|
|
116
|
+
});
|
|
117
|
+
}
|
|
118
|
+
names.add(name);
|
|
119
|
+
tools.push({
|
|
120
|
+
type: "function",
|
|
121
|
+
name,
|
|
122
|
+
description: description(tool),
|
|
123
|
+
inputSchema: tool.listed.inputSchema,
|
|
124
|
+
});
|
|
125
|
+
}
|
|
126
|
+
return problems.length > 0 ? { problems } : { tools };
|
|
127
|
+
}
|
|
128
|
+
function firstSentence(text) {
|
|
129
|
+
const flat = text.replace(/\s+/g, " ").trim();
|
|
130
|
+
const end = flat.search(/[.!?](\s|$)/);
|
|
131
|
+
const sentence = end === -1 ? flat : flat.slice(0, end + 1);
|
|
132
|
+
return sentence.length > 200 ? `${sentence.slice(0, 199)}…` : sentence;
|
|
133
|
+
}
|
|
134
|
+
/** One line per tool: the host's id and the first sentence of the pinned description. */
|
|
135
|
+
export function toCatalogue(entries) {
|
|
136
|
+
return entries
|
|
137
|
+
.map(({ id, tool }) => {
|
|
138
|
+
const sentence = firstSentence(description(tool));
|
|
139
|
+
return sentence === "" ? id : `${id}: ${sentence}`;
|
|
140
|
+
})
|
|
141
|
+
.join("\n");
|
|
142
|
+
}
|
|
143
|
+
/** A tool's description and input schema as text, for a model that asks to read it. */
|
|
144
|
+
export function describeTool(id, tool) {
|
|
145
|
+
const text = description(tool);
|
|
146
|
+
return [
|
|
147
|
+
id,
|
|
148
|
+
...(text === "" ? [] : ["", text]),
|
|
149
|
+
"",
|
|
150
|
+
"Input schema:",
|
|
151
|
+
JSON.stringify(tool.listed.inputSchema, null, 2),
|
|
152
|
+
].join("\n");
|
|
153
|
+
}
|
|
@@ -0,0 +1,14 @@
|
|
|
1
|
+
/** Thrown into the body stream of a reply that went over the limit. */
|
|
2
|
+
export declare class ReplyTooLarge extends Error {
|
|
3
|
+
readonly bytes: number;
|
|
4
|
+
constructor(bytes: number);
|
|
5
|
+
}
|
|
6
|
+
type Fetch = typeof fetch;
|
|
7
|
+
/**
|
|
8
|
+
* Wraps the host's `fetch` so a reply to a JSON-RPC request is stopped at `limit` bytes, before
|
|
9
|
+
* it is read into memory. Only POST replies are metered: the long-lived GET event stream is not
|
|
10
|
+
* one reply. `onOver` names the request (when its body shows an id), because the SDK swallows a
|
|
11
|
+
* stream error on an SSE reply and leaves the call waiting until its timeout.
|
|
12
|
+
*/
|
|
13
|
+
export declare function limitReplies(inner: Fetch, limit: number, onOver: (id: number | string, bytes: number) => void): Fetch;
|
|
14
|
+
export {};
|
|
@@ -0,0 +1,59 @@
|
|
|
1
|
+
/** Thrown into the body stream of a reply that went over the limit. */
|
|
2
|
+
export class ReplyTooLarge extends Error {
|
|
3
|
+
bytes;
|
|
4
|
+
constructor(bytes) {
|
|
5
|
+
super(`reply is larger than the limit (at least ${bytes} bytes)`);
|
|
6
|
+
this.bytes = bytes;
|
|
7
|
+
}
|
|
8
|
+
}
|
|
9
|
+
/** The JSON-RPC id of a POSTed request, when the body shows one. */
|
|
10
|
+
function requestId(init) {
|
|
11
|
+
if (typeof init?.body !== "string")
|
|
12
|
+
return undefined;
|
|
13
|
+
try {
|
|
14
|
+
const id = JSON.parse(init.body).id;
|
|
15
|
+
return typeof id === "number" || typeof id === "string" ? id : undefined;
|
|
16
|
+
}
|
|
17
|
+
catch {
|
|
18
|
+
return undefined;
|
|
19
|
+
}
|
|
20
|
+
}
|
|
21
|
+
/**
|
|
22
|
+
* Wraps the host's `fetch` so a reply to a JSON-RPC request is stopped at `limit` bytes, before
|
|
23
|
+
* it is read into memory. Only POST replies are metered: the long-lived GET event stream is not
|
|
24
|
+
* one reply. `onOver` names the request (when its body shows an id), because the SDK swallows a
|
|
25
|
+
* stream error on an SSE reply and leaves the call waiting until its timeout.
|
|
26
|
+
*/
|
|
27
|
+
export function limitReplies(inner, limit, onOver) {
|
|
28
|
+
return async (input, init) => {
|
|
29
|
+
const response = await inner(input, init);
|
|
30
|
+
if (init?.method !== "POST" || response.body === null)
|
|
31
|
+
return response;
|
|
32
|
+
const id = requestId(init);
|
|
33
|
+
const declared = Number(response.headers.get("content-length"));
|
|
34
|
+
if (declared > limit) {
|
|
35
|
+
void response.body.cancel().catch(() => { });
|
|
36
|
+
if (id !== undefined)
|
|
37
|
+
onOver(id, declared);
|
|
38
|
+
throw new ReplyTooLarge(declared);
|
|
39
|
+
}
|
|
40
|
+
let seen = 0;
|
|
41
|
+
const body = response.body.pipeThrough(new TransformStream({
|
|
42
|
+
transform(chunk, controller) {
|
|
43
|
+
seen += chunk.byteLength;
|
|
44
|
+
if (seen > limit) {
|
|
45
|
+
if (id !== undefined)
|
|
46
|
+
onOver(id, seen);
|
|
47
|
+
controller.error(new ReplyTooLarge(seen));
|
|
48
|
+
return;
|
|
49
|
+
}
|
|
50
|
+
controller.enqueue(chunk);
|
|
51
|
+
},
|
|
52
|
+
}));
|
|
53
|
+
return new Response(body, {
|
|
54
|
+
status: response.status,
|
|
55
|
+
statusText: response.statusText,
|
|
56
|
+
headers: response.headers,
|
|
57
|
+
});
|
|
58
|
+
};
|
|
59
|
+
}
|
|
@@ -0,0 +1,96 @@
|
|
|
1
|
+
import type { JsonObject, McpEvent, Server } from "./types.js";
|
|
2
|
+
export interface SessionConfig {
|
|
3
|
+
clientInfo: {
|
|
4
|
+
name: string;
|
|
5
|
+
version: string;
|
|
6
|
+
};
|
|
7
|
+
maxReplyBytes: number;
|
|
8
|
+
fetch: typeof fetch;
|
|
9
|
+
onEvent?: (event: McpEvent) => void;
|
|
10
|
+
}
|
|
11
|
+
export type SessionEnd = Extract<McpEvent, {
|
|
12
|
+
type: "session_ended";
|
|
13
|
+
}>["reason"];
|
|
14
|
+
/** One request's trip over the wire. The caller reads it when `exchange` returns. */
|
|
15
|
+
export interface Exchange {
|
|
16
|
+
/** True once the transport took the request: from then on it may have run. */
|
|
17
|
+
sent: boolean;
|
|
18
|
+
/** The session ended while the request was in flight and no reply had come. */
|
|
19
|
+
lost?: boolean;
|
|
20
|
+
/** The JSON-RPC response as it came off the wire, before the SDK parsed or rejected it. */
|
|
21
|
+
raw?: {
|
|
22
|
+
result: JsonObject;
|
|
23
|
+
} | {
|
|
24
|
+
error: JsonObject;
|
|
25
|
+
};
|
|
26
|
+
/** What the SDK threw, when it threw. */
|
|
27
|
+
error?: unknown;
|
|
28
|
+
/** The reply was stopped at the size limit; at least this many bytes. */
|
|
29
|
+
tooLarge?: number;
|
|
30
|
+
id?: number | string;
|
|
31
|
+
}
|
|
32
|
+
/**
|
|
33
|
+
* A live link to one MCP server. It reads each reply under the SDK: the transport's `send` names
|
|
34
|
+
* the request id of the request being made (a call is matched through the identity of its
|
|
35
|
+
* `arguments`, which reaches `send` unchanged; a list or ping through a reference in `_meta`,
|
|
36
|
+
* which survives the SDK rebuilding `params`), and the incoming-message hook keeps the raw
|
|
37
|
+
* response for that id. The outcome is decided from that raw message, not from what the SDK made
|
|
38
|
+
* of it.
|
|
39
|
+
*
|
|
40
|
+
* A session is `ended` from the moment anything starts ending it (close, idle timer, a reply over
|
|
41
|
+
* the limit, the transport closing), and leaves its registry then: the teardown that follows may
|
|
42
|
+
* take seconds and must not receive new requests.
|
|
43
|
+
*/
|
|
44
|
+
export declare class Session {
|
|
45
|
+
readonly key: string;
|
|
46
|
+
private readonly cfg;
|
|
47
|
+
private readonly idleCloseMs;
|
|
48
|
+
/** Set by the registry; called once, when the session starts ending. */
|
|
49
|
+
onEnded?: (reason: SessionEnd) => void;
|
|
50
|
+
ended: boolean;
|
|
51
|
+
server: {
|
|
52
|
+
name: string;
|
|
53
|
+
version: string;
|
|
54
|
+
};
|
|
55
|
+
protocolVersion: string;
|
|
56
|
+
instructions: string | undefined;
|
|
57
|
+
private readonly client;
|
|
58
|
+
private readonly transport;
|
|
59
|
+
private readonly waiting;
|
|
60
|
+
private readonly byId;
|
|
61
|
+
private readonly aborts;
|
|
62
|
+
private closing;
|
|
63
|
+
private refs;
|
|
64
|
+
private active;
|
|
65
|
+
private idleTimer;
|
|
66
|
+
private constructor();
|
|
67
|
+
/** Starts the process or the HTTP session and does the handshake. Throws what the SDK threw. */
|
|
68
|
+
static open(server: Server, cfg: SessionConfig, opts: {
|
|
69
|
+
signal?: AbortSignal;
|
|
70
|
+
timeoutMs: number;
|
|
71
|
+
idleCloseMs: number;
|
|
72
|
+
}): Promise<Session>;
|
|
73
|
+
get transportKind(): "stdio" | "http";
|
|
74
|
+
/** An HTTP server that issued a session id can forget it; a stateless one cannot. */
|
|
75
|
+
get hasServerSession(): boolean;
|
|
76
|
+
private makeTransport;
|
|
77
|
+
private tap;
|
|
78
|
+
private replyTooLarge;
|
|
79
|
+
private stdioReplyTooLarge;
|
|
80
|
+
/** The one place a session starts ending. Synchronous, so no later request can reach it. */
|
|
81
|
+
private finish;
|
|
82
|
+
private armIdle;
|
|
83
|
+
/**
|
|
84
|
+
* Runs one request. `token` is what `send` will see to tell it from the others: the `arguments`
|
|
85
|
+
* object of a call, or the reference `run` put in a list or ping's `_meta`. Never throws: the
|
|
86
|
+
* Exchange says what happened.
|
|
87
|
+
*/
|
|
88
|
+
private exchange;
|
|
89
|
+
call(tool: JsonObject, name: string, args: JsonObject, signal: AbortSignal): Promise<Exchange>;
|
|
90
|
+
/** A request without arguments of its own: `_meta` carries what tells it from the others. */
|
|
91
|
+
private plain;
|
|
92
|
+
listPage(cursor: string | undefined, signal: AbortSignal): Promise<Exchange>;
|
|
93
|
+
ping(signal: AbortSignal): Promise<Exchange>;
|
|
94
|
+
close(reason?: SessionEnd): Promise<void>;
|
|
95
|
+
private shutDown;
|
|
96
|
+
}
|