@divyacon/piece-google-docs 0.0.0-stage → 0.1.1

package/src/lib/actions/create-document-based-on-template.action.ts

@@ -0,0 +1,110 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { googleDocsAuth, createGoogleClient } from '../auth';
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { docs as googleDocs } from '@googleapis/docs';
+import { editTemplateActionOutputSchema } from '../output-schemas';
+
+const PLACEHOLDER_FORMATS: Record<string, string> = {
+  'curly_braces': '{{KEY}}',
+  'square_brackets': '[[KEY]]',
+  'single_curly': '{KEY}',
+  'single_square': '[KEY]',
+  '{{KEY}}': '{{KEY}}',
+  '[[KEY]]': '[[KEY]]',
+  '{KEY}': '{KEY}',
+  '[KEY]': '[KEY]',
+};
+
+export const createDocumentBasedOnTemplate = createAction({
+  auth: googleDocsAuth,
+  name: 'create_document_based_on_template',
+  description:
+    'Edit a template file and replace the values with the ones provided',
+  audience: 'both',
+  aiMetadata: {
+    description:
+      'Fills a Google Docs template in place by find-and-replacing placeholder tokens (e.g. [[KEY]] or {{KEY}}) with supplied key/value pairs and swapping placeholder images by object ID. Use when an agent has an existing template document and wants to merge data into it rather than build a doc from scratch. Requires the target document ID and the matching placeholder format; idempotent since re-running with the same values replaces no remaining placeholders and leaves the document unchanged.',
+    idempotent: true,
+  },
+  displayName: 'Edit template file',
+  props: {
+    template: Property.ShortText({
+      displayName: 'Destination File',
+      description: 'The ID of the file to replace the values',
+      required: true,
+    }),
+    values: Property.Object({
+      displayName: 'Variables',
+      description: 'Dont include the placeholder format "[[]]" or "{{}}", only the key name and its value',
+      required: true,
+    }),
+    images: Property.Object({
+      displayName: 'Images',
+      description:
+        'Key: Image ID (get it manually from the Read File Action), Value: Image URL',
+      required: true,
+    }),
+    placeholder_format: Property.StaticDropdown({
+      displayName: 'Placeholder Format',
+      description: 'Choose the format of placeholders in your template',
+      required: true,
+      defaultValue: 'square_brackets',
+      options: {
+          disabled: false,
+          options: [
+              { label: 'Curly Braces {{}}', value: 'curly_braces' },
+              { label: 'Square Brackets [[]]', value: 'square_brackets' },
+              { label: 'Single Curly Braces {}', value: 'single_curly' },
+              { label: 'Single Square Brackets []', value: 'single_square' }
+          ],
+        },
+  }),
+  },
+  outputSchema: editTemplateActionOutputSchema,
+  async run(context) {
+    const documentId: string = context.propsValue.template;
+    const values = context.propsValue.values;
+    const placeholderType = context.propsValue.placeholder_format;
+    const placeholder_format = PLACEHOLDER_FORMATS[placeholderType] || '[[KEY]]';
+
+    const authClient = await createGoogleClient(context.auth);
+    const docs = googleDocs('v1');
+
+    const requests = [];
+
+    for (const key in values) {
+      const value = values[key];
+      const new_key = placeholder_format.replace('KEY', key);
+
+      requests.push({
+        replaceAllText: {
+          containsText: {
+            text: new_key,
+            matchCase: true,
+          },
+          replaceText: String(value),
+        },
+      });
+    }
+
+    for (const key in context.propsValue.images) {
+      const value = context.propsValue.images[key];
+      requests.push({
+        replaceImage: {
+          imageObjectId: key,
+          uri: String(value),
+        },
+      });
+    }
+
+    const res = await docs.documents.batchUpdate({
+      auth: authClient,
+      documentId,
+      requestBody: {
+        requests: requests,
+      },
+    });
+
+    return res;
+  },
+});

package/src/lib/actions/create-document-from-markdown.action.ts

