@commandable/integration-data 0.4.0 → 0.4.1

package/integrations/google-docs/handlers/insert_page_break_after_first_match.js

@@ -0,0 +1,49 @@
+async (input) => {
+  const { documentId, findText, position } = input
+  const marker = `__CMD_MARK_${Date.now()}__`
+  const replaceRes = await integration.fetch(`/documents/${encodeURIComponent(documentId)}:batchUpdate`, {
+    method: 'POST',
+    body: { requests: [{ replaceAllText: { containsText: { text: findText, matchCase: false }, replaceText: marker } }] },
+  })
+  await replaceRes.json()
+
+  const getRes = await integration.fetch(`/documents/${encodeURIComponent(documentId)}`)
+  const doc = await getRes.json()
+  let baseIndex = -1
+  for (const el of (doc?.body?.content || [])) {
+    const p = el.paragraph
+    if (!p)
+      continue
+    for (const e of (p.elements || [])) {
+      const t = e?.textRun?.content
+      if (!t)
+        continue
+      const idx = t.indexOf(marker)
+      if (idx >= 0) {
+        const elStart = e.startIndex || 1
+        const startIndex = elStart + idx
+        const endIndex = startIndex + marker.length
+        baseIndex = position === 'before' ? startIndex : endIndex
+        break
+      }
+    }
+    if (baseIndex >= 0)
+      break
+  }
+  if (baseIndex < 0) {
+    const confirm = await integration.fetch(`/documents/${encodeURIComponent(documentId)}`)
+    const got = await confirm.json()
+    return { documentId: got?.documentId || documentId, applied: false, replies: [] }
+  }
+
+  const requests = []
+  requests.push({ insertPageBreak: { location: { index: baseIndex } } })
+  requests.push({ replaceAllText: { containsText: { text: marker, matchCase: true }, replaceText: findText } })
+  const res = await integration.fetch(`/documents/${encodeURIComponent(documentId)}:batchUpdate`, { method: 'POST', body: { requests } })
+  const out = await res.json()
+  if (out?.documentId || Array.isArray(out?.replies))
+    return { ...out, applied: true }
+  const confirm = await integration.fetch(`/documents/${encodeURIComponent(documentId)}`)
+  const got = await confirm.json()
+  return { documentId: got?.documentId || documentId, applied: true, replies: Array.isArray(out?.replies) ? out.replies : [] }
+}

package/integrations/google-docs/handlers/insert_table_after_first_match.js

@@ -0,0 +1,49 @@
+async (input) => {
+  const { documentId, findText, rows, columns, position } = input
+  const marker = `__CMD_MARK_${Date.now()}__`
+  const replaceRes = await integration.fetch(`/documents/${encodeURIComponent(documentId)}:batchUpdate`, {
+    method: 'POST',
+    body: { requests: [{ replaceAllText: { containsText: { text: findText, matchCase: false }, replaceText: marker } }] },
+  })
+  await replaceRes.json()
+
+  const getRes = await integration.fetch(`/documents/${encodeURIComponent(documentId)}`)
+  const doc = await getRes.json()
+  let baseIndex = -1
+  for (const el of (doc?.body?.content || [])) {
+    const p = el.paragraph
+    if (!p)
+      continue
+    for (const e of (p.elements || [])) {
+      const t = e?.textRun?.content
+      if (!t)
+        continue
+      const idx = t.indexOf(marker)
+      if (idx >= 0) {
+        const elStart = e.startIndex || 1
+        const startIndex = elStart + idx
+        const endIndex = startIndex + marker.length
+        baseIndex = position === 'before' ? startIndex : endIndex
+        break
+      }
+    }
+    if (baseIndex >= 0)
+      break
+  }
+  if (baseIndex < 0) {
+    const confirm = await integration.fetch(`/documents/${encodeURIComponent(documentId)}`)
+    const got = await confirm.json()
+    return { documentId: got?.documentId || documentId, applied: false, replies: [] }
+  }
+
+  const requests = []
+  requests.push({ insertTable: { location: { index: baseIndex }, rows, columns } })
+  requests.push({ replaceAllText: { containsText: { text: marker, matchCase: true }, replaceText: findText } })
+  const res = await integration.fetch(`/documents/${encodeURIComponent(documentId)}:batchUpdate`, { method: 'POST', body: { requests } })
+  const out = await res.json()
+  if (out?.documentId || Array.isArray(out?.replies))
+    return { ...out, applied: true }
+  const confirm = await integration.fetch(`/documents/${encodeURIComponent(documentId)}`)
+  const got = await confirm.json()
+  return { documentId: got?.documentId || documentId, applied: true, replies: Array.isArray(out?.replies) ? out.replies : [] }
+}

