};

}

export type GoogleMeetCurrentTabRecoveryResult = Awaited<

ReturnType<typeof recoverCurrentMeetTab | typeof recoverCurrentMeetTabOnNode>

>;

export async function launchChromeMeetOnNode(params: {

runtime: PluginRuntime;

config: GoogleMeetConfig;

return false;

}

export function collectMattermostSlashCallbackPaths(raw?: Partial<MattermostSlashCommandConfig>) {

const config = resolveSlashCommandConfig(raw);

const paths = new Set<string>([config.callbackPath]);

if (typeof config.callbackUrl === "string" && config.callbackUrl.trim()) {

try {

const pathname = new URL(config.callbackUrl).pathname;

if (pathname) {

paths.add(pathname);

}

} catch {

// Ignore invalid callback URLs and keep the normalized callback path only.

}

}

return [...paths];

}

/**

* Build the callback URL that Mattermost will POST to when a command is invoked.

*/

import type { IncomingMessage, ServerResponse } from "node:http";

import type { Mock } from "vitest";

import { vi } from "vitest";

import type { ResolvedSynologyChatAccount } from "./types.js";

export type RegisteredRoute = {

path: string;

})),

setSynologyRuntime: vi.fn(),

}));

export function makeSecurityAccount(

overrides: Partial<ResolvedSynologyChatAccount> = {},

): ResolvedSynologyChatAccount {

return {

accountId: "default",

enabled: true,

token: "t",

incomingUrl: "https://nas/incoming",

nasHost: "h",

webhookPath: "/w",

webhookPathSource: "default",

dangerouslyAllowNameMatching: false,

dangerouslyAllowInheritedWebhookPath: false,

dmPolicy: "allowlist" as const,

allowedUserIds: [],

rateLimitPerMinute: 30,

botName: "Bot",

allowInsecureSsl: false,

...overrides,

};

}

XAI_RESPONSES_ENDPOINT,

} from "./responses-tool-shared.js";

import {

coerceXaiToolConfig,

resolveNormalizedXaiToolModel,

resolvePositiveIntegerToolConfig,

} from "./tool-config-shared.js";

export const XAI_CODE_EXECUTION_ENDPOINT = XAI_RESPONSES_ENDPOINT;

export const XAI_DEFAULT_CODE_EXECUTION_MODEL = "grok-4-1-fast";

export type XaiCodeExecutionConfig = {

apiKey?: unknown;

model?: unknown;

maxTurns?: unknown;

};

export type XaiCodeExecutionResponse = XaiWebSearchResponse & {

output?: Array<{

type?: string;

outputTypes: string[];

};

export function resolveXaiCodeExecutionConfig(

config?: Record<string, unknown>,

): XaiCodeExecutionConfig {

return coerceXaiToolConfig(config) as XaiCodeExecutionConfig;

}

export function resolveXaiCodeExecutionModel(config?: Record<string, unknown>): string {

return resolveNormalizedXaiToolModel({

config,