@@ -0,0 +1,63 @@
+import { googleDocsAuth, createGoogleClient } from '../auth';
+import { docsCommon } from '../common';
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { docs as googleDocs } from '@googleapis/docs';
+import { createDocumentFromMarkdownActionOutputSchema } from '../output-schemas';
+
+export const createDocumentFromMarkdown = createAction({
+  auth: googleDocsAuth,
+  name: 'create_document_from_markdown',
+  displayName: 'Create Document from Markdown',
+  description: 'Create a Google Docs document from Markdown content',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Creates a new Google Docs document and populates it from Markdown text, converting headings (#, ##, ###), bullet lists (-, *, +), and paragraphs into native Google Docs formatting. Use when an agent has Markdown content (the format LLMs produce natively) and wants a formatted document in one call. Inline styling such as bold/italic is inserted as plain text. Not idempotent: each call creates a new document.',
+    idempotent: false,
+  },
+  outputSchema: createDocumentFromMarkdownActionOutputSchema,
+  props: {
+    title: Property.ShortText({
+      displayName: 'Title',
+      description: 'The title (and file name) of the new document.',
+      required: true,
+    }),
+    markdown: Property.LongText({
+      displayName: 'Markdown Content',
+      description: 'Markdown text. Supports headings (#/##/###), bullet lists (-/*/+), and paragraphs.',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const { title, markdown } = context.propsValue;
+    const authClient = await createGoogleClient(context.auth);
+    const docs = googleDocs({ version: 'v1', auth: authClient });
+
+    let documentId: string;
+    try {
+      const created = await docs.documents.create({ requestBody: { title } });
+      if (!created.data.documentId) {
+        throw new Error('Google Docs did not return a document ID for the new document.');
+      }
+      documentId = created.data.documentId;
+    } catch (error) {
+      throw new Error(docsCommon.formatError(error, 'create'));
+    }
+
+    const requests = docsCommon.markdownToBatchRequests(markdown);
+    if (requests.length > 0) {
+      try {
+        await docs.documents.batchUpdate({ documentId, requestBody: { requests } });
+      } catch (error) {
+        throw new Error(docsCommon.formatError(error, 'populate the new'));
+      }
+    }
+
+    return {
+      success: true,
+      documentId,
+      title,
+      url: `https://docs.google.com/document/d/${documentId}/edit`,
+    };
+  },
+});

package/src/lib/actions/create-document.ts

@@ -0,0 +1,36 @@
+import { createAction } from '@agnocon/pieces-framework';
+import { docsCommon } from '../common';
+import { googleDocsAuth, getAccessToken } from '../auth';
+import { createDocumentActionOutputSchema } from '../output-schemas';
+
+export const createDocument = createAction({
+  auth: googleDocsAuth,
+  name: 'create_document',
+  description: 'Create a document on Google Docs',
+  audience: 'human',
+  aiMetadata: {
+    description:
+      'Creates a brand-new Google Docs document with the given title and writes the provided text into it. Use when an agent needs to generate a fresh document from content it has produced; to add to an existing document use Append Text instead. Not idempotent: every call creates a separate new document.',
+    idempotent: false,
+  },
+  displayName: 'Create Document',
+  props: {
+    title: docsCommon.title,
+    body: docsCommon.body,
+  },
+  outputSchema: createDocumentActionOutputSchema,
+  async run(context) {
+    const accessToken = await getAccessToken(context.auth);
+    const document = await docsCommon.createDocument(
+      context.propsValue.title,
+      accessToken
+    );
+    const response = await docsCommon.writeToDocument(
+      document.documentId,
+      context.propsValue.body,
+      accessToken
+    );
+
+    return response;
+  },
+});

package/src/lib/actions/create-footer.action.ts

@@ -0,0 +1,59 @@
+import { googleDocsAuth, createGoogleClient } from '../auth';
+import { docsCommon } from '../common';
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { docs as googleDocs, docs_v1 } from '@googleapis/docs';
+import { createFooterActionOutputSchema } from '../output-schemas';
+
+export const createFooter = createAction({
+  auth: googleDocsAuth,
+  name: 'create_footer',
+  displayName: 'Create Footer',
+  description: 'Create a footer section in a Google Docs document',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Creates a footer section in a Google Docs document and returns the new footerId. Use this when you need to add a footer to a document before inserting footer text — the footerId returned here is required by any subsequent Insert Text call targeting the footer segment. Each call creates a new footer; not idempotent.',
+    idempotent: false,
+  },
+  outputSchema: createFooterActionOutputSchema,
+  props: {
+    documentId: Property.ShortText({
+      displayName: 'Document ID',
+      description: 'The ID of the document to add a footer to (from the document URL or Search Documents).',
+      required: true,
+    }),
+    type: Property.StaticDropdown({
+      displayName: 'Footer Type',
+      description: 'The type of footer to create. DEFAULT is the standard document footer.',
+      required: false,
+      defaultValue: 'DEFAULT',
+      options: {
+        options: [
+          { label: 'Default', value: 'DEFAULT' },
+        ],
+      },
+    }),
+  },
+  async run(context) {
+    const { documentId, type } = context.propsValue;
+    const authClient = await createGoogleClient(context.auth);
+    const docs = googleDocs({ version: 'v1', auth: authClient });
+
+    const request: docs_v1.Schema$Request = {
+      createFooter: {
+        type: (type ?? 'DEFAULT') as docs_v1.Schema$CreateFooterRequest['type'],
+      },
+    };
+
+    try {
+      const response = await docs.documents.batchUpdate({
+        documentId,
+        requestBody: { requests: [request] },
+      });
+      const footerId = response.data.replies?.[0]?.createFooter?.footerId ?? null;
+      return { success: true, documentId, footerId };
+    } catch (error) {
+      throw new Error(docsCommon.formatError(error, 'create the footer in'));
+    }
+  },
+});

package/src/lib/actions/create-footnote.action.ts

@@ -0,0 +1,53 @@
+import { googleDocsAuth, createGoogleClient } from '../auth';
+import { docsCommon } from '../common';
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { docs as googleDocs, docs_v1 } from '@googleapis/docs';
+import { createFootnoteActionOutputSchema } from '../output-schemas';
+
+export const createFootnote = createAction({
+  auth: googleDocsAuth,
+  name: 'create_footnote',
+  displayName: 'Create Footnote',
+  description: 'Insert a footnote at a character index in a Google Docs document',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Inserts a footnote at a specific character index inside an existing paragraph in a Google Docs document, or at the end of the body segment if no index is provided. Returns the new footnoteId, which can then be used to insert text into the footnote segment via Insert Text. The index must fall inside an existing paragraph — obtain a valid index from Get Document End Index or Read Document (cannot be guessed). Not idempotent.',
+    idempotent: false,
+  },
+  outputSchema: createFootnoteActionOutputSchema,
+  props: {
+    documentId: Property.ShortText({
+      displayName: 'Document ID',
+      description: 'The ID of the document to insert a footnote into (from the document URL or Search Documents).',
+      required: true,
+    }),
+    index: Property.Number({
+      displayName: 'Index',
+      description:
+        'Character index inside an existing paragraph where the footnote anchor is inserted. Leave empty to append at the end of the body segment. Obtain a valid index from Get Document End Index or Read Document — cannot be guessed.',
+      required: false,
+    }),
+  },
+  async run(context) {
+    const { documentId, index } = context.propsValue;
+    const authClient = await createGoogleClient(context.auth);
+    const docs = googleDocs({ version: 'v1', auth: authClient });
+
+    const request: docs_v1.Schema$Request =
+      index === undefined || index === null
+        ? { createFootnote: { endOfSegmentLocation: {} } }
+        : { createFootnote: { location: { index } } };
+
+    try {
+      const response = await docs.documents.batchUpdate({
+        documentId,
+        requestBody: { requests: [request] },
+      });
+      const footnoteId = response.data.replies?.[0]?.createFootnote?.footnoteId ?? null;
+      return { success: true, documentId, footnoteId };
+    } catch (error) {
+      throw new Error(docsCommon.formatError(error, 'create the footnote in'));
+    }
+  },
+});

