@howaboua/pi-chatgpt-sites 0.0.0-stage → 0.0.2

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/CHANGELOG.md ADDED
@@ -0,0 +1,11 @@
1
+ # @howaboua/pi-chatgpt-sites
2
+
3
+ ## 0.0.2
4
+
5
+ - Streamlined tool descriptions and on-demand help discovery. Guide contents are unchanged.
6
+
7
+ ## 0.0.1
8
+
9
+ - ### Features
10
+ - Added Pi Sites with site management, committed-source saves, deployment and on-demand documentation.
11
+ - Tools are automatically deferred in Code Mode and Notebook.
package/LICENSE ADDED
@@ -0,0 +1,22 @@
1
+ MIT License
2
+
3
+ Copyright (c) 2026 pasky
4
+ Copyright (c) 2026 Igor Warzocha
5
+
6
+ Permission is hereby granted, free of charge, to any person obtaining a copy
7
+ of this software and associated documentation files (the "Software"), to deal
8
+ in the Software without restriction, including without limitation the rights
9
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10
+ copies of the Software, and to permit persons to whom the Software is
11
+ furnished to do so, subject to the following conditions:
12
+
13
+ The above copyright notice and this permission notice shall be included in all
14
+ copies or substantial portions of the Software.
15
+
16
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22
+ SOFTWARE.
package/README.md CHANGED
@@ -1,3 +1,21 @@
1
- # Temporary Holding Version
1
+ # Pi ChatGPT Sites
2
2
 