package/integrations/google-docs/handlers/insert_text_after_first_match.js

@@ -0,0 +1,51 @@
+async (input) => {
+  const { documentId, findText, insertText, position } = input
+  const marker = `__CMD_MARK_${Date.now()}__`
+  // Replace first occurrence by marker only (simulate single by replacing all, then revert later to first span)
+  const replaceRes = await integration.fetch(`/documents/${encodeURIComponent(documentId)}:batchUpdate`, {
+    method: 'POST',
+    body: { requests: [{ replaceAllText: { containsText: { text: findText, matchCase: false }, replaceText: marker } }] },
+  })
+  await replaceRes.json()
+
+  const getRes = await integration.fetch(`/documents/${encodeURIComponent(documentId)}`)
+  const doc = await getRes.json()
+  let insertIndex = -1
+  for (const el of (doc?.body?.content || [])) {
+    const p = el.paragraph
+    if (!p)
+      continue
+    for (const e of (p.elements || [])) {
+      const t = e?.textRun?.content
+      if (!t)
+        continue
+      const idx = t.indexOf(marker)
+      if (idx >= 0) {
+        const elStart = e.startIndex || 1
+        const startIndex = elStart + idx
+        const endIndex = startIndex + marker.length
+        insertIndex = position === 'before' ? startIndex : endIndex
+        break
+      }
+    }
+    if (insertIndex >= 0)
+      break
+  }
+  if (insertIndex < 0) {
+    const confirm = await integration.fetch(`/documents/${encodeURIComponent(documentId)}`)
+    const got = await confirm.json()
+    return { documentId: got?.documentId || documentId, applied: false, replies: [] }
+  }
+
+  const requests = []
+  requests.push({ insertText: { text: insertText, location: { index: insertIndex } } })
+  // restore marker back to original findText everywhere
+  requests.push({ replaceAllText: { containsText: { text: marker, matchCase: true }, replaceText: findText } })
+  const res = await integration.fetch(`/documents/${encodeURIComponent(documentId)}:batchUpdate`, { method: 'POST', body: { requests } })
+  const out = await res.json()
+  if (out?.documentId || Array.isArray(out?.replies))
+    return { ...out, applied: true }
+  const confirm = await integration.fetch(`/documents/${encodeURIComponent(documentId)}`)
+  const got = await confirm.json()
+  return { documentId: got?.documentId || documentId, applied: true, replies: Array.isArray(out?.replies) ? out.replies : [] }
+}

package/integrations/google-docs/handlers/read_document.js