package/src/lib/actions/create-header.action.ts

@@ -0,0 +1,59 @@
+import { googleDocsAuth, createGoogleClient } from '../auth';
+import { docsCommon } from '../common';
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { docs as googleDocs, docs_v1 } from '@googleapis/docs';
+import { createHeaderActionOutputSchema } from '../output-schemas';
+
+export const createHeader = createAction({
+  auth: googleDocsAuth,
+  name: 'create_header',
+  displayName: 'Create Header',
+  description: 'Create a header section in a Google Docs document',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Creates a header section in a Google Docs document and returns the new headerId. Use this when you need to add a header to a document before inserting header text — the headerId returned here is required by any subsequent Insert Text call targeting the header segment. Each call creates a new header; not idempotent.',
+    idempotent: false,
+  },
+  outputSchema: createHeaderActionOutputSchema,
+  props: {
+    documentId: Property.ShortText({
+      displayName: 'Document ID',
+      description: 'The ID of the document to add a header to (from the document URL or Search Documents).',
+      required: true,
+    }),
+    type: Property.StaticDropdown({
+      displayName: 'Header Type',
+      description: 'The type of header to create. DEFAULT is the standard document header.',
+      required: false,
+      defaultValue: 'DEFAULT',
+      options: {
+        options: [
+          { label: 'Default', value: 'DEFAULT' },
+        ],
+      },
+    }),
+  },
+  async run(context) {
+    const { documentId, type } = context.propsValue;
+    const authClient = await createGoogleClient(context.auth);
+    const docs = googleDocs({ version: 'v1', auth: authClient });
+
+    const request: docs_v1.Schema$Request = {
+      createHeader: {
+        type: (type ?? 'DEFAULT') as docs_v1.Schema$CreateHeaderRequest['type'],
+      },
+    };
+
+    try {
+      const response = await docs.documents.batchUpdate({
+        documentId,
+        requestBody: { requests: [request] },
+      });
+      const headerId = response.data.replies?.[0]?.createHeader?.headerId ?? null;
+      return { success: true, documentId, headerId };
+    } catch (error) {
+      throw new Error(docsCommon.formatError(error, 'create the header in'));
+    }
+  },
+});

