@rnsk/toolkits 0.0.10 → 0.0.12

package/dist/toolkits/new-relic/tools/synthetics.js

@@ -0,0 +1,246 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { accountIdField, nerdgraph, newRelicApiKeyField, synthApi } from './client.js';
+const MONITOR_PERIODS = ['EVERY_MINUTE', 'EVERY_5_MINUTES', 'EVERY_10_MINUTES', 'EVERY_15_MINUTES', 'EVERY_30_MINUTES', 'EVERY_HOUR', 'EVERY_6_HOURS', 'EVERY_12_HOURS', 'EVERY_DAY'];
+const monitorLocations = z.object({
+    public: z.array(z.string()).optional().describe("Public locations, e.g. ['AWS_US_EAST_1','AWS_EU_WEST_1'] (at least one public or private required)"),
+    private: z.array(z.string()).optional().describe('Private location GUIDs'),
+}).describe('Where the monitor runs');
+const SYNTH_ERRORS = 'errors { description type }';
+// ---- REST API v3 monitors ----
+const legacyFrequency = z.number().int().describe('Check frequency minutes: 1, 5, 10, 15, 30, 60, 360, 720, or 1440');
+export const createMonitor = tool({
+    description: 'Creates a legacy synthetic monitor (SIMPLE ping, BROWSER, SCRIPT_API, SCRIPT_BROWSER) via REST v3 for uptime checks.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        name: z.string().describe('Monitor name, descriptive and unique'),
+        type: z.enum(['SIMPLE', 'BROWSER', 'SCRIPT_API', 'SCRIPT_BROWSER']),
+        frequency: legacyFrequency,
+        locations: z.array(z.string()).min(1).describe("Locations, e.g. ['AWS_US_EAST_1'] (list valid ones via listLocations)"),
+        status: z.enum(['ENABLED', 'DISABLED']).describe('ENABLED runs immediately'),
+        uri: z.string().optional().describe('URL to monitor (required for SIMPLE/BROWSER)'),
+    }),
+    execute: async ({ newRelicApiKey, ...monitor }) => synthApi(newRelicApiKey, 'POST', '/monitors', { body: monitor }, 'create synthetic monitor'),
+});
+export const getSynthMonitor = tool({
+    description: 'Reads one synthetic monitor (config, status, SLA threshold) by UUID.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        monitorId: z.string().describe('Monitor UUID to retrieve'),
+    }),
+    execute: async ({ newRelicApiKey, monitorId }) => synthApi(newRelicApiKey, 'GET', `/monitors/${monitorId}`, undefined, 'get synthetic monitor'),
+});
+export const listMonitors = tool({
+    description: 'Lists synthetic monitors with limit/offset pagination (max 100 per page).',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        limit: z.number().int().min(1).max(100).optional().describe('Results per page (default 50, max 100)'),
+        offset: z.number().int().min(0).optional().describe('Monitors to skip (default 0)'),
+    }),
+    execute: async ({ newRelicApiKey, limit, offset }) => synthApi(newRelicApiKey, 'GET', '/monitors', { query: { limit, offset } }, 'list synthetic monitors'),
+});
+export const patchMonitor = tool({
+    description: 'Partially updates a synthetic monitor. Only provided fields change — use for small tweaks.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        monitorId: z.string().describe('Monitor UUID to update'),
+        name: z.string().optional(),
+        type: z.enum(['SIMPLE', 'BROWSER', 'SCRIPT_API', 'SCRIPT_BROWSER']).optional(),
+        frequency: legacyFrequency.optional(),
+        uri: z.string().optional().describe('Valid HTTP/HTTPS URL'),
+        locations: z.array(z.string()).optional(),
+        status: z.enum(['ENABLED', 'DISABLED']).optional(),
+        slaThreshold: z.number().optional().describe('Acceptable response-time seconds'),
+    }),
+    execute: async ({ newRelicApiKey, monitorId, ...patch }) => synthApi(newRelicApiKey, 'PATCH', `/monitors/${monitorId}`, { body: patch }, 'patch synthetic monitor'),
+});
+export const updateSynthMonitor = tool({
+    description: 'Fully replaces a synthetic monitor via PUT. All fields required (name, type, frequency, uri, locations, status).',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        monitorId: z.string().describe('Monitor UUID to replace'),
+        name: z.string(),
+        type: z.enum(['SIMPLE', 'BROWSER', 'SCRIPT_API', 'SCRIPT_BROWSER']).describe('Type cannot be changed on update'),
+        frequency: legacyFrequency,
+        uri: z.string().describe('Valid HTTP/HTTPS URL'),
+        locations: z.array(z.string()).min(1),
+        status: z.enum(['ENABLED', 'DISABLED']),
+        slaThreshold: z.number().min(0).optional().describe('SLA threshold seconds'),
+    }),
+    execute: async ({ newRelicApiKey, monitorId, ...monitor }) => synthApi(newRelicApiKey, 'PUT', `/monitors/${monitorId}`, { body: monitor }, 'update synthetic monitor'),
+});
+export const deleteMonitor = tool({
+    description: 'Permanently deletes a synthetic monitor by UUID. Immediate and irreversible.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        monitorId: z.string().describe('Monitor UUID to delete'),
+    }),
+    execute: async ({ newRelicApiKey, monitorId }) => synthApi(newRelicApiKey, 'DELETE', `/monitors/${monitorId}`, undefined, 'delete synthetic monitor'),
+});
+export const updateMonitorScript = tool({
+    description: 'Updates the script of a SCRIPT_BROWSER/SCRIPT_API monitor. Sends base64-encoded JavaScript (Selenium for browser, http-request for API).',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        monitorId: z.string().describe('SCRIPT_BROWSER or SCRIPT_API monitor UUID'),
+        scriptText: z.string().describe('Base64-encoded script content'),
+    }),
+    execute: async ({ newRelicApiKey, monitorId, scriptText }) => synthApi(newRelicApiKey, 'PUT', `/monitors/${monitorId}/script`, { body: { scriptText } }, 'update monitor script'),
+});
+export const listLocations = tool({
+    description: 'Lists valid public and private locations for synthetic monitors. Run before creating monitors to pick location codes.',
+    inputSchema: z.object({ newRelicApiKey: newRelicApiKeyField }),
+    execute: async ({ newRelicApiKey }) => synthApi(newRelicApiKey, 'GET', '/locations', undefined, 'list synthetic monitor locations'),
+});
+// ---- NerdGraph synthetics ----
+const runtimeInput = z.object({
+    runtimeType: z.string().describe("Runtime, e.g. 'NODE_API', 'CHROME_BROWSER'"),
+    runtimeTypeVersion: z.string().describe("Version, e.g. '16.10' (Node) or '100' (Chrome)"),
+    scriptLanguage: z.string().optional().describe("Default 'JAVASCRIPT'"),
+});
+export const createSyntheticsSimpleMonitor = tool({
+    description: 'Creates a ping (SIMPLE) monitor via NerdGraph checking URL availability from multiple locations with TLS/response validation options.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdField('Account ID for the monitor'),
+        name: z.string().describe('Monitor name'),
+        uri: z.string().describe('Valid HTTP/HTTPS URL to monitor'),
+        locations: z.object({ public: z.array(z.string()).min(1).describe("Location codes, e.g. ['AWS_US_EAST_1']") }).describe('Run locations'),
+        period: z.enum(MONITOR_PERIODS),
+        status: z.enum(['ENABLED', 'DISABLED']).describe('ENABLED starts monitoring immediately'),
+        advancedOptions: z.object({
+            customHeaders: z.array(z.object({ name: z.string(), value: z.string() })).optional(),
+            useTlsValidation: z.boolean().optional(),
+            responseValidationText: z.string().optional().describe('Required body text — monitor fails without it'),
+        }).optional(),
+    }),
+    execute: async ({ newRelicApiKey, accountId, ...monitor }) => nerdgraph(newRelicApiKey, `mutation($accountId: Int!, $monitor: SyntheticsCreateSimpleMonitorInput!) { syntheticsCreateSimpleMonitor(accountId: $accountId, monitor: $monitor) { monitor { id name uri } ${SYNTH_ERRORS} } }`, { accountId, monitor }, 'create synthetics simple monitor'),
+});
+export const updateSyntheticsSimpleMonitor = tool({
+    description: 'Updates a ping monitor (name, status, period, URI, locations, apdex, TLS/redirect/validation options). Only provided fields change.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        guid: z.string().describe('Monitor entity GUID to update'),
+        monitor: z.object({
+            name: z.string().optional(),
+            uri: z.string().optional().describe('Valid HTTP/HTTPS URL'),
+            period: z.enum(MONITOR_PERIODS).optional(),
+            status: z.enum(['ENABLED', 'DISABLED']).optional(),
+            locations: z.array(z.string()).optional().describe('Location codes (omit to keep)'),
+            apdexTarget: z.number().min(0).optional().describe('Acceptable response-time seconds'),
+            advancedOptions: z.object({
+                customHeaders: z.array(z.object({ name: z.string(), value: z.string() })).optional(),
+                useTlsValidation: z.boolean().optional(),
+                redirectIsFailure: z.boolean().optional().describe('Treat 3xx as failure'),
+                responseValidationText: z.string().optional(),
+                shouldBypassHeadRequest: z.boolean().optional().describe('Skip HEAD, go straight to GET'),
+            }).optional(),
+        }).describe('Fields to update'),
+    }),
+    execute: async ({ newRelicApiKey, guid, monitor }) => nerdgraph(newRelicApiKey, `mutation($guid: EntityGuid!, $monitor: SyntheticsUpdateSimpleMonitorInput!) { syntheticsUpdateSimpleMonitor(guid: $guid, monitor: $monitor) { ${SYNTH_ERRORS} } }`, { guid, monitor }, 'update synthetics simple monitor'),
+});
+export const createScriptedMonitor = tool({
+    description: 'Creates a scripted monitor via NerdGraph: SCRIPT_BROWSER (Selenium user flows) or SCRIPT_API (endpoint checks). Runtime must match the type.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdField('Account ID for the monitor'),
+        monitorType: z.enum(['SCRIPT_BROWSER', 'SCRIPT_API']),
+        name: z.string().describe('Monitor name, unique within the account'),
+        script: z.string().describe('JavaScript: Selenium ($browser) for browser, $http for API — include assertions'),
+        locations: monitorLocations,
+        period: z.enum(MONITOR_PERIODS).describe('Check frequency (frequent checks consume quota)'),
+        runtime: runtimeInput.describe('CHROME_BROWSER for SCRIPT_BROWSER, NODE_API for SCRIPT_API'),
+        status: z.enum(['ENABLED', 'DISABLED', 'MUTED']).optional().describe('Initial status (default ENABLED)'),
+        advancedOptions: z.record(z.any()).optional().describe('Custom headers, device emulation, validation rules'),
+    }),
+    execute: async ({ newRelicApiKey, accountId, monitorType, ...monitor }) => nerdgraph(newRelicApiKey, `mutation($accountId: Int!, $monitor: SyntheticsCreateScriptedMonitorInput!) { syntheticsCreateScriptedMonitor(accountId: $accountId, monitorType: ${monitorType}, monitor: $monitor) { monitor { id name } ${SYNTH_ERRORS} } }`, { accountId, monitor: { status: 'ENABLED', ...monitor } }, 'create scripted monitor'),
+});
+export const updateScriptedMonitor = tool({
+    description: 'Updates a scripted monitor (name, period, script, locations, status, apdex). Only provided fields change.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        guid: z.string().describe('Monitor entity GUID to update'),
+        monitorType: z.enum(['SCRIPT_BROWSER', 'SCRIPT_API']).describe('Determines which mutation runs'),
+        monitor: z.object({
+            name: z.string().optional(),
+            script: z.string().optional().describe('Updated script content'),
+            period: z.enum(MONITOR_PERIODS).optional(),
+            status: z.enum(['ENABLED', 'DISABLED', 'MUTED']).optional(),
+            locations: z.object({
+                public: z.array(z.string()).optional(),
+                private: z.array(z.string()).optional(),
+            }).optional(),
+            apdexTarget: z.number().optional().describe('SLA seconds (default 7.0)'),
+        }).describe('Fields to update'),
+    }),
+    execute: async ({ newRelicApiKey, guid, monitorType, monitor }) => {
+        const mutation = monitorType === 'SCRIPT_BROWSER' ? 'syntheticsUpdateScriptBrowserMonitor' : 'syntheticsUpdateScriptApiMonitor';
+        return nerdgraph(newRelicApiKey, `mutation($guid: EntityGuid!, $monitor: SyntheticsUpdateScriptedMonitorInput!) { ${mutation}(guid: $guid, monitor: $monitor) { monitor { guid name } ${SYNTH_ERRORS} } }`, { guid, monitor }, 'update scripted monitor');
+    },
+});
+export const createBrokenLinksMonitor = tool({
+    description: 'Creates a broken-links monitor scanning a webpage for dead links on a schedule. Needs NODE_API runtime and at least one location.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdField('Account ID for the monitor'),
+        name: z.string().describe('Monitor name'),
+        uri: z.string().describe('Valid HTTP/HTTPS page URL to scan'),
+        period: z.enum(MONITOR_PERIODS),
+        status: z.enum(['ENABLED', 'DISABLED']).describe('ENABLED runs immediately'),
+        runtime: z.object({
+            runtimeType: z.string().describe("e.g. 'NODE_API'"),
+            runtimeTypeVersion: z.string().describe("e.g. '16.10'"),
+        }).describe('Execution environment'),
+        locations: monitorLocations,
+        tags: z.array(z.object({ key: z.string(), values: z.array(z.string()) })).optional().describe('Organizational tags'),
+    }),
+    execute: async ({ newRelicApiKey, accountId, ...monitor }) => nerdgraph(newRelicApiKey, `mutation($accountId: Int!, $monitor: SyntheticsCreateBrokenLinksMonitorInput!) { syntheticsCreateBrokenLinksMonitor(accountId: $accountId, monitor: $monitor) { ${SYNTH_ERRORS} } }`, { accountId, monitor }, 'create broken links monitor'),
+});
+export const createSyntheticsPrivateLocation = tool({
+    description: 'Creates a private location for running monitors inside your own infrastructure. Returns a GUID for monitor targeting.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdField('Account ID for the location'),
+        name: z.string().describe('Location name'),
+        description: z.string().optional(),
+        verifiedScriptExecution: z.boolean().optional().describe('Require password to edit (default false)'),
+    }),
+    execute: async ({ newRelicApiKey, accountId, ...input }) => nerdgraph(newRelicApiKey, `mutation($accountId: Int!, $privateLocation: SyntheticsPrivateLocationInput!) { syntheticsCreatePrivateLocation(accountId: $accountId, privateLocation: $privateLocation) { guid ${SYNTH_ERRORS} } }`, { accountId, privateLocation: input }, 'create synthetics private location'),
+});
+export const deleteSyntheticsPrivateLocation = tool({
+    description: 'Permanently deletes a private location by GUID. Monitors targeting it stop running there.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        guid: z.string().describe('Private location entity GUID to delete'),
+    }),
+    execute: async ({ newRelicApiKey, guid }) => nerdgraph(newRelicApiKey, `mutation($guid: EntityGuid!) { syntheticsDeletePrivateLocation(guid: $guid) { ${SYNTH_ERRORS} } }`, { guid }, 'delete synthetics private location'),
+});
+export const deleteSyntheticsMonitorGraphql = tool({
+    description: 'Deletes a synthetic monitor by entity GUID via NerdGraph. Immediate and irreversible.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        guid: z.string().describe('Monitor entity GUID to delete'),
+    }),
+    execute: async ({ newRelicApiKey, guid }) => nerdgraph(newRelicApiKey, 'mutation($guid: EntityGuid!) { syntheticsDeleteMonitor(guid: $guid) { deletedGuid } }', { guid }, 'delete synthetics monitor'),
+});
+export const createSyntheticsSecureCredential = tool({
+    description: 'Stores an encrypted credential (API keys, passwords, tokens) via NerdGraph for use in monitor scripts. Key: 1-64 uppercase chars.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdField('Account ID for the credential'),
+        key: z.string().min(1).max(64).describe('UPPERCASE key name (letters, numbers, underscores)'),
+        value: z.string().min(1).describe('Secret value (encrypted at rest)'),
+        description: z.string().optional(),
+    }),
+    execute: async ({ newRelicApiKey, accountId, key, value, description }) => nerdgraph(newRelicApiKey, `mutation($accountId: Int!, $key: String!, $value: SecureValue!, $description: String) { syntheticsCreateSecureCredential(accountId: $accountId, key: $key, value: $value, description: $description) { ${SYNTH_ERRORS} } }`, { accountId, key, value, description: description ?? null }, 'create synthetics secure credential'),
+});
+export const deleteSyntheticsSecureCredential = tool({
+    description: 'Permanently deletes a synthetics secure credential by account and key.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdField('Account ID owning the credential'),
+        key: z.string().min(1).max(64).describe('Credential key name to delete'),
+    }),
+    execute: async ({ newRelicApiKey, accountId, key }) => nerdgraph(newRelicApiKey, `mutation($accountId: Int!, $key: String!) { syntheticsDeleteSecureCredential(accountId: $accountId, key: $key) { ${SYNTH_ERRORS} } }`, { accountId, key }, 'delete synthetics secure credential'),
+});
+//# sourceMappingURL=synthetics.js.map