@@ -0,0 +1,189 @@
+async (input) => {
+  const MONO_FONTS = new Set([
+    'Courier',
+    'Courier New',
+    'Consolas',
+    'Menlo',
+    'Monaco',
+    'Roboto Mono',
+    'Source Code Pro',
+  ])
+
+  const HEADING_MAP = {
+    TITLE: '#',
+    SUBTITLE: '##',
+    HEADING_1: '#',
+    HEADING_2: '##',
+    HEADING_3: '###',
+    HEADING_4: '####',
+    HEADING_5: '#####',
+    HEADING_6: '######',
+  }
+
+  const BULLET_GLYPHS = new Set([
+    'BULLET_DISC_CIRCLE_SQUARE',
+    'BULLET_DIAMONDX_ARROW3D_SQUARE',
+    'BULLET_CHECKBOX',
+    'BULLET_ARROW_DIAMOND_DISC',
+    'BULLET_STAR_CIRCLE_SQUARE',
+  ])
+
+  const LIST_NUMBER_GLYPHS = new Set([
+    'DECIMAL',
+    'ZERO_DECIMAL',
+    'UPPER_ALPHA',
+    'ALPHA',
+    'UPPER_ROMAN',
+    'ROMAN',
+  ])
+
+  const trimEndWhitespace = (value) => (value || '').replace(/[ \t]+$/g, '')
+
+  const escapeCell = (value) =>
+    String(value ?? '')
+      .replace(/\|/g, '\\|')
+      .replace(/\r?\n/g, '<br>')
+
+  const extractPlainTextFromParagraph = (paragraph) => {
+    let text = ''
+    for (const element of paragraph?.elements || []) {
+      text += element?.textRun?.content || ''
+    }
+    return trimEndWhitespace(text)
+  }
+
+  const applyTextStyle = (text, textStyle = {}) => {
+    const raw = (text || '').replace(/\n/g, '')
+    if (!raw) return ''
+
+    let out = raw
+    if (textStyle.link?.url) out = `[${out}](${textStyle.link.url})`
+
+    const fontFamily = textStyle.weightedFontFamily?.fontFamily || ''
+    const isMono = textStyle.smallCaps || MONO_FONTS.has(fontFamily)
+
+    if (isMono) out = `\`${out}\``
+    if (textStyle.bold) out = `**${out}**`
+    if (textStyle.italic) out = `*${out}*`
+    if (textStyle.strikethrough) out = `~~${out}~~`
+
+    return out
+  }
+
+  const paragraphToMarkdown = (paragraph, docLists) => {
+    const styleType = paragraph?.paragraphStyle?.namedStyleType
+    const headingPrefix = HEADING_MAP[styleType] || ''
+
+    let line = ''
+    for (const element of paragraph?.elements || []) {
+      line += applyTextStyle(element?.textRun?.content || '', element?.textRun?.textStyle || {})
+    }
+    line = trimEndWhitespace(line)
+
+    if (!line) return ''
+
+    const bullet = paragraph?.bullet
+    if (bullet) {
+      const nestingLevel = bullet.nestingLevel || 0
+      const listMeta = docLists?.[bullet.listId]
+      const nesting = listMeta?.listProperties?.nestingLevels?.[nestingLevel]
+      const glyphType = nesting?.glyphType || ''
+      const isNumbered = LIST_NUMBER_GLYPHS.has(glyphType) && !BULLET_GLYPHS.has(glyphType)
+      const indent = '  '.repeat(Math.max(0, nestingLevel))
+      return `${indent}${isNumbered ? '1.' : '-'} ${line}`
+    }
+
+    if (headingPrefix) return `${headingPrefix} ${line}`
+    return line
+  }
+
+  const tableToMarkdown = (table, docLists) => {
+    const rows = table?.tableRows || []
+    if (!rows.length) return ''
+
+    const normalized = rows.map((row) =>
+      (row?.tableCells || []).map((cell) => {
+        const parts = []
+        for (const c of cell?.content || []) {
+          if (c?.paragraph) {
+            const p = paragraphToMarkdown(c.paragraph, docLists)
+            if (p) parts.push(p)
+          }
+        }
+        return escapeCell(parts.join('<br>'))
+      }),
+    )
+
+    const width = Math.max(...normalized.map((r) => r.length), 1)
+    const padded = normalized.map((r) => [...r, ...Array(width - r.length).fill('')])
+    const header = padded[0] || Array(width).fill('')
+    const separator = Array(width).fill('---')
+    const body = padded.slice(1)
+
+    const lines = [
+      `| ${header.join(' | ')} |`,
+      `| ${separator.join(' | ')} |`,
+      ...body.map((r) => `| ${r.join(' | ')} |`),
+    ]
+    return lines.join('\n')
+  }
+
+  const docToPlainText = (docBodyContent) => {
+    const lines = []
+    for (const item of docBodyContent || []) {
+      if (item?.paragraph) {
+        const text = extractPlainTextFromParagraph(item.paragraph)
+        if (text) lines.push(text)
+      } else if (item?.table) {
+        for (const row of item.table.tableRows || []) {
+          const cells = (row.tableCells || []).map((cell) => {
+            const pieces = []
+            for (const contentItem of cell.content || []) {
+              if (contentItem?.paragraph) {
+                const text = extractPlainTextFromParagraph(contentItem.paragraph)
+                if (text) pieces.push(text)
+              }
+            }
+            return pieces.join(' ')
+          })
+          if (cells.some(Boolean)) lines.push(cells.join(' | '))
+        }
+      }
+    }
+    return lines.join('\n\n').trim()
+  }
+
+  const { documentId } = input
+  const res = await integration.fetch(`/documents/${encodeURIComponent(documentId)}`)
+  const doc = await res.json()
+
+  const content = doc?.body?.content || []
+  const lists = doc?.lists || {}
+
+  const blocks = []
+  for (const item of content) {
+    if (item?.paragraph) {
+      const line = paragraphToMarkdown(item.paragraph, lists)
+      if (line) blocks.push(line)
+    } else if (item?.table) {
+      const table = tableToMarkdown(item.table, lists)
+      if (table) blocks.push(table)
+    }
+  }
+
+  const markdown = blocks.join('\n\n').trim()
+  if (markdown) {
+    return {
+      documentId: doc?.documentId || documentId,
+      title: doc?.title || '',
+      markdown,
+    }
+  }
+
+  // Escape hatch: return plain text if markdown conversion produced nothing.
+  return {
+    documentId: doc?.documentId || documentId,
+    title: doc?.title || '',
+    markdown: docToPlainText(content),
+  }
+}