package/src/lib/actions/create-named-range.action.ts

@@ -0,0 +1,70 @@
+import { googleDocsAuth, createGoogleClient } from '../auth';
+import { docsCommon } from '../common';
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { docs as googleDocs, docs_v1 } from '@googleapis/docs';
+import { createNamedRangeActionOutputSchema } from '../output-schemas';
+
+export const createNamedRange = createAction({
+  auth: googleDocsAuth,
+  name: 'create_named_range',
+  displayName: 'Create Named Range',
+  description: 'Create a named range over a character range in a Google Docs document',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Creates a named range over a specified character range in a Google Docs document body and returns the new namedRangeId. Named ranges let you bookmark a region for later operations (e.g. deletion, styling) by ID or by name. The startIndex and endIndex must be valid character positions inside the document body — obtain them from Get Document End Index or Read Document (cannot be guessed). Not idempotent.',
+    idempotent: false,
+  },
+  outputSchema: createNamedRangeActionOutputSchema,
+  props: {
+    documentId: Property.ShortText({
+      displayName: 'Document ID',
+      description: 'The ID of the document to add a named range to (from the document URL or Search Documents).',
+      required: true,
+    }),
+    name: Property.ShortText({
+      displayName: 'Range Name',
+      description: 'A human-readable name for the range. Multiple named ranges in the same document can share the same name.',
+      required: true,
+    }),
+    startIndex: Property.Number({
+      displayName: 'Start Index',
+      description:
+        'Inclusive start character index of the range. Obtain from Get Document End Index or Read Document — cannot be guessed.',
+      required: true,
+    }),
+    endIndex: Property.Number({
+      displayName: 'End Index',
+      description:
+        'Exclusive end character index of the range. Must be greater than Start Index. Obtain from Get Document End Index or Read Document — cannot be guessed.',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const { documentId, name, startIndex, endIndex } = context.propsValue;
+    if (endIndex <= startIndex) {
+      throw new Error('End Index must be greater than Start Index.');
+    }
+
+    const authClient = await createGoogleClient(context.auth);
+    const docs = googleDocs({ version: 'v1', auth: authClient });
+
+    const request: docs_v1.Schema$Request = {
+      createNamedRange: {
+        name,
+        range: { startIndex, endIndex },
+      },
+    };
+
+    try {
+      const response = await docs.documents.batchUpdate({
+        documentId,
+        requestBody: { requests: [request] },
+      });
+      const namedRangeId = response.data.replies?.[0]?.createNamedRange?.namedRangeId ?? null;
+      return { success: true, documentId, name, namedRangeId };
+    } catch (error) {
+      throw new Error(docsCommon.formatError(error, 'create the named range in'));
+    }
+  },
+});

package/src/lib/actions/create-paragraph-bullets.action.ts

@@ -0,0 +1,95 @@
+import { googleDocsAuth, createGoogleClient } from '../auth';
+import { docsCommon } from '../common';
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { docs as googleDocs, docs_v1 } from '@googleapis/docs';
+import { createParagraphBulletsActionOutputSchema } from '../output-schemas';
+
+export const createParagraphBullets = createAction({
+  auth: googleDocsAuth,
+  name: 'create_paragraph_bullets',
+  displayName: 'Create Paragraph Bullets',
+  description: 'Apply a bullet list preset to paragraphs in a character range in a Google Docs document',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Applies a bullet list style (e.g. BULLET_DISC_CIRCLE_SQUARE) to all paragraphs within a character range in a Google Docs document. Use this to convert existing paragraphs into a bulleted or numbered list. The startIndex and endIndex must span the paragraphs to bullet — obtain valid indices from Get Document End Index or Read Document (cannot be guessed). Not idempotent (re-running with a different preset changes the glyph style).',
+    idempotent: false,
+  },
+  outputSchema: createParagraphBulletsActionOutputSchema,
+  props: {
+    documentId: Property.ShortText({
+      displayName: 'Document ID',
+      description: 'The ID of the document to apply bullets to (from the document URL or Search Documents).',
+      required: true,
+    }),
+    startIndex: Property.Number({
+      displayName: 'Start Index',
+      description:
+        'Inclusive start character index of the range of paragraphs to bullet. Obtain from Get Document End Index or Read Document — cannot be guessed.',
+      required: true,
+    }),
+    endIndex: Property.Number({
+      displayName: 'End Index',
+      description:
+        'Exclusive end character index of the range of paragraphs to bullet. Must be greater than Start Index. Obtain from Get Document End Index or Read Document — cannot be guessed.',
+      required: true,
+    }),
+    bulletPreset: Property.StaticDropdown({
+      displayName: 'Bullet Preset',
+      description: 'The bullet list glyph preset to apply to the paragraphs.',
+      required: false,
+      defaultValue: 'BULLET_DISC_CIRCLE_SQUARE',
+      options: {
+        options: [
+          { label: 'Disc / Circle / Square (default)', value: 'BULLET_DISC_CIRCLE_SQUARE' },
+          { label: 'Diamond / Circle / Square', value: 'BULLET_DIAMONDX_ARROW3D_SQUARE' },
+          { label: 'Checkbox', value: 'BULLET_CHECKBOX' },
+          { label: 'Arrow / Diamond / Disc', value: 'BULLET_ARROW_DIAMOND_DISC' },
+          { label: 'Star / Circle / Square', value: 'BULLET_STAR_CIRCLE_SQUARE' },
+          { label: 'Arrow3D / Circle / Square', value: 'BULLET_ARROW3D_CIRCLE_SQUARE' },
+          { label: 'Left Triangle / Diamond / Disc', value: 'BULLET_LEFTTRIANGLE_DIAMOND_DISC' },
+          { label: 'Diamond / Circle / Disc', value: 'BULLET_DIAMONDX_HOLLOWDIAMOND_SQUARE' },
+          { label: 'Diamond / Diamond / Square', value: 'BULLET_DIAMOND_DISC_CIRCLE' },
+          { label: 'Numbered: Decimal / Alpha Lower / Roman Lower', value: 'NUMBERED_DECIMAL_ALPHA_ROMAN' },
+          { label: 'Numbered: Decimal / Alpha Lower / Roman Lower (parenthesis)', value: 'NUMBERED_DECIMAL_ALPHA_ROMAN_PARENS' },
+          { label: 'Numbered: Decimal nested', value: 'NUMBERED_DECIMAL_NESTED' },
+          { label: 'Numbered: Upper Alpha / Alpha Lower / Roman Lower', value: 'NUMBERED_UPPERALPHA_ALPHA_ROMAN' },
+          { label: 'Numbered: Upper Roman / Roman Lower / Alpha Lower', value: 'NUMBERED_UPPERROMAN_UPPERALPHA_DECIMAL' },
+          { label: 'Numbered: Zero Decimal / Alpha Lower / Roman Lower', value: 'NUMBERED_ZERODECIMAL_ALPHA_ROMAN' },
+        ],
+      },
+    }),
+  },
+  async run(context) {
+    const { documentId, startIndex, endIndex, bulletPreset } = context.propsValue;
+    if (endIndex <= startIndex) {
+      throw new Error('End Index must be greater than Start Index.');
+    }
+
+    const authClient = await createGoogleClient(context.auth);
+    const docs = googleDocs({ version: 'v1', auth: authClient });
+
+    const request: docs_v1.Schema$Request = {
+      createParagraphBullets: {
+        range: { startIndex, endIndex },
+        bulletPreset: (bulletPreset ?? 'BULLET_DISC_CIRCLE_SQUARE') as docs_v1.Schema$CreateParagraphBulletsRequest['bulletPreset'],
+      },
+    };
+
+    try {
+      await docs.documents.batchUpdate({
+        documentId,
+        requestBody: { requests: [request] },
+      });
+      return {
+        success: true,
+        documentId,
+        startIndex,
+        endIndex,
+        bulletPreset: bulletPreset ?? 'BULLET_DISC_CIRCLE_SQUARE',
+      };
+    } catch (error) {
+      throw new Error(docsCommon.formatError(error, 'create paragraph bullets in'));
+    }
+  },
+});