package/dist/toolkits/notebook-lm/icon.d.ts

@@ -0,0 +1,5 @@
+export declare const NOTEBOOK_LM_ICON: {
+    kind: "svg";
+    dataUri: string;
+};
+//# sourceMappingURL=icon.d.ts.map

package/dist/toolkits/notebook-lm/icon.js

@@ -0,0 +1,6 @@
+const SVG = `<svg fill="currentColor" fill-rule="evenodd" height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg"><title>NotebookLM</title><path d="M11.999 3.14C5.372 3.14 0 8.588 0 15.312v5.828h2.212v-.58c0-2.728 2.178-4.938 4.866-4.938 2.688 0 4.866 2.21 4.866 4.937v.581h2.212v-.58c0-3.967-3.17-7.18-7.078-7.18a6.966 6.966 0 00-4.086 1.318C4.2 12.262 6.687 10.59 9.56 10.59c4.057 0 7.347 3.338 7.347 7.453v3.097h2.212v-3.097c0-5.355-4.28-9.698-9.56-9.698a9.438 9.438 0 00-6.217 2.332C4.984 7.528 8.244 5.383 12 5.383c5.406 0 9.788 4.446 9.788 9.93v5.827H24v-5.828C23.999 8.588 18.627 3.14 11.999 3.14z"></path></svg>`;
+export const NOTEBOOK_LM_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