package/integrations/google-docs/handlers/replace_all_text.js

@@ -0,0 +1,8 @@
+async (input) => {
+  const { documentId, findText, replaceText, matchCase } = input
+  const res = await integration.fetch(`/documents/${encodeURIComponent(documentId)}:batchUpdate`, {
+    method: 'POST',
+    body: { requests: [{ replaceAllText: { containsText: { text: findText, matchCase: Boolean(matchCase) }, replaceText } }] },
+  })
+  return await res.json()
+}

package/integrations/google-docs/handlers/style_first_match.js

@@ -0,0 +1,42 @@
+async (input) => {
+  const { documentId, findText, textStyle, fields } = input
+  // 1) Find first match via replaceAllText with unique marker
+  const marker = `__CMD_MARK_${Date.now()}__`
+  const replaceRes = await integration.fetch(`/documents/${encodeURIComponent(documentId)}:batchUpdate`, {
+    method: 'POST',
+    body: { requests: [{ replaceAllText: { containsText: { text: findText, matchCase: false }, replaceText: marker } }] },
+  })
+  const rep = await replaceRes.json()
+  // 2) Get doc, locate marker, compute indices
+  const getRes = await integration.fetch(`/documents/${encodeURIComponent(documentId)}`)
+  const doc = await getRes.json()
+  let startIndex = -1
+  let endIndex = -1
+  for (const el of (doc?.body?.content || [])) {
+    const p = el.paragraph
+    if (!p)
+      continue
+    for (const e of (p.elements || [])) {
+      const t = e?.textRun?.content
+      if (!t)
+        continue
+      const idx = t.indexOf(marker)
+      if (idx >= 0) {
+        const elStart = e.startIndex || 1
+        startIndex = elStart + idx
+        endIndex = startIndex + marker.length
+        break
+      }
+    }
+    if (startIndex >= 0)
+      break
+  }
+  if (startIndex < 0)
+    return rep
+  // 3) Apply style and restore original text
+  const requests = []
+  requests.push({ updateTextStyle: { range: { startIndex, endIndex }, textStyle, fields: fields || Object.keys(textStyle || {}).join(',') } })
+  requests.push({ replaceAllText: { containsText: { text: marker, matchCase: true }, replaceText: findText } })
+  const res = await integration.fetch(`/documents/${encodeURIComponent(documentId)}:batchUpdate`, { method: 'POST', body: { requests } })
+  return await res.json()
+}

package/integrations/google-docs/handlers/update_document_style.js

@@ -0,0 +1,8 @@
+async (input) => {
+  const { documentId, documentStyle, fields } = input
+  const res = await integration.fetch(`/documents/${encodeURIComponent(documentId)}:batchUpdate`, {
+    method: 'POST',
+    body: { requests: [{ updateDocumentStyle: { documentStyle, fields: fields || Object.keys(documentStyle || {}).join(',') } }] },
+  })
+  return await res.json()
+}

package/integrations/google-docs/handlers/update_paragraph_style_for_first_match.js

