@nuxtagentic/integrations 0.0.0-stage → 0.1.1

package/runtime/server/utils/google-mcp.ts

@@ -0,0 +1,296 @@
+import type { Connect, ConnectActor, McpCallResult } from '@cloudconfig/core/connect'
+import { GOOGLE_MCP_SERVERS } from '../../shared/google-mcp'
+
+type Input = Record<string, unknown>
+
+export interface GoogleMcpAction {
+  server: string
+  tool: string
+  arguments: Input
+  response: 'events' | 'draft' | 'files' | 'file'
+}
+
+export function isGoogleMcpEnabled(env: Record<string, unknown> | undefined): boolean {
+  return String(env?.NUXT_GOOGLE_MCP_ENABLED ?? process.env.NUXT_GOOGLE_MCP_ENABLED) === 'true'
+}
+
+/** The compatibility actions that write through Google's MCP servers ask for approval. */
+export function isGoogleMcpWriteAction(provider: string, action: string): boolean {
+  return (
+    (provider === 'gcal' && action === 'create_events') ||
+    (provider === 'gmail' && action === 'draft_replies') ||
+    (provider === 'gdrive' && action === 'create_files')
+  )
+}
+
+function isObject(value: unknown): value is Input {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+}
+
+function readObject(value: unknown): Input {
+  return isObject(value) ? value : {}
+}
+
+function hasOnlyFields(input: Input, fields: readonly string[]): boolean {
+  return Object.keys(input).every((field) => fields.includes(field))
+}
+
+/**
+ * Preserve the existing action inputs. Requests Google's tools cannot faithfully
+ * represent stay on REST; an MCP failure never causes a second operation via REST.
+ */
+export function planGoogleMcpAction({
+  provider,
+  action,
+  input,
+}: {
+  provider: string
+  action: string
+  input: Input
+}): GoogleMcpAction | null {
+  switch (`${provider}_${action}`) {
+    case 'gcal_read_events':
+      return planCalendarRead(input)
+    case 'gcal_create_events':
+      return planCalendarCreation(input)
+    case 'gmail_draft_replies':
+      return planGmailDraft(input)
+    case 'gdrive_read_files':
+      return planDriveRead(input)
+    case 'gdrive_create_files':
+      return planDriveCreation(input)
+    default:
+      return null
+  }
+}
+
+function planCalendarRead(input: Input): GoogleMcpAction | null {
+  const query = readObject(input.query)
+
+  const fields = {
+    timeMin: 'startTime',
+    timeMax: 'endTime',
+    timeZone: 'timeZone',
+    q: 'fullText',
+    maxResults: 'pageSize',
+    pageToken: 'pageToken',
+  }
+  if (!hasOnlyFields(query, Object.keys(fields))) return null
+  const toolArguments: Input = {
+    calendarId: input.calendarId ?? 'primary',
+    pageSize: 250,
+    eventType: [
+      'DEFAULT',
+      'OUT_OF_OFFICE',
+      'FOCUS_TIME',
+      'FROM_GMAIL',
+      'WORKING_LOCATION',
+      'BIRTHDAY',
+    ],
+  }
+  for (const [source, target] of Object.entries(fields)) {
+    if (query[source] !== undefined) toolArguments[target] = query[source]
+  }
+  const pageSize = Number(toolArguments.pageSize)
+  if (!Number.isInteger(pageSize) || pageSize < 1 || pageSize > 250) return null
+  toolArguments.pageSize = pageSize
+  return {
+    server: GOOGLE_MCP_SERVERS.gcal,
+    tool: 'list_events',
+    arguments: toolArguments,
+    response: 'events',
+  }
+}
+
+function planCalendarCreation(input: Input): GoogleMcpAction | null {
+  const query = readObject(input.query)
+  const body = readObject(input.body)
+
+  // Complex event options and differing start/end time zones keep their REST semantics.
+  if (
+    !hasOnlyFields(query, []) ||
+    !hasOnlyFields(body, ['summary', 'start', 'end', 'description', 'location'])
+  ) {
+    return null
+  }
+  const start = readObject(body.start)
+  const end = readObject(body.end)
+  if (
+    !hasOnlyFields(start, ['dateTime', 'timeZone']) ||
+    !hasOnlyFields(end, ['dateTime', 'timeZone'])
+  ) {
+    return null
+  }
+  if (
+    typeof body.summary !== 'string' ||
+    typeof start.dateTime !== 'string' ||
+    typeof end.dateTime !== 'string'
+  ) {
+    return null
+  }
+  if (start.timeZone !== end.timeZone) return null
+  return {
+    server: GOOGLE_MCP_SERVERS.gcal,
+    tool: 'create_event',
+    arguments: {
+      summary: body.summary,
+      calendarId: input.calendarId ?? 'primary',
+      startTime: start.dateTime,
+      endTime: end.dateTime,
+      // Calendar's REST insert sends no notifications unless explicitly requested.
+      notificationLevel: 'NONE',
+      ...(start.timeZone ? { timeZone: start.timeZone } : {}),
+      ...(body.description !== undefined ? { description: body.description } : {}),
+      ...(body.location !== undefined ? { location: body.location } : {}),
+    },
+    response: 'events',
+  }
+}
+
+function planGmailDraft(input: Input): GoogleMcpAction | null {
+  const query = readObject(input.query)
+  const body = readObject(input.body)
+
+  if (!hasOnlyFields(query, []) || !hasOnlyFields(body, ['to', 'subject', 'text'])) return null
+  if (
+    typeof body.to !== 'string' ||
+    typeof body.subject !== 'string' ||
+    typeof body.text !== 'string'
+  )
+    return null
+  const recipients = body.to.split(',').map((recipient) => recipient.trim())
+  if (recipients.some((recipient) => !/^[^\s<>@,]+@[^\s<>@,]+\.[^\s<>@,]+$/.test(recipient)))
+    return null
+  if (/[\r\n]/.test(body.to) || /[\r\n]/.test(body.subject)) {
+    throw new Error('Email recipient and subject must not contain line breaks.')
+  }
+  return {
+    server: GOOGLE_MCP_SERVERS.gmail,
+    tool: 'create_draft',
+    arguments: { to: recipients, subject: body.subject, body: body.text },
+    response: 'draft',
+  }
+}
+
+function planDriveRead(input: Input): GoogleMcpAction | null {
+  const query = readObject(input.query)
+
+  if (!hasOnlyFields(query, ['q', 'pageSize', 'pageToken'])) return null
+  let searchQuery = ''
+  if (query.q !== undefined) {
+    if (typeof query.q !== 'string') return null
+    // Drive MCP calls the file name "title" and supports a smaller search grammar.
+    const match = query.q.match(
+      /^(name|fullText|mimeType|modifiedTime|createdTime|viewedByMeTime)\s*(contains|!=|<=|>=|=|<|>)\s*('(?:\\.|[^'\\])*')$/,
+    )
+    if (!match) return null
+    const [, field, operator, value] = match
+    searchQuery = `${field === 'name' ? 'title' : field} ${operator} ${value}`
+  }
+  const pageSize = Number(query.pageSize ?? 100)
+  if (!Number.isInteger(pageSize) || pageSize < 1 || pageSize > 1000) return null
+  return {
+    server: GOOGLE_MCP_SERVERS.gdrive,
+    tool: 'search_files',
+    arguments: {
+      query: searchQuery,
+      pageSize,
+      ...(query.pageToken !== undefined ? { pageToken: query.pageToken } : {}),
+    },
+    response: 'files',
+  }
+}
+
+function planDriveCreation(input: Input): GoogleMcpAction | null {
+  const query = readObject(input.query)
+  const body = readObject(input.body)
+
+  if (!hasOnlyFields(query, []) || !hasOnlyFields(body, ['name', 'mimeType', 'parents']))
+    return null
+  if (typeof body.name !== 'string' || typeof body.mimeType !== 'string') return null
+  const supportedTypes = ['document', 'spreadsheet', 'presentation', 'folder'].map(
+    (type) => `application/vnd.google-apps.${type}`,
+  )
+  if (!supportedTypes.includes(body.mimeType)) return null
+  const parents = body.parents ?? []
+  if (
+    !Array.isArray(parents) ||
+    parents.length > 1 ||
+    parents.some((parent) => typeof parent !== 'string')
+  )
+    return null
+  return {
+    server: GOOGLE_MCP_SERVERS.gdrive,
+    tool: 'create_file',
+    arguments: {
+      title: body.name,
+      contentMimeType: body.mimeType,
+      ...(parents[0] ? { parentId: parents[0] } : {}),
+    },
+    response: 'file',
+  }
+}
+function readMcpResponse(result: McpCallResult): Input {
+  if (result.isError) {
+    throw new Error(
+      `Google MCP rejected the action: ${JSON.stringify(result.content).slice(0, 500)}`,
+    )
+  }
+  if (isObject(result.structuredContent)) return result.structuredContent
+  for (const content of result.content) {
+    if (!isObject(content) || content.type !== 'text' || typeof content.text !== 'string') continue
+    try {
+      const value: unknown = JSON.parse(content.text)
+      if (isObject(value)) return value
+    } catch {
+      // Other text blocks may be explanatory; require a structured result below.
+    }
+  }
+  throw new Error('Google MCP returned no structured action result.')
+}
+
+function normalizeDriveFile(value: unknown): Input {
+  if (!isObject(value)) throw new Error('Google MCP returned an invalid Drive file.')
+  const { title, fileSize, viewUrl, parentId, ...file } = value
+  return {
+    ...file,
+    ...(title !== undefined ? { name: title } : {}),
+    ...(fileSize !== undefined ? { size: fileSize } : {}),
+    ...(viewUrl !== undefined ? { webViewLink: viewUrl } : {}),
+    ...(parentId !== undefined ? { parents: [parentId] } : {}),
+  }
+}
+
+/** Execute through Connect so the same account ownership and token refresh rules apply. */
+export async function executeGoogleMcpAction({
+  connect,
+  actor,
+  connectionId,
+  request,
+  signal,
+}: {
+  connect: Pick<Connect, 'mcp'>
+  actor: ConnectActor
+  connectionId: number
+  request: GoogleMcpAction
+  signal?: AbortSignal
+}): Promise<Input> {
+  const session = connect.mcp(actor, connectionId, {
+    server: request.server,
+    ...(signal ? { signal } : {}),
+  })
+  const response = readMcpResponse(await session.callTool(request.tool, request.arguments, 60_000))
+  if (request.response === 'files') {
+    if (!Array.isArray(response.files))
+      throw new Error('Google MCP returned an invalid Drive file list.')
+    return { ...response, files: response.files.map(normalizeDriveFile) }
+  }
+  if (request.response === 'file') return normalizeDriveFile(response)
+  if (request.response === 'events' && request.tool === 'list_events') {
+    if (!Array.isArray(response.events))
+      throw new Error('Google MCP returned an invalid calendar event list.')
+    const { events, ...calendar } = response
+    return { ...calendar, items: events }
+  }
+  return response
+}