package/dist/toolkits/notebook-lm/manifest.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("../../index.js").ToolkitManifest;
+export default _default;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/toolkits/notebook-lm/manifest.js

@@ -0,0 +1,44 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { NOTEBOOK_LM_ICON } from './icon.js';
+import { notebookLmTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'notebook-lm',
+    displayName: 'NotebookLM',
+    shortDescription: 'Create and manage NotebookLM Enterprise notebooks, sources, and audio overviews.',
+    category: 'AI & Machine Learning',
+    icon: NOTEBOOK_LM_ICON,
+    auth: {
+        type: 'oauth2',
+        tokenField: 'notebookLmToken',
+        provider: {
+            slug: 'notebook-lm',
+            env: { clientId: 'NOTEBOOK_LM_CLIENT_ID', clientSecret: 'NOTEBOOK_LM_CLIENT_SECRET' },
+            authorizeUrl: 'https://accounts.google.com/o/oauth2/v2/auth',
+            tokenUrl: 'https://oauth2.googleapis.com/token',
+            scopes: [
+                'https://www.googleapis.com/auth/cloud-platform',
+                'https://www.googleapis.com/auth/discoveryengine.readwrite',
+            ],
+            exchangeStyle: 'form',
+            extraAuthParams: { access_type: 'offline', prompt: 'consent' },
+            connectDescription: 'Connect NotebookLM Enterprise to create notebooks, add text and file sources, and generate audio overviews. Requires a licensed Google Cloud project with the NotebookLM Enterprise API enabled and discoveryengine IAM permissions.',
+            callbackPath: '/api/auth/notebook-lm/callback',
+            stateCookie: 'notebook_lm_oauth_state',
+        },
+    },
+    allowedHosts: [
+        'discoveryengine.googleapis.com',
+        'us-discoveryengine.googleapis.com',
+        'eu-discoveryengine.googleapis.com',
+        'global-discoveryengine.googleapis.com',
+    ],
+    tools: notebookLmTools.map((entry) => defineTool({
+        name: entry.name,
+        description: entry.description,
+        tool: entry.tool,
+        requiredAuth: entry.requiredAuth,
+        scope: entry.scope,
+    })),
+    meta: { since: '0.0.10' },
+});
+//# sourceMappingURL=manifest.js.map