@@ -0,0 +1,48 @@
+async (input) => {
+  const { documentId, findText, paragraphStyle, fields } = input
+  const marker = `__CMD_MARK_${Date.now()}__`
+  const replaceRes = await integration.fetch(`/documents/${encodeURIComponent(documentId)}:batchUpdate`, {
+    method: 'POST',
+    body: { requests: [{ replaceAllText: { containsText: { text: findText, matchCase: false }, replaceText: marker } }] },
+  })
+  await replaceRes.json()
+
+  const getRes = await integration.fetch(`/documents/${encodeURIComponent(documentId)}`)
+  const doc = await getRes.json()
+  let paragraphStart = -1
+  let paragraphEnd = -1
+  for (const el of (doc?.body?.content || [])) {
+    const p = el.paragraph
+    if (!p)
+      continue
+    for (const e of (p.elements || [])) {
+      const t = e?.textRun?.content
+      if (!t)
+        continue
+      const idx = t.indexOf(marker)
+      if (idx >= 0) {
+        paragraphStart = p.elements?.[0]?.startIndex || e.startIndex || 1
+        paragraphEnd = (p.elements?.[p.elements.length - 1]?.endIndex) || (e.endIndex) || (paragraphStart + marker.length)
+        break
+      }
+    }
+    if (paragraphStart >= 0)
+      break
+  }
+  if (paragraphStart < 0) {
+    const confirm = await integration.fetch(`/documents/${encodeURIComponent(documentId)}`)
+    const got = await confirm.json()
+    return { documentId: got?.documentId || documentId, applied: false, replies: [] }
+  }
+
+  const requests = []
+  requests.push({ updateParagraphStyle: { range: { startIndex: paragraphStart, endIndex: paragraphEnd }, paragraphStyle, fields: fields || Object.keys(paragraphStyle || {}).join(',') } })
+  requests.push({ replaceAllText: { containsText: { text: marker, matchCase: true }, replaceText: findText } })
+  const res = await integration.fetch(`/documents/${encodeURIComponent(documentId)}:batchUpdate`, { method: 'POST', body: { requests } })
+  const out = await res.json()
+  if (out?.documentId || Array.isArray(out?.replies))
+    return { ...out, applied: true }
+  const confirm = await integration.fetch(`/documents/${encodeURIComponent(documentId)}`)
+  const got = await confirm.json()
+  return { documentId: got?.documentId || documentId, applied: true, replies: Array.isArray(out?.replies) ? out.replies : [] }
+}

package/integrations/google-docs/manifest.json