package/src/lib/actions/create-text-document.action.ts

@@ -0,0 +1,35 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { docsCommon } from '../common';
+import { googleDocsAuth, getAccessToken } from '../auth';
+import { appendTextActionOutputSchema } from '../output-schemas';
+
+export const createTextDocument = createAction({
+  auth: googleDocsAuth,
+  name: 'create_text_document',
+  displayName: 'Create Text Document',
+  description: 'Create a new Google Docs document with a title and plain text',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Creates a new Google Docs document with the given title and writes the provided plain text into it, returning the new document metadata (including its ID). Use when an agent has plain text to put in a fresh document; for Markdown-formatted content use Create Document from Markdown instead. Not idempotent: each call creates a separate new document.',
+    idempotent: false,
+  },
+  outputSchema: appendTextActionOutputSchema,
+  props: {
+    title: Property.ShortText({
+      displayName: 'Title',
+      description: 'The title (and file name) of the new document.',
+      required: true,
+    }),
+    body: Property.LongText({
+      displayName: 'Content',
+      description: 'The plain text to write into the new document.',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const accessToken = await getAccessToken(context.auth);
+    const document = await docsCommon.createDocument(context.propsValue.title, accessToken);
+    return await docsCommon.writeToDocument(document.documentId, context.propsValue.body, accessToken);
+  },
+});

package/src/lib/actions/delete-content-range.action.ts

@@ -0,0 +1,59 @@
+import { googleDocsAuth, createGoogleClient } from '../auth';
+import { docsCommon } from '../common';
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { docs as googleDocs, docs_v1 } from '@googleapis/docs';
+import { deleteContentRangeActionOutputSchema } from '../output-schemas';
+
+export const deleteContentRange = createAction({
+  auth: googleDocsAuth,
+  name: 'delete_content_range',
+  displayName: 'Delete Content Range',
+  description: 'Delete a range of content from a Google Docs document',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Deletes all content between a start and end character index in a Google Docs document body. Obtain valid indices from Get Document End Index / Read Document first — indices cannot be guessed. Note that every Google Docs segment ends in a newline that cannot be deleted, so the end index must not exceed the body end index minus one. Destructive and not idempotent.',
+    idempotent: false,
+  },
+  outputSchema: deleteContentRangeActionOutputSchema,
+  props: {
+    documentId: Property.ShortText({
+      displayName: 'Document ID',
+      description: 'The ID of the document to edit.',
+      required: true,
+    }),
+    startIndex: Property.Number({
+      displayName: 'Start Index',
+      description: 'Inclusive start character index. Obtain from Get Document End Index / Read Document.',
+      required: true,
+    }),
+    endIndex: Property.Number({
+      displayName: 'End Index',
+      description: 'Exclusive end character index. Must be greater than Start Index and not exceed the body end index.',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const { documentId, startIndex, endIndex } = context.propsValue;
+    if (endIndex <= startIndex) {
+      throw new Error('End Index must be greater than Start Index.');
+    }
+
+    const authClient = await createGoogleClient(context.auth);
+    const docs = googleDocs({ version: 'v1', auth: authClient });
+
+    const request: docs_v1.Schema$Request = {
+      deleteContentRange: { range: { startIndex, endIndex } },
+    };
+
+    try {
+      await docs.documents.batchUpdate({
+        documentId,
+        requestBody: { requests: [request] },
+      });
+      return { success: true, documentId, deletedFrom: startIndex, deletedTo: endIndex };
+    } catch (error) {
+      throw new Error(docsCommon.formatError(error, 'delete content from'));
+    }
+  },
+});