package/dist/toolkits/notebook-lm/tools/add-text-sources.d.ts

@@ -0,0 +1,36 @@
+export declare const addTextSources: import("ai").Tool<{
+    sources: {
+        content: string;
+        sourceName: string;
+    }[];
+    notebookLmToken: string;
+    notebookId: string;
+    location?: string | undefined;
+    endpointLocation?: string | undefined;
+    projectNumber?: string | undefined;
+}, {
+    error: string;
+    details?: undefined;
+    sources?: undefined;
+    raw?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: unknown;
+    sources?: undefined;
+    raw?: undefined;
+    message?: undefined;
+} | {
+    sources: any;
+    raw: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    sources?: undefined;
+    raw?: undefined;
+}>;
+//# sourceMappingURL=add-text-sources.d.ts.map

package/dist/toolkits/notebook-lm/tools/add-text-sources.js

@@ -0,0 +1,51 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { buildNotebookName, getEndpoint, parseResponseError } from './utils.js';
+export const addTextSources = tool({
+    description: 'Add one or more named raw-text sources to a NotebookLM Enterprise notebook via batchCreate.',
+    inputSchema: z.object({
+        notebookLmToken: z.string().describe('NotebookLM OAuth access token.'),
+        notebookId: z.string().min(1).describe('Notebook UUID or full resource name to receive the sources.'),
+        sources: z.array(z.object({
+            sourceName: z.string().min(1).describe('Display name for this source.'),
+            content: z.string().min(1).describe('Raw text used to ground the notebook.'),
+        })).min(1).describe('Text sources to add; each item contains a display name and raw text content.'),
+        location: z.string().optional().describe('Location override, defaults to global.'),
+        endpointLocation: z.string().optional().describe('Endpoint multi-region, defaults to global.'),
+        projectNumber: z.string().optional().describe('Project number, defaults to -.'),
+    }),
+    execute: async ({ notebookLmToken, notebookId, sources, location, endpointLocation, projectNumber }) => {
+        if (!notebookLmToken)
+            return { error: 'NotebookLM token is required. Connect NotebookLM first.' };
+        try {
+            const endpoint = getEndpoint(endpointLocation || location);
+            const name = buildNotebookName(notebookId, projectNumber, location);
+            const url = `${endpoint}/${name}/sources:batchCreate`;
+            const userContents = sources.map((s) => ({ textContent: { sourceName: s.sourceName, content: s.content } }));
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: { Authorization: `Bearer ${notebookLmToken}`, 'Content-Type': 'application/json' },
+                body: JSON.stringify({ userContents }),
+            });
+            if (!response.ok) {
+                const err = await parseResponseError(response);
+                return { error: 'Failed to add text sources', details: err.details };
+            }
+            const data = await response.json();
+            const normalized = (data.sources || []).map((src) => ({
+                sourceId: src.sourceId?.id || src.sourceId || src.name?.split('/').pop(),
+                name: src.name,
+                title: src.title || src.displayName,
+                metadata: src.metadata,
+                ingestionStatus: src.settings?.status || src.ingestionStatus,
+                failureReason: src.failureReason,
+            }));
+            return { sources: normalized, raw: data };
+        }
+        catch (error) {
+            return { error: 'Error adding text sources', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=add-text-sources.js.map

package/dist/toolkits/notebook-lm/tools/create-audio-overview.d.ts

@@ -0,0 +1,47 @@
+export declare const createAudioOverview: import("ai").Tool<{
+    notebookLmToken: string;
+    notebookId: string;
+    sourceIds: string[];
+    location?: string | undefined;
+    languageCode?: string | undefined;
+    endpointLocation?: string | undefined;
+    projectNumber?: string | undefined;
+    episodeFocus?: string | undefined;
+}, {
+    error: string;
+    details?: undefined;
+    audioOverviewId?: undefined;
+    name?: undefined;
+    status?: undefined;
+    generationOptions?: undefined;
+    raw?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: unknown;
+    audioOverviewId?: undefined;
+    name?: undefined;
+    status?: undefined;
+    generationOptions?: undefined;
+    raw?: undefined;
+    message?: undefined;
+} | {
+    audioOverviewId: any;
+    name: any;
+    status: any;
+    generationOptions: any;
+    raw: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    audioOverviewId?: undefined;
+    name?: undefined;
+    status?: undefined;
+    generationOptions?: undefined;
+    raw?: undefined;
+}>;
+//# sourceMappingURL=create-audio-overview.d.ts.map

package/dist/toolkits/notebook-lm/tools/create-audio-overview.js

@@ -0,0 +1,55 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { buildNotebookName, getEndpoint, parseResponseError } from './utils.js';
+export const createAudioOverview = tool({
+    description: 'Start asynchronous generation of a NotebookLM Enterprise audio overview from selected notebook sources. Each notebook can have only one audio overview; if one already exists, Google returns it and ignores new generation options. Returns before audio is ready; no status polling method exists in public API.',
+    inputSchema: z.object({
+        notebookLmToken: z.string().describe('NotebookLM OAuth access token.'),
+        notebookId: z.string().min(1).describe('Notebook UUID or full resource name whose sources will be used to generate the audio overview.'),
+        sourceIds: z.array(z.string().min(1)).min(1).describe('One or more source UUIDs or full names from the notebook to include. If omitted by API, all sources are used.'),
+        episodeFocus: z.string().optional().describe('Optional instructions describing the topics or angle the generated episode should emphasize.'),
+        languageCode: z.string().optional().describe('Optional BCP-47 language code, e.g. en-US, fr-FR.'),
+        location: z.string().optional().describe('Location override, defaults to global.'),
+        endpointLocation: z.string().optional().describe('Endpoint multi-region, defaults to global.'),
+        projectNumber: z.string().optional().describe('Project number, defaults to -.'),
+    }),
+    execute: async ({ notebookLmToken, notebookId, sourceIds, episodeFocus, languageCode, location, endpointLocation, projectNumber }) => {
+        if (!notebookLmToken)
+            return { error: 'NotebookLM token is required. Connect NotebookLM first.' };
+        try {
+            const endpoint = getEndpoint(endpointLocation || location);
+            const name = buildNotebookName(notebookId, projectNumber, location);
+            const url = `${endpoint}/${name}/audioOverviews`;
+            const body = {};
+            if (sourceIds && sourceIds.length)
+                body.sourceIds = sourceIds.map((id) => ({ id }));
+            if (episodeFocus)
+                body.episodeFocus = episodeFocus;
+            if (languageCode)
+                body.languageCode = languageCode;
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: { Authorization: `Bearer ${notebookLmToken}`, 'Content-Type': 'application/json' },
+                body: JSON.stringify(body),
+            });
+            if (!response.ok) {
+                const err = await parseResponseError(response);
+                return { error: 'Failed to create audio overview', details: err.details };
+            }
+            const data = await response.json();
+            const overview = data.audioOverview || data;
+            return {
+                audioOverviewId: overview.audioOverviewId || overview.name?.split('/').pop(),
+                name: overview.name,
+                status: overview.status,
+                generationOptions: overview.generationOptions || body,
+                raw: data,
+            };
+        }
+        catch (error) {
+            return { error: 'Error creating audio overview', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=create-audio-overview.js.map

package/dist/toolkits/notebook-lm/tools/create-notebook.d.ts

@@ -0,0 +1,52 @@
+export declare const createNotebook: import("ai").Tool<{
+    title: string;
+    notebookLmToken: string;
+    location?: string | undefined;
+    endpointLocation?: string | undefined;
+    projectNumber?: string | undefined;
+}, {
+    error: string;
+    details?: undefined;
+    notebookId?: undefined;
+    name?: undefined;
+    title?: undefined;
+    emoji?: undefined;
+    metadata?: undefined;
+    sources?: undefined;
+    raw?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: unknown;
+    notebookId?: undefined;
+    name?: undefined;
+    title?: undefined;
+    emoji?: undefined;
+    metadata?: undefined;
+    sources?: undefined;
+    raw?: undefined;
+    message?: undefined;
+} | {
+    notebookId: any;
+    name: any;
+    title: any;
+    emoji: any;
+    metadata: any;
+    sources: any;
+    raw: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    notebookId?: undefined;
+    name?: undefined;
+    title?: undefined;
+    emoji?: undefined;
+    metadata?: undefined;
+    sources?: undefined;
+    raw?: undefined;
+}>;
+//# sourceMappingURL=create-notebook.d.ts.map

package/dist/toolkits/notebook-lm/tools/create-notebook.js

@@ -0,0 +1,49 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { buildParent, getEndpoint, parseResponseError } from './utils.js';
+export const createNotebook = tool({
+    description: 'Create a NotebookLM Enterprise notebook in a licensed Google Cloud project and location. Creates a new notebook with the given title.',
+    inputSchema: z.object({
+        notebookLmToken: z.string().describe('NotebookLM OAuth access token (Bearer). Inject via manifest tokenField notebookLmToken.'),
+        title: z.string().min(1).describe('Human-readable notebook title.'),
+        location: z.string().optional().describe('Geographic location, e.g. global, us, eu. Defaults to global.'),
+        endpointLocation: z.string().optional().describe('Multi-region for endpoint: us, eu, global. Defaults to global.'),
+        projectNumber: z.string().optional().describe('GCP project number. Defaults to - (token project). Use projects/PROJECT_NUMBER/locations/LOCATION parent.'),
+    }),
+    execute: async ({ notebookLmToken, title, location, endpointLocation, projectNumber }) => {
+        if (!notebookLmToken)
+            return { error: 'NotebookLM token is required. Connect NotebookLM first.' };
+        try {
+            const endpoint = getEndpoint(endpointLocation || location);
+            const parent = buildParent(projectNumber, location);
+            const url = `${endpoint}/${parent}/notebooks`;
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${notebookLmToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ title }),
+            });
+            if (!response.ok) {
+                const err = await parseResponseError(response);
+                return { error: 'Failed to create notebook', details: err.details };
+            }
+            const data = await response.json();
+            return {
+                notebookId: data.notebookId || data.name?.split('/').pop(),
+                name: data.name,
+                title: data.title,
+                emoji: data.emoji,
+                metadata: data.metadata,
+                sources: data.sources,
+                raw: data,
+            };
+        }
+        catch (error) {
+            return { error: 'Error creating notebook', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=create-notebook.js.map

package/dist/toolkits/notebook-lm/tools/delete-audio-overview.d.ts

@@ -0,0 +1,33 @@
+export declare const deleteAudioOverview: import("ai").Tool<{
+    notebookLmToken: string;
+    notebookId: string;
+    audioOverviewId: string;
+    location?: string | undefined;
+    endpointLocation?: string | undefined;
+    projectNumber?: string | undefined;
+}, {
+    error: string;
+    details?: undefined;
+    deletedAudioOverviewId?: undefined;
+    raw?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: unknown;
+    deletedAudioOverviewId?: undefined;
+    raw?: undefined;
+    message?: undefined;
+} | {
+    deletedAudioOverviewId: string;
+    raw: unknown;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    deletedAudioOverviewId?: undefined;
+    raw?: undefined;
+}>;
+//# sourceMappingURL=delete-audio-overview.d.ts.map