@@ -0,0 +1,44 @@
+{
+  "name": "google-docs",
+  "version": "0.1.0",
+  "baseUrl": "https://docs.googleapis.com/v1",
+  "tools": [
+    {
+      "name": "read_document",
+      "description": "Read a Google Doc and return its content as clean Markdown. Preserves headings, bold, italic, strikethrough, links, code spans, ordered/unordered lists with nesting, and tables. This is the standard way to read document content. For editing, use append_text, replace_all_text, first-match tools, or batch_update.",
+      "inputSchema": "schemas/read_document.json",
+      "handler": "handlers/read_document.js",
+      "scope": "read"
+    },
+    {
+      "name": "create_document",
+      "description": "Create a new empty Google Doc with the given title. Returns the created document's metadata including its documentId, which is needed for all subsequent operations on the document.",
+      "inputSchema": "schemas/create_document.json",
+      "handler": "handlers/create_document.js",
+      "scope": "write"
+    },
+    {
+      "name": "batch_update",
+      "description": "Send a documents.batchUpdate request to modify a document with one or more structured requests. Supports insertText, deleteContentRange, replaceAllText, createNamedRange, updateTextStyle, updateParagraphStyle, insertTable, insertInlineImage, and more. For common operations, prefer the higher-level tools: append_text, replace_all_text, and the first-match tools. Use batch_update for operations not covered by those helpers.",
+      "inputSchema": "schemas/batch_update.json",
+      "handler": "handlers/batch_update.js",
+      "scope": "write"
+    },
+    { "name": "append_text", "description": "Append plain text to the end of a Google Doc. Automatically fetches the document to find the correct end index and inserts the text there. Use this for adding content to the end of a document without needing to know the document structure.", "inputSchema": "schemas/append_text.json", "handler": "handlers/append_text.js", "scope": "write" },
+    { "name": "replace_all_text", "description": "Replace all occurrences of a text string in a Google Doc with new text. Case-sensitive by default. More efficient than the first-match tools when you need to replace every occurrence. Returns the number of occurrences replaced.", "inputSchema": "schemas/replace_all_text.json", "handler": "handlers/replace_all_text.js", "scope": "write" },
+    { "name": "style_first_match", "description": "Find the first occurrence of text in a document and apply a TextStyle to it (bold, italic, fontSize, foregroundColor, etc.). Uses a marker-based approach: replaces the text with a unique marker, locates the marker's position, applies the style, then restores the original text. Returns {applied: true/false}.", "inputSchema": "schemas/style_first_match.json", "handler": "handlers/style_first_match.js", "scope": "write" },
+    { "name": "insert_text_after_first_match", "description": "Find the first occurrence of text and insert new text immediately before or after it. Useful for inserting content at a specific anchor point in the document without knowing exact character indices. Returns {applied: true/false}.", "inputSchema": "schemas/insert_text_after_first_match.json", "handler": "handlers/insert_text_after_first_match.js", "scope": "write" },
+    { "name": "insert_table_after_first_match", "description": "Find the first occurrence of text and insert a table with the specified number of rows and columns nearby. Returns {applied: true/false}.", "inputSchema": "schemas/insert_table_after_first_match.json", "handler": "handlers/insert_table_after_first_match.js", "scope": "write" },
+    { "name": "insert_page_break_after_first_match", "description": "Find the first occurrence of text and insert a page break nearby. Useful for structuring long documents. Returns {applied: true/false}.", "inputSchema": "schemas/insert_page_break_after_first_match.json", "handler": "handlers/insert_page_break_after_first_match.js", "scope": "write" },
+    { "name": "insert_inline_image_after_first_match", "description": "Find the first occurrence of text and insert an inline image nearby, referenced by URL. Returns {applied: true/false}.", "inputSchema": "schemas/insert_inline_image_after_first_match.json", "handler": "handlers/insert_inline_image_after_first_match.js", "scope": "write" },
+    { "name": "delete_first_match", "description": "Find the first occurrence of text in the document and delete it. Only the first match is removed. Use replace_all_text with an empty string to remove all occurrences. Returns {applied: true/false}.", "inputSchema": "schemas/delete_first_match.json", "handler": "handlers/delete_first_match.js", "scope": "write" },
+    { "name": "update_paragraph_style_for_first_match", "description": "Find the first occurrence of text and update the paragraph style for the paragraph containing it. Use to apply heading levels (HEADING_1 through HEADING_6), NORMAL_TEXT, or adjust spacing, alignment, and indentation. Returns {applied: true/false}.", "inputSchema": "schemas/update_paragraph_style_for_first_match.json", "handler": "handlers/update_paragraph_style_for_first_match.js", "scope": "write" },
+    {
+      "name": "update_document_style",
+      "description": "Update document-level style properties such as page size (pageSize.width, pageSize.height in pt), margins (marginTop, marginBottom, marginLeft, marginRight in pt), and page orientation. Does not affect individual paragraph or text styles.",
+      "inputSchema": "schemas/update_document_style.json",
+      "handler": "handlers/update_document_style.js",
+      "scope": "write"
+    }
+  ]
+}

package/integrations/google-docs/prompt.md