3
- This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
3
+ Manage ChatGPT Sites from Pi: inspect sites, save committed source, deploy saved versions, and read access, environment, domains, analytics, logs, database tables, and schedules.
4
+
5
+ ```sh
6
+ pi install npm:@howaboua/pi-chatgpt-sites
7
+ ```
8
+
9
+ Sign in with `/login openai-codex` using the legacy OpenAI Codex provider. The account must have Sites access. The extension uses Pi's authentication and refresh, not a separate token file.
10
+
11
+ Ask Pi to inspect your Sites. The `sites` tool returns help with no arguments, and `sites_documentation` provides topic guides and current operation parameters. In Code Mode and Notebook, both tools are automatically deferred and discoverable through `ALL_TOOLS`.
12
+
13
+ The repository binding is `.openai/hosting.json`. Source saves require Git and a clean, committed, bound repository. Saves push exact HEAD. Deployments are production and require explicit audience selection. Publication terms may require browser acceptance. Credentials and secret environment values are redacted from results.
14
+
15
+ This uses the private Sites beta API, which may change. Installation does not create or deploy a site.
16
+
17
+ ## Migrating from the bundled custom tools
18
+
19
+ Remove `sites.toml`, `sites_documentation.toml`, and their `sites/` companion directory from your custom-tool definitions before installing this extension. Keep your repository's `.openai/hosting.json` binding.
20
+
21
+ Calls now use structured arguments: `sites({resource, action, params})` and `sites_documentation({topic})`. In Code Mode and Notebook, use the same objects with `tools.sites(...)` and `tools.sites_documentation(...)`.
package/changelog.ts ADDED
@@ -0,0 +1,337 @@
1
+ // Generated extension packages copy this file during changelog:extensions.
2
+
3
+ import { randomUUID } from "node:crypto";
4
+ import { readFileSync } from "node:fs";
5
+ import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
6
+ import { dirname, join } from "node:path";
7
+ import { fileURLToPath } from "node:url";
8
+ import {
9
+ DynamicBorder,
10
+ type ExtensionAPI,
11
+ getAgentDir,
12
+ getMarkdownTheme,
13
+ } from "@earendil-works/pi-coding-agent";
14
+ import { Container, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
15
+
16
+ const ENTRY_TYPE = "@howaboua/pi-stuff/changelog";
17
+ const REGISTRATION_CHANNEL = "@howaboua/pi-stuff/changelog/register/v1";
18
+ const STATE_FILENAME = "howaboua-pi-stuff-changelog.json";
19
+ const SUPPRESS_KEY = "suppress";
20
+ const LOCK_STALE_MS = 30_000;
21
+ const LOCK_TIMEOUT_MS = 2_000;
22
+
23
+ interface PackageMetadata {
24
+ name: string;
25
+ version: string;
26
+ }
27
+
28
+ interface PackageRegistration extends PackageMetadata {
29
+ changelogPath: string;
30
+ }
31
+
32
+ interface RegistrationEvent {
33
+ accept: () => void;
34
+ registration: PackageRegistration;
35
+ }
36
+
37
+ interface ChangelogEntry {
38
+ content: string;
39
+ version: string;
40
+ }
41
+
42
+ interface ChangelogEntryData {
43
+ markdown: string;
44
+ }
45
+
46
+ type ChangelogState = Record<string, boolean | string>;
47
+
48
+ function packageRegistration(): PackageRegistration {
49
+ const packageDirectory = fileURLToPath(new URL(".", import.meta.url));
50
+ const metadata = JSON.parse(
51
+ readFileSync(join(packageDirectory, "package.json"), "utf8"),
52
+ ) as Partial<PackageMetadata>;
53
+ if (typeof metadata.name !== "string" || typeof metadata.version !== "string")
54
+ throw new Error(`Invalid package metadata in ${packageDirectory}`);
55
+ return {
56
+ name: metadata.name,
57
+ version: metadata.version,
58
+ changelogPath: join(packageDirectory, "CHANGELOG.md"),
59
+ };
60
+ }
61
+
62
+ function isRegistrationEvent(value: unknown): value is RegistrationEvent {
63
+ if (!value || typeof value !== "object") return false;
64
+ const event = value as Partial<RegistrationEvent>;
65
+ return (
66
+ typeof event.accept === "function" &&
67
+ typeof event.registration?.name === "string" &&
68
+ typeof event.registration.version === "string" &&
69
+ typeof event.registration.changelogPath === "string"
70
+ );
71
+ }
72
+
73
+ function parseChangelog(markdown: string): ChangelogEntry[] {
74
+ const entries: ChangelogEntry[] = [];
75
+ let currentLines: string[] = [];
76
+ let currentVersion: string | undefined;
77
+
78
+ for (const line of markdown.split("\n")) {
79
+ const version = line.match(/^##\s+\[?(\d+\.\d+\.\d+)\]?(?:\s.*)?$/)?.[1];
80
+ if (version) {
81
+ if (currentVersion)
82
+ entries.push({
83
+ content: currentLines.join("\n").trim(),
84
+ version: currentVersion,
85
+ });
86
+ currentVersion = version;
87
+ currentLines = [line];
88
+ } else if (currentVersion) {
89
+ currentLines.push(line);
90
+ }
91
+ }
92
+
93
+ if (currentVersion)
94
+ entries.push({
95
+ content: currentLines.join("\n").trim(),
96
+ version: currentVersion,
97
+ });
98
+ return entries;
99
+ }
100
+
101
+ function compareVersions(left: string, right: string): number {
102
+ const leftParts = left.split(".").map(Number);
103
+ const rightParts = right.split(".").map(Number);
104
+ for (let index = 0; index < 3; index++) {
105
+ const difference = (leftParts[index] ?? 0) - (rightParts[index] ?? 0);
106
+ if (difference !== 0) return difference;
107
+ }
108
+ return 0;
109
+ }
110
+
111
+ function isStableVersion(version: string): boolean {
112
+ return /^\d+\.\d+\.\d+$/.test(version);
113
+ }
114
+
115
+ function statePath(): string {
116
+ return join(getAgentDir(), STATE_FILENAME);
117
+ }
118
+
119
+ async function readState(path: string): Promise<ChangelogState> {
120
+ let text: string;
121
+ try {
122
+ text = await readFile(path, "utf8");
123
+ } catch (error) {
124
+ if ((error as NodeJS.ErrnoException).code === "ENOENT") return {};
125
+ throw error;
126
+ }
127
+ const parsed = JSON.parse(text) as unknown;
128
+ if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
129
+ throw new Error(`${path} must contain a JSON object`);
130
+ for (const [name, value] of Object.entries(parsed)) {
131
+ if (name === SUPPRESS_KEY) {
132
+ if (typeof value !== "boolean")
133
+ throw new Error(`${path} ${SUPPRESS_KEY} must be a boolean`);
134
+ } else if (typeof value !== "string") {
135
+ throw new Error(`${path} version for ${name} must be a string`);
136
+ }
137
+ }
138
+ return parsed as ChangelogState;
139
+ }
140
+
141
+ async function acquireLock(path: string): Promise<() => Promise<void>> {
142
+ const deadline = Date.now() + LOCK_TIMEOUT_MS;
143
+ while (true) {
144
+ try {
145
+ await mkdir(path);
146
+ return () => rm(path, { force: true, recursive: true });
147
+ } catch (error) {
148
+ if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
149
+ const info = await stat(path).catch(() => undefined);
150
+ if (info && Date.now() - info.mtimeMs > LOCK_STALE_MS) {
151
+ await rm(path, { force: true, recursive: true });
152
+ continue;
153
+ }
154
+ if (Date.now() >= deadline)
155
+ throw new Error(`Timed out waiting for ${path}`);
156
+ await new Promise((resolve) => setTimeout(resolve, 20));
157
+ }
158
+ }
159
+ }
160
+
161
+ async function writeState(path: string, state: ChangelogState): Promise<void> {
162
+ await mkdir(dirname(path), { mode: 0o700, recursive: true });
163
+ const temporaryPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
164
+ try {
165
+ const ordered = Object.fromEntries(
166
+ Object.entries(state).sort(([left], [right]) =>
167
+ left.localeCompare(right),
168
+ ),
169
+ );
170
+ await writeFile(temporaryPath, `${JSON.stringify(ordered, null, 2)}\n`, {
171
+ encoding: "utf8",
172
+ mode: 0o600,
173
+ });
174
+ await rename(temporaryPath, path);
175
+ } catch (error) {
176
+ await rm(temporaryPath, { force: true });
177
+ throw error;
178
+ }
179
+ }
180
+
181
+ function packageMarkdown(
182
+ registration: PackageRegistration,
183
+ entries: ChangelogEntry[],
184
+ ): string {
185
+ const body = (entry: ChangelogEntry) =>
186
+ entry.content
187
+ .replace(/^##[^\n]*\n*/, "")
188
+ .replace(/^###\s+(?:Changes|Minor Changes|Patch Changes)\s*\n*/gim, "")
189
+ .replace(/^###\s+(.+)$/gm, "**$1**");
190
+ if (entries.length === 1) {
191
+ const [entry] = entries;
192
+ if (!entry) return "";
193
+ return `## ${registration.name} ${entry.version}\n\n${body(entry)}`;
194
+ }
195
+ return [
196
+ `## ${registration.name}`,
197
+ ...entries.map((entry) => `**${entry.version}**\n\n${body(entry)}`),
198
+ ].join("\n\n");
199
+ }
200
+
201
+ async function claimUpdates(
202
+ registrations: Iterable<PackageRegistration>,
203
+ ): Promise<{ errors: string[]; markdown?: string }> {
204
+ const stableRegistrations = [...registrations]
205
+ .filter((registration) => isStableVersion(registration.version))
206
+ .sort((left, right) => left.name.localeCompare(right.name));
207
+ if (stableRegistrations.length === 0) return { errors: [] };
208
+ const path = statePath();
209
+ await mkdir(dirname(path), { mode: 0o700, recursive: true });
210
+ const release = await acquireLock(`${path}.lock`);
211
+ try {
212
+ const state = await readState(path);
213
+ const errors: string[] = [];
214
+ const sections: string[] = [];
215
+ let changed = false;
216
+ if (state[SUPPRESS_KEY] === true) {
217
+ for (const registration of stableRegistrations) {
218
+ const seenVersion = state[registration.name];
219
+ if (
220
+ typeof seenVersion !== "string" ||
221
+ compareVersions(registration.version, seenVersion) > 0
222
+ ) {
223
+ state[registration.name] = registration.version;
224
+ changed = true;
225
+ }
226
+ }
227
+ if (changed) await writeState(path, state);
228
+ return { errors };
229
+ }
230
+ for (const registration of stableRegistrations) {
231
+ const seenVersion = state[registration.name];
232
+ if (
233
+ typeof seenVersion === "string" &&
234
+ compareVersions(registration.version, seenVersion) <= 0
235
+ )
236
+ continue;
237
+ try {
238
+ const entries = parseChangelog(
239
+ await readFile(registration.changelogPath, "utf8"),
240
+ ).filter(
241
+ (entry) =>
242
+ compareVersions(entry.version, registration.version) <= 0 &&
243
+ (typeof seenVersion === "string"
244
+ ? compareVersions(entry.version, seenVersion) > 0
245
+ : entry.version === registration.version),
246
+ );
247
+ if (entries.length === 0) {
248
+ errors.push(
249
+ `No ${registration.version} changelog entry found for ${registration.name}`,
250
+ );
251
+ continue;
252
+ }
253
+ sections.push(packageMarkdown(registration, entries));
254
+ state[registration.name] = registration.version;
255
+ changed = true;
256
+ } catch (error) {
257
+ errors.push(
258
+ `Could not read the ${registration.name} changelog: ${error instanceof Error ? error.message : String(error)}`,
259
+ );
260
+ }
261
+ }
262
+ if (changed) await writeState(path, state);
263
+ return {
264
+ errors,
265
+ ...(sections.length > 0 ? { markdown: sections.join("\n\n") } : {}),
266
+ };
267
+ } finally {
268
+ await release();
269
+ }
270
+ }
271
+
272
+ function registerCoordinator(
273
+ pi: ExtensionAPI,
274
+ registration: PackageRegistration,
275
+ ): void {
276
+ let accepted = false;
277
+ pi.events.emit(REGISTRATION_CHANNEL, {
278
+ registration,
279
+ accept: () => {
280
+ accepted = true;
281
+ },
282
+ } satisfies RegistrationEvent);
283
+ if (accepted) return;
284
+
285
+ const registrations = new Map([[registration.name, registration]]);
286
+ pi.events.on(REGISTRATION_CHANNEL, (value) => {
287
+ if (!isRegistrationEvent(value)) return;
288
+ registrations.set(value.registration.name, value.registration);
289
+ value.accept();
290
+ });
291
+ pi.registerEntryRenderer<ChangelogEntryData>(
292
+ ENTRY_TYPE,
293
+ (entry, _options, theme) => {
294
+ if (!entry.data) return undefined;
295
+ const container = new Container();
296
+ container.addChild(new DynamicBorder());
297
+ container.addChild(
298
+ new Text(theme.bold(theme.fg("accent", "What's New")), 1, 0),
299
+ );
300
+ container.addChild(new Spacer(1));
301
+ container.addChild(
302
+ new Markdown(entry.data.markdown.trim(), 1, 0, getMarkdownTheme()),
303
+ );
304
+ container.addChild(new Spacer(1));
305
+ container.addChild(new DynamicBorder());
306
+ return container;
307
+ },
308
+ );
309
+ pi.on("session_start", async (event, ctx) => {
310
+ if (event.reason === "reload" || ctx.mode !== "tui") return;
311
+ if (
312
+ ctx.sessionManager
313
+ .getEntries()
314
+ .some((entry) =>
315
+ ["branch_summary", "compaction", "message"].includes(entry.type),
316
+ )
317
+ )
318
+ return;
319
+ try {
320
+ const update = await claimUpdates(registrations.values());
321
+ if (update.markdown)
322
+ pi.appendEntry<ChangelogEntryData>(ENTRY_TYPE, {
323
+ markdown: update.markdown,
324
+ });
325
+ for (const error of update.errors) ctx.ui.notify(error, "warning");
326
+ } catch (error) {
327
+ ctx.ui.notify(
328
+ `Could not update Howaboua changelog state: ${error instanceof Error ? error.message : String(error)}`,
329
+ "warning",
330
+ );
331
+ }
332
+ });
333
+ }
334
+
335
+ export default function howabouaPackageChangelog(pi: ExtensionAPI): void {
336
+ registerCoordinator(pi, packageRegistration());
337
+ }
@@ -0,0 +1,2 @@
1
+ import { type ExtensionAPI } from "@earendil-works/pi-coding-agent";
2
+ export default function sitesExtension(pi: ExtensionAPI): Promise<void>;
package/dist/index.js ADDED
@@ -0,0 +1,113 @@
1
+ import { defineTool } from "@earendil-works/pi-coding-agent";
2
+ import { Type } from "typebox";
3
+ import { getSitesAuth } from "./src/auth.js";
4
+ import { SitesClient } from "./src/client.js";
5
+ import { call, documentation } from "./src/facade.js";
6
+ import { boundedJson } from "./src/redact.js";
7
+ async function result(run) {
8
+ try {
9
+ const value = await run();
10
+ const text = typeof value === "string" ? value : boundedJson(value);
11
+ if (text.startsWith("{")) {
12
+ const parsed = JSON.parse(text);
13
+ if (isRecord(parsed) &&
14
+ parsed["ok"] === false &&
15
+ isRecord(parsed["error"])) {
16
+ const info = parsed["error"];
17
+ throw Object.assign(new Error(String(info["message"])), info);
18
+ }
19
+ }
20
+ return { content: [{ type: "text", text }], details: undefined };
21
+ }
22
+ catch (error) {
23
+ const info = error instanceof Error ? error : new Error(String(error));
24
+ throw new Error(boundedJson({
25
+ ok: false,
26
+ error: {
27
+ code: "code" in info ? (info.code ?? "sites_error") : "sites_error",
28
+ message: info.message,
29
+ topic: "topic" in info ? info.topic : undefined,
30
+ terms_url: "termsUrl" in info ? info.termsUrl : undefined,
31
+ status: "status" in info ? info.status : undefined,
32
+ details: "details" in info ? info.details : undefined,
33
+ },
34
+ }));
35
+ }
36
+ }
37
+ function isRecord(value) {
38
+ return value !== null && typeof value === "object" && !Array.isArray(value);
39
+ }
40
+ export default async function sitesExtension(pi) {
41
+ const sites = defineTool({
42
+ name: "sites",
43
+ label: "Sites",
44
+ description: "Manage ChatGPT Sites",
45
+ parameters: Type.Object({
46
+ resource: Type.Optional(Type.String()),
47
+ action: Type.Optional(Type.String()),
48
+ params: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
49
+ }, { additionalProperties: false }),
50
+ async execute(_id, args, signal, _onUpdate, ctx) {
51
+ const client = new SitesClient({
52
+ authProvider: () => getSitesAuth(ctx),
53
+ signal,
54
+ });
55
+ return result(() => Object.keys(args).length === 0 || args.action === "help"
56
+ ? documentation("index", client)
57
+ : call(args, client, ctx.cwd, signal));
58
+ },
59
+ });
60
+ const guide = defineTool({
61
+ name: "sites_documentation",
62
+ label: "Sites documentation",
63
+ description: "Sites guide or current resource.action parameter schema",
64
+ parameters: Type.Object({ topic: Type.Optional(Type.String()) }, { additionalProperties: false }),
65
+ async execute(_id, args, signal, _onUpdate, ctx) {
66
+ return result(() => documentation(args.topic === "help" ? "index" : args.topic, new SitesClient({ authProvider: () => getSitesAuth(ctx), signal })));
67
+ },
68
+ });
69
+ const tools = [
70
+ {
71
+ tool: sites,
72
+ gpt: "Manage ChatGPT Sites",
73
+ ordinary: sites.description,
74
+ },
75
+ {
76
+ tool: guide,
77
+ gpt: "Sites guide or live resource.action parameter schema",
78
+ ordinary: guide.description,
79
+ },
80
+ ];
81
+ for (const { tool } of tools)
82
+ pi.registerTool(tool);
83
+ try {
84
+ const { adaptToolForCodeMode, registerCodeModeExtensionTools } = await import("@howaboua/pi-codex-conversion/code-mode");
85
+ const registration = registerCodeModeExtensionTools(pi, () => tools.map(({ tool }) => adaptToolForCodeMode(tool, {
86
+ discovery: "help",
87
+ deferLoading: true,
88
+ })));
89
+ pi.on("session_shutdown", () => registration.unregister());
90
+ const { registerGptPromptMode } = await import("@howaboua/pi-codex-conversion/prompt-mode");
91
+ registerGptPromptMode(pi, (active) => {
92
+ for (const { tool, gpt, ordinary } of tools) {
93
+ const description = active ? gpt : ordinary;
94
+ if (tool.description !== description) {
95
+ tool.description = description;
96
+ pi.registerTool(tool);
97
+ }
98
+ }
99
+ return tools.map(({ tool }) => tool);
100
+ });
101
+ }
102
+ catch (error) {
103
+ if (!(error instanceof Error) ||
104
+ !("code" in error) ||
105
+ ![
106
+ "ERR_MODULE_NOT_FOUND",
107
+ "MODULE_NOT_FOUND",
108
+ "ERR_PACKAGE_PATH_NOT_EXPORTED",
109
+ ].includes(String(error.code)) ||
110
+ !error.message.includes("@howaboua/pi-codex-conversion"))
111
+ throw error;
112
+ }
113
+ }
@@ -0,0 +1,5 @@
1
+ import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
2
+ export declare function getSitesAuth(ctx: ExtensionContext): Promise<{
3
+ token: string;
4
+ accountId: string;
5
+ }>;
@@ -0,0 +1,27 @@
1
+ export async function getSitesAuth(ctx) {
2
+ const token = await ctx.modelRegistry.getApiKeyForProvider("openai-codex");
3
+ const message = "Sites requires an OpenAI Codex login. Ask the user to run /login openai-codex (legacy OpenAI Codex)";
4
+ if (!token)
5
+ throw new Error(message);
6
+ try {
7
+ const part = token.split(".")[1];
8
+ if (!part)
9
+ throw new Error(message);
10
+ const claims = JSON.parse(Buffer.from(part, "base64url").toString("utf8"));
11
+ const identity = isRecord(claims)
12
+ ? claims["https://api.openai.com/auth"]
13
+ : undefined;
14
+ const accountId = isRecord(identity)
15
+ ? identity["chatgpt_account_id"]
16
+ : undefined;
17
+ if (typeof accountId !== "string" || !accountId)
18
+ throw new Error(message);
19
+ return { token, accountId };
20
+ }
21
+ catch {
22
+ throw new Error(message);
23
+ }
24
+ }
25
+ function isRecord(value) {
26
+ return value !== null && typeof value === "object" && !Array.isArray(value);
27
+ }
@@ -0,0 +1,36 @@
1
+ export interface JsonSchema {
2
+ [key: string]: unknown;
3
+ properties?: Record<string, unknown>;
4
+ required?: string[];
5
+ }
6
+ export interface SitesClientOptions {
7
+ fetchImpl?: typeof fetch;
8
+ authProvider: () => Promise<{
9
+ token: string;
10
+ accountId: string;
11
+ }>;
12
+ signal?: AbortSignal | undefined;
13
+ }
14
+ interface SitesTool {
15
+ name: string;
16
+ inputSchema?: JsonSchema;
17
+ _meta: Record<string, unknown>;
18
+ }
19
+ export declare class SitesClient {
20
+ private fetchImpl;
21
+ private authProvider;
22
+ private signal;
23
+ private requestId;
24
+ private tools;
25
+ private headers;
26
+ constructor({ fetchImpl, authProvider, signal }: SitesClientOptions);
27
+ initialize(): Promise<void>;
28
+ listSitesTools(): Promise<SitesTool[]>;
29
+ schema(toolSuffix: string): Promise<JsonSchema | undefined>;
30
+ call(toolSuffix: string, args: unknown): Promise<unknown>;
31
+ findTool(toolSuffix: string): Promise<SitesTool>;
32
+ rpc(method: string, params: unknown, { notification }?: {
33
+ notification?: boolean;
34
+ }): Promise<unknown>;
35
+ }
36
+ export {};