@@ -0,0 +1,49 @@
+## Reading documents
+
+Use `read_document` as the standard read tool. It returns clean markdown with headings, lists, links, inline code, and tables preserved as much as possible.
+
+`read_document` includes an escape hatch: if markdown conversion fails to produce useful content, it falls back to plain-text extraction so you still get readable output.
+
+For editing workflows, read with `read_document` first, then use `append_text`, `replace_all_text`, first-match tools, or `batch_update`.
+
+## Editing documents
+
+The Google Docs API uses character-index-based editing, but the high-level tools handle index resolution automatically:
+
+- **`append_text`** — adds text to the end of the document (no index needed)
+- **`replace_all_text`** — replaces every occurrence of a string (no index needed)
+- **First-match tools** (`style_first_match`, `insert_text_after_first_match`, etc.) — locate text by content, then act on the first match
+
+Only use `batch_update` with raw index operations when the higher-level tools don't cover your use case.
+
+## First-match pattern
+
+The `*_first_match` tools use a 3-step marker approach:
+1. Replace all occurrences of `findText` with a unique marker (`__CMD_MARK_...`)
+2. Fetch the document to find the marker's exact character indices
+3. Apply the operation at those indices, then restore the original text
+
+This means each first-match operation makes 3 API calls. They return `{applied: true}` on success or `{applied: false}` if the text was not found.
+
+## Common batch_update operations
+
+```json
+{ "requests": [
+  { "insertText": { "text": "Hello", "location": { "index": 1 } } },
+  { "deleteContentRange": { "range": { "startIndex": 5, "endIndex": 10 } } },
+  { "updateTextStyle": {
+      "range": { "startIndex": 1, "endIndex": 6 },
+      "textStyle": { "bold": true },
+      "fields": "bold"
+  }},
+  { "updateParagraphStyle": {
+      "range": { "startIndex": 1, "endIndex": 2 },
+      "paragraphStyle": { "namedStyleType": "HEADING_1" },
+      "fields": "namedStyleType"
+  }}
+]}
+```
+
+## Document IDs
+
+The documentId appears in the Google Docs URL: `https://docs.google.com/document/d/{documentId}/edit`

package/integrations/google-docs/schemas/append_text.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "documentId": { "type": "string" },
+    "text": { "type": "string" }
+  },
+  "required": ["documentId", "text"],
+  "additionalProperties": false
+}

package/integrations/google-docs/schemas/apply_text_style.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "documentId": { "type": "string" },
+    "startIndex": { "type": "number", "minimum": 1 },
+    "endIndex": { "type": "number", "minimum": 1 },
+    "textStyle": { "type": "object", "description": "Docs API TextStyle object, e.g., { bold: true }" },
+    "fields": { "type": "string", "description": "Fields mask for update, e.g., 'bold,italic'" }
+  },
+  "required": ["documentId", "startIndex", "endIndex", "textStyle"],
+  "additionalProperties": false
+}

package/integrations/google-docs/schemas/batch_update.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "documentId": { "type": "string", "description": "The document ID of the Google Doc." },
+    "requests": {
+      "type": "array",
+      "description": "Array of Docs API requests (insertText, updateParagraphStyle, replaceAllText, etc).",
+      "items": { "type": "object" }
+    },
+    "writeControl": { "type": "object", "description": "Write control to ensure idempotency (requiredRevisionId, targetRevisionId)." },
+    "includeTabStops": { "type": "boolean", "description": "Include tab stops in responses where applicable." }
+  },
+  "required": ["documentId", "requests"],
+  "additionalProperties": true
+}

package/integrations/google-docs/schemas/create_document.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "title": { "type": "string", "description": "Title for the new document." }
+  },
+  "additionalProperties": true
+}

package/integrations/google-docs/schemas/delete_content_range.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "documentId": { "type": "string" },
+    "startIndex": { "type": "number", "minimum": 1 },
+    "endIndex": { "type": "number", "minimum": 1 }
+  },
+  "required": ["documentId", "startIndex", "endIndex"],
+  "additionalProperties": false
+}

package/integrations/google-docs/schemas/delete_first_match.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "documentId": { "type": "string" },
+    "findText": { "type": "string" }
+  },
+  "required": ["documentId", "findText"],
+  "additionalProperties": false
+}

package/integrations/google-docs/schemas/insert_inline_image.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "documentId": { "type": "string" },
+    "index": { "type": "number", "minimum": 1 },
+    "uri": { "type": "string", "description": "Publicly accessible image URL" },
+    "altText": { "type": "string" }
+  },
+  "required": ["documentId", "index", "uri"],
+  "additionalProperties": false
+}

package/integrations/google-docs/schemas/insert_inline_image_after_first_match.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "documentId": { "type": "string" },
+    "findText": { "type": "string" },
+    "uri": { "type": "string" },
+    "position": { "type": "string", "enum": ["after", "before"], "default": "after" }
+  },
+  "required": ["documentId", "findText", "uri"],
+  "additionalProperties": false
+}