runline 0.11.6 → 0.13.0

package/dist/plugins/googleContacts/src/index.js

@@ -22,7 +22,9 @@
  * the bare ID and normalize. The response always includes a
  * convenience `contactId` field stripped from `resourceName`.
  */
+import * as t from "typebox";
 import { googleAccessToken } from "../../_shared/googleAuth.js";
+import { Id, NonEmptyString, PositiveInteger, stringEnum, } from "../../_shared/googleSchemas.js";
 // ─── Fields ─────────────────────────────────────────────────────
 /**
  * Every `personFields` value supported by People API get/list calls.
@@ -279,6 +281,128 @@ function attachContactId(obj) {
 }
 // ─── Plugin ──────────────────────────────────────────────────────
 const SCOPES = ["https://www.googleapis.com/auth/contacts"];
+const strictObject = (properties, options = {}) => t.Object(properties, { ...options, additionalProperties: false });
+const optionalString = (description) => t.Optional(t.String(description ? { description } : {}));
+const optionalBoolean = t.Optional(t.Boolean());
+const personField = stringEnum([...ALL_PERSON_FIELDS, "*"]);
+const personFields = t.Optional(t.Union([t.String(), t.Array(personField, { minItems: 1 })]));
+const structuredDate = strictObject({
+    year: t.Optional(t.Integer({ minimum: 0 })),
+    month: t.Integer({ minimum: 1, maximum: 12 }),
+    day: t.Integer({ minimum: 1, maximum: 31 }),
+});
+const contactDate = t.Union([NonEmptyString, structuredDate]);
+const typedValue = strictObject({
+    value: NonEmptyString,
+    type: optionalString(),
+});
+const relation = strictObject({
+    person: NonEmptyString,
+    type: optionalString(),
+});
+const contactEvent = strictObject({
+    date: contactDate,
+    type: optionalString(),
+});
+const userDefined = strictObject({ key: NonEmptyString, value: t.String() });
+// These two People API resources are intentionally extensible. Known fields are
+// typed, while additional provider fields remain available for forward
+// compatibility and parity with the plugin's existing passthrough behavior.
+const address = t.Object({
+    formattedValue: optionalString(),
+    type: optionalString(),
+    poBox: optionalString(),
+    streetAddress: optionalString(),
+    extendedAddress: optionalString(),
+    city: optionalString(),
+    region: optionalString(),
+    postalCode: optionalString(),
+    country: optionalString(),
+    countryCode: optionalString(),
+}, { additionalProperties: true });
+const organization = t.Object({
+    name: optionalString(),
+    title: optionalString(),
+    department: optionalString(),
+    type: optionalString(),
+    symbol: optionalString(),
+    domain: optionalString(),
+    location: optionalString(),
+    jobDescription: optionalString(),
+    phoneticName: optionalString(),
+    costCenter: optionalString(),
+    fullTimeEquivalentMillipercent: t.Optional(t.Integer({ minimum: 0, maximum: 100_000 })),
+    startDate: t.Optional(structuredDate),
+    endDate: t.Optional(structuredDate),
+    current: optionalBoolean,
+}, { additionalProperties: true });
+const clientData = strictObject({ key: NonEmptyString, value: t.String() });
+const contactWritableFields = {
+    givenName: optionalString(),
+    familyName: optionalString(),
+    middleName: optionalString(),
+    honorificPrefix: optionalString(),
+    honorificSuffix: optionalString(),
+    phoneNumbers: t.Optional(t.Array(typedValue)),
+    emailAddresses: t.Optional(t.Array(typedValue)),
+    addresses: t.Optional(t.Array(address)),
+    organizations: t.Optional(t.Array(organization)),
+    relations: t.Optional(t.Array(relation)),
+    urls: t.Optional(t.Array(typedValue)),
+    events: t.Optional(t.Array(contactEvent)),
+    birthday: t.Optional(contactDate),
+    biography: optionalString(),
+    userDefined: t.Optional(t.Array(userDefined)),
+    groups: t.Optional(t.Array(NonEmptyString)),
+};
+const writableContactKeys = Object.keys(contactWritableFields);
+const contactSchemas = {
+    create: strictObject(contactWritableFields),
+    get: strictObject({ contactId: Id, fields: personFields }),
+    list: strictObject({
+        query: optionalString(),
+        fields: personFields,
+        sortOrder: t.Optional(stringEnum([
+            "LAST_MODIFIED_ASCENDING",
+            "LAST_MODIFIED_DESCENDING",
+            "FIRST_NAME_ASCENDING",
+            "LAST_NAME_ASCENDING",
+        ])),
+        returnAll: optionalBoolean,
+        maxResults: t.Optional(PositiveInteger),
+        pageToken: optionalString(),
+    }),
+    update: strictObject({
+        contactId: Id,
+        etag: optionalString(),
+        fields: personFields,
+        ...contactWritableFields,
+    }, { anyOf: writableContactKeys.map((key) => ({ required: [key] })) }),
+    delete: strictObject({ contactId: Id }),
+};
+const groupSchemas = {
+    list: strictObject({
+        returnAll: optionalBoolean,
+        maxResults: t.Optional(PositiveInteger),
+        pageToken: optionalString(),
+        syncToken: optionalString(),
+    }),
+    get: strictObject({
+        groupId: Id,
+        maxMembers: t.Optional(t.Integer({ minimum: 0 })),
+    }),
+    create: strictObject({
+        name: NonEmptyString,
+        clientData: t.Optional(t.Array(clientData)),
+    }),
+    update: strictObject({
+        groupId: Id,
+        name: optionalString(),
+        clientData: t.Optional(t.Array(clientData)),
+        etag: optionalString(),
+    }, { anyOf: [{ required: ["name"] }, { required: ["clientData"] }] }),
+    delete: strictObject({ groupId: Id, deleteContacts: optionalBoolean }),
+};
 export default function googleContacts(rl) {
     rl.setName("googleContacts");
     rl.setVersion("0.1.0");
@@ -326,61 +450,9 @@ export default function googleContacts(rl) {
     });
     // ── Contact ───────────────────────────────────────────
     rl.registerAction("contact.create", {
+        access: "write",
         description: "Create a new contact",
-        inputSchema: {
-            givenName: { type: "string", required: false },
-            familyName: { type: "string", required: false },
-            middleName: { type: "string", required: false },
-            honorificPrefix: { type: "string", required: false },
-            honorificSuffix: { type: "string", required: false },
-            phoneNumbers: {
-                type: "array",
-                required: false,
-                description: "[{value, type?}]",
-            },
-            emailAddresses: {
-                type: "array",
-                required: false,
-                description: "[{value, type?}]",
-            },
-            addresses: {
-                type: "array",
-                required: false,
-                description: "[{formattedValue?, streetAddress?, city?, region?, postalCode?, country?, type?}]",
-            },
-            organizations: {
-                type: "array",
-                required: false,
-                description: "[{name, title?, department?, type?}]",
-            },
-            relations: {
-                type: "array",
-                required: false,
-                description: "[{person, type?}]",
-            },
-            urls: { type: "array", required: false },
-            events: {
-                type: "array",
-                required: false,
-                description: "[{date, type?}] — date can be ISO string or {year, month, day}",
-            },
-            birthday: {
-                type: "string",
-                required: false,
-                description: "ISO date string or {year, month, day}",
-            },
-            biography: { type: "string", required: false },
-            userDefined: {
-                type: "array",
-                required: false,
-                description: "[{key, value}] — custom key/value pairs",
-            },
-            groups: {
-                type: "array",
-                required: false,
-                description: "Group IDs or full contactGroups/… resource names",
-            },
-        },
+        inputSchema: contactSchemas.create,
         async execute(input, ctx) {
             const p = (input ?? {});
             const { body } = buildPersonBody(p);
@@ -389,19 +461,9 @@ export default function googleContacts(rl) {
         },
     });
     rl.registerAction("contact.get", {
+        access: "read",
         description: "Get a contact by ID",
-        inputSchema: {
-            contactId: {
-                type: "string",
-                required: true,
-                description: "Bare ID or full people/… resource name",
-            },
-            fields: {
-                type: "string",
-                required: false,
-                description: "'*' (all), comma-separated string, or array of People-API field names (default: names, emailAddresses, phoneNumbers)",
-            },
-        },
+        inputSchema: contactSchemas.get,
         async execute(input, ctx) {
             const p = (input ?? {});
             const resource = normalizeContactResource(p.contactId);
@@ -410,23 +472,9 @@ export default function googleContacts(rl) {
         },
     });
     rl.registerAction("contact.list", {
+        access: "read",
         description: "List contacts (people/me/connections) or search them. When `query` is set, hits people:searchContacts; otherwise returns the user's connections.",
-        inputSchema: {
-            query: {
-                type: "string",
-                required: false,
-                description: "If set, uses people:searchContacts instead of connections.list",
-            },
-            fields: { type: "string", required: false },
-            sortOrder: {
-                type: "string",
-                required: false,
-                description: "LAST_MODIFIED_ASCENDING | LAST_MODIFIED_DESCENDING | FIRST_NAME_ASCENDING | LAST_NAME_ASCENDING (connections.list only)",
-            },
-            returnAll: { type: "boolean", required: false },
-            maxResults: { type: "number", required: false },
-            pageToken: { type: "string", required: false },
-        },
+        inputSchema: contactSchemas.list,
         async execute(input, ctx) {
             const p = (input ?? {});
             const useSearch = typeof p.query === "string" && p.query.length > 0;
@@ -479,37 +527,9 @@ export default function googleContacts(rl) {
         },
     });
     rl.registerAction("contact.update", {
+        access: "write",
         description: "Update a contact. Only supplied fields are sent; etag is resolved automatically if not provided.",
-        inputSchema: {
-            contactId: { type: "string", required: true },
-            etag: {
-                type: "string",
-                required: false,
-                description: "Optimistic-concurrency tag. If omitted, the plugin fetches the latest etag first.",
-            },
-            fields: {
-                type: "string",
-                required: false,
-                description: "personFields projection on the response (same semantics as contact.get)",
-            },
-            // Writable fields
-            givenName: { type: "string", required: false },
-            familyName: { type: "string", required: false },
-            middleName: { type: "string", required: false },
-            honorificPrefix: { type: "string", required: false },
-            honorificSuffix: { type: "string", required: false },
-            phoneNumbers: { type: "array", required: false },
-            emailAddresses: { type: "array", required: false },
-            addresses: { type: "array", required: false },
-            organizations: { type: "array", required: false },
-            relations: { type: "array", required: false },
-            urls: { type: "array", required: false },
-            events: { type: "array", required: false },
-            birthday: { type: "string", required: false },
-            biography: { type: "string", required: false },
-            userDefined: { type: "array", required: false },
-            groups: { type: "array", required: false },
-        },
+        inputSchema: contactSchemas.update,
         async execute(input, ctx) {
             const p = (input ?? {});
             const resource = normalizeContactResource(p.contactId);
@@ -533,8 +553,9 @@ export default function googleContacts(rl) {
         },
     });
     rl.registerAction("contact.delete", {
+        access: "write",
         description: "Delete a contact",
-        inputSchema: { contactId: { type: "string", required: true } },
+        inputSchema: contactSchemas.delete,
         async execute(input, ctx) {
             const p = (input ?? {});
             const resource = normalizeContactResource(p.contactId);
@@ -544,13 +565,9 @@ export default function googleContacts(rl) {
     });
     // ── Contact groups ────────────────────────────────────
     rl.registerAction("group.list", {
+        access: "read",
         description: "List contact groups (including system groups like 'myContacts' and 'starred')",
-        inputSchema: {
-            returnAll: { type: "boolean", required: false },
-            maxResults: { type: "number", required: false },
-            pageToken: { type: "string", required: false },
-            syncToken: { type: "string", required: false },
-        },
+        inputSchema: groupSchemas.list,
         async execute(input, ctx) {
             const p = (input ?? {});
             const qs = {};
@@ -567,15 +584,9 @@ export default function googleContacts(rl) {
         },
     });
     rl.registerAction("group.get", {
+        access: "read",
         description: "Get a contact group by ID",
-        inputSchema: {
-            groupId: { type: "string", required: true },
-            maxMembers: {
-                type: "number",
-                required: false,
-                description: "Include up to N member resourceNames in the response",
-            },
-        },
+        inputSchema: groupSchemas.get,
         async execute(input, ctx) {
             const p = (input ?? {});
             const resource = normalizeGroupResource(p.groupId);
@@ -586,15 +597,9 @@ export default function googleContacts(rl) {
         },
     });
     rl.registerAction("group.create", {
+        access: "write",
         description: "Create a contact group",
-        inputSchema: {
-            name: { type: "string", required: true },
-            clientData: {
-                type: "array",
-                required: false,
-                description: "[{key, value}] — app-private metadata",
-            },
-        },
+        inputSchema: groupSchemas.create,
         async execute(input, ctx) {
             const p = (input ?? {});
             const body = {
@@ -607,13 +612,9 @@ export default function googleContacts(rl) {
         },
     });
     rl.registerAction("group.update", {
+        access: "write",
         description: "Update a contact group. Pass a fresh `etag` or let the plugin resolve it automatically.",
-        inputSchema: {
-            groupId: { type: "string", required: true },
-            name: { type: "string", required: false },
-            clientData: { type: "array", required: false },
-            etag: { type: "string", required: false },
-        },
+        inputSchema: groupSchemas.update,
         async execute(input, ctx) {
             const p = (input ?? {});
             const resource = normalizeGroupResource(p.groupId);
@@ -642,11 +643,9 @@ export default function googleContacts(rl) {
         },
     });
     rl.registerAction("group.delete", {
+        access: "write",
         description: "Delete a contact group. Pass `deleteContacts=true` to also delete every contact in the group.",
-        inputSchema: {
-            groupId: { type: "string", required: true },
-            deleteContacts: { type: "boolean", required: false },
-        },
+        inputSchema: groupSchemas.delete,
         async execute(input, ctx) {
             const p = (input ?? {});
             const resource = normalizeGroupResource(p.groupId);

package/dist/plugins/googleDocs/src/documents.js

@@ -1,15 +1,16 @@
-import { DRIVE_BASE, docsRequest, extractDocumentId, flattenBodyText, } from "./shared.js";
+import * as t from "typebox";
+import { DocumentInput, DRIVE_BASE, docsRequest, extractDocumentId, flattenBodyText, RawGoogleObject, STRICT_OBJECT, WriteControl, } from "./shared.js";
 export function registerDocumentsActions(rl) {
     rl.registerAction("document.create", {
+        access: "write",
         description: "Create a new Google Doc, optionally in a specific Drive folder (goes through the Drive API; needs drive.file scope).",
-        inputSchema: {
-            title: { type: "string", required: true },
-            folderId: {
-                type: "string",
-                required: false,
+        inputSchema: t.Object({
+            title: t.String({ minLength: 1 }),
+            folderId: t.Optional(t.String({
+                minLength: 1,
                 description: "Parent folder in Drive. Omit to place in My Drive root.",
-            },
-        },
+            })),
+        }, STRICT_OBJECT),
         async execute(input, ctx) {
             const p = (input ?? {});
             const body = {
@@ -23,35 +24,30 @@ export function registerDocumentsActions(rl) {
         },
     });
     rl.registerAction("document.createBlank", {
+        access: "write",
         description: "Create a blank Google Doc through the native Docs API. Use document.create when you need Drive folder placement.",
-        inputSchema: {
-            title: { type: "string", required: true },
-        },
+        inputSchema: t.Object({ title: t.String({ minLength: 1 }) }, STRICT_OBJECT),
         async execute(input, ctx) {
             const p = (input ?? {});
             return docsRequest(ctx, "POST", "/documents", { title: p.title });
         },
     });
     rl.registerAction("document.get", {
+        access: "read",
         description: "Get a document. Accepts a bare ID or a docs.google.com URL. `simple=true` collapses the body to plain text.",
-        inputSchema: {
-            document: {
-                type: "string",
-                required: true,
-                description: "Document ID or URL",
-            },
-            simple: { type: "boolean", required: false },
-            suggestionsViewMode: {
-                type: "string",
-                required: false,
-                description: "DEFAULT_FOR_CURRENT_ACCESS | SUGGESTIONS_INLINE | PREVIEW_SUGGESTIONS_ACCEPTED | PREVIEW_WITHOUT_SUGGESTIONS",
-            },
-            includeTabsContent: {
-                type: "boolean",
-                required: false,
-                description: "Return content for all tabs in document.tabs instead of only first-tab legacy fields.",
-            },
-        },
+        inputSchema: t.Object({
+            ...DocumentInput,
+            simple: t.Optional(t.Boolean()),
+            suggestionsViewMode: t.Optional(t.Union([
+                t.Literal("DEFAULT_FOR_CURRENT_ACCESS"),
+                t.Literal("SUGGESTIONS_INLINE"),
+                t.Literal("PREVIEW_SUGGESTIONS_ACCEPTED"),
+                t.Literal("PREVIEW_WITHOUT_SUGGESTIONS"),
+            ])),
+            includeTabsContent: t.Optional(t.Boolean({
+                description: "Return content for all tabs instead of only first-tab legacy fields.",
+            })),
+        }, STRICT_OBJECT),
         async execute(input, ctx) {
             const p = (input ?? {});
             const documentId = extractDocumentId(p.document);
@@ -67,16 +63,13 @@ export function registerDocumentsActions(rl) {
         },
     });
     rl.registerAction("document.batchUpdate", {
+        access: "write",
         description: "Raw passthrough to documents.batchUpdate — pass a full `requests` array for atomic multi-edit operations.",
-        inputSchema: {
-            document: { type: "string", required: true },
-            requests: { type: "array", required: true },
-            writeControl: {
-                type: "object",
-                required: false,
-                description: "{requiredRevisionId} | {targetRevisionId}",
-            },
-        },
+        inputSchema: t.Object({
+            ...DocumentInput,
+            requests: t.Array(RawGoogleObject, { minItems: 1 }),
+            writeControl: t.Optional(WriteControl),
+        }, STRICT_OBJECT),
         async execute(input, ctx) {
             const p = (input ?? {});
             const documentId = extractDocumentId(p.document);

package/dist/plugins/googleDocs/src/formatting.js

@@ -1,39 +1,50 @@
-import { compact, extractDocumentId, runBatchUpdate } from "./shared.js";
+import * as t from "typebox";
+import { compact, DocumentInput, extractDocumentId, PositivePoints, RangeInput, RawGoogleObject, runBatchUpdate, STRICT_OBJECT, } from "./shared.js";
 export function registerFormattingActions(rl) {
     rl.registerAction("document.updateParagraphStyle", {
+        access: "write",
         description: "Apply paragraph styling (alignment, named style, indents, spacing, direction) to the paragraphs intersecting the range.",
-        inputSchema: {
-            document: { type: "string", required: true },
-            startIndex: { type: "number", required: true },
-            endIndex: { type: "number", required: true },
-            alignment: {
-                type: "string",
-                required: false,
-                description: "START | CENTER | END | JUSTIFIED",
-            },
-            namedStyleType: {
-                type: "string",
-                required: false,
-                description: "NORMAL_TEXT | TITLE | SUBTITLE | HEADING_1 .. HEADING_6",
-            },
-            direction: {
-                type: "string",
-                required: false,
-                description: "LEFT_TO_RIGHT | RIGHT_TO_LEFT",
-            },
-            indentFirstLinePt: { type: "number", required: false },
-            indentStartPt: { type: "number", required: false },
-            indentEndPt: { type: "number", required: false },
-            spaceAbovePt: { type: "number", required: false },
-            spaceBelowPt: { type: "number", required: false },
-            lineSpacing: {
-                type: "number",
-                required: false,
-                description: "Percentage; 100 = single, 150 = 1.5x.",
-            },
-            segmentId: { type: "string", required: false },
-            tabId: { type: "string", required: false },
-        },
+        inputSchema: t.Object({
+            ...DocumentInput,
+            ...RangeInput,
+            alignment: t.Optional(t.Union([
+                t.Literal("START"),
+                t.Literal("CENTER"),
+                t.Literal("END"),
+                t.Literal("JUSTIFIED"),
+            ])),
+            namedStyleType: t.Optional(t.Union([
+                t.Literal("NORMAL_TEXT"),
+                t.Literal("TITLE"),
+                t.Literal("SUBTITLE"),
+                t.Literal("HEADING_1"),
+                t.Literal("HEADING_2"),
+                t.Literal("HEADING_3"),
+                t.Literal("HEADING_4"),
+                t.Literal("HEADING_5"),
+                t.Literal("HEADING_6"),
+            ])),
+            direction: t.Optional(t.Union([t.Literal("LEFT_TO_RIGHT"), t.Literal("RIGHT_TO_LEFT")])),
+            indentFirstLinePt: t.Optional(PositivePoints),
+            indentStartPt: t.Optional(PositivePoints),
+            indentEndPt: t.Optional(PositivePoints),
+            spaceAbovePt: t.Optional(PositivePoints),
+            spaceBelowPt: t.Optional(PositivePoints),
+            lineSpacing: t.Optional(t.Number({ minimum: 0 })),
+        }, {
+            ...STRICT_OBJECT,
+            anyOf: [
+                { required: ["alignment"] },
+                { required: ["namedStyleType"] },
+                { required: ["direction"] },
+                { required: ["indentFirstLinePt"] },
+                { required: ["indentStartPt"] },
+                { required: ["indentEndPt"] },
+                { required: ["spaceAbovePt"] },
+                { required: ["spaceBelowPt"] },
+                { required: ["lineSpacing"] },
+            ],
+        }),
         async execute(input, ctx) {
             const p = (input ?? {});
             const documentId = extractDocumentId(p.document);
@@ -96,21 +107,14 @@ export function registerFormattingActions(rl) {
         },
     });
     rl.registerAction("document.updateNamedStyle", {
+        access: "write",
         description: "Update a named style such as NORMAL_TEXT, TITLE, or HEADING_1 using a Docs API NamedStyle object.",
-        inputSchema: {
-            document: { type: "string", required: true },
-            namedStyle: {
-                type: "object",
-                required: true,
-                description: "Docs API NamedStyle object. Must include namedStyleType.",
-            },
-            fields: {
-                type: "string",
-                required: true,
-                description: "Field mask such as textStyle.bold or paragraphStyle.alignment.",
-            },
-            tabId: { type: "string", required: false },
-        },
+        inputSchema: t.Object({
+            ...DocumentInput,
+            namedStyle: RawGoogleObject,
+            fields: t.String({ minLength: 1 }),
+            tabId: t.Optional(t.String({ minLength: 1 })),
+        }, STRICT_OBJECT),
         async execute(input, ctx) {
             const p = (input ?? {});
             const documentId = extractDocumentId(p.document);

package/dist/plugins/googleDocs/src/images.js

@@ -1,21 +1,21 @@
-import { buildLocation, extractDocumentId, runBatchUpdate } from "./shared.js";
+import * as t from "typebox";
+import { buildLocation, DocumentInput, extractDocumentId, LOCATION_REQUIREMENT, LocationInput, PositivePoints, runBatchUpdate, STRICT_OBJECT, } from "./shared.js";
+const PublicImageUri = t.String({
+    minLength: 1,
+    pattern: "^https?://",
+    description: "Publicly fetchable HTTP(S) image URI",
+});
 export function registerImagesActions(rl) {
     rl.registerAction("document.insertInlineImage", {
+        access: "write",
         description: "Insert an inline image at the given location. `uri` must point to a publicly fetchable image.",
-        inputSchema: {
-            document: { type: "string", required: true },
-            locationKind: {
-                type: "string",
-                required: false,
-                description: "location (default; requires index) | endOfSegmentLocation",
-            },
-            index: { type: "number", required: false },
-            uri: { type: "string", required: true },
-            widthPt: { type: "number", required: false },
-            heightPt: { type: "number", required: false },
-            segmentId: { type: "string", required: false },
-            tabId: { type: "string", required: false },
-        },
+        inputSchema: t.Object({
+            ...DocumentInput,
+            ...LocationInput,
+            uri: PublicImageUri,
+            widthPt: t.Optional(PositivePoints),
+            heightPt: t.Optional(PositivePoints),
+        }, { ...STRICT_OBJECT, anyOf: LOCATION_REQUIREMENT }),
         async execute(input, ctx) {
             const p = (input ?? {});
             const documentId = extractDocumentId(p.document);
@@ -36,18 +36,15 @@ export function registerImagesActions(rl) {
         },
     });
     rl.registerAction("document.replaceImage", {
+        access: "write",
         description: "Replace an existing image (identified by its inline-object id) with a new image from a publicly fetchable URI.",
-        inputSchema: {
-            document: { type: "string", required: true },
-            imageObjectId: { type: "string", required: true },
-            uri: { type: "string", required: true },
-            imageReplaceMethod: {
-                type: "string",
-                required: false,
-                description: "CENTER_CROP (default) | (others as Docs API adds them)",
-            },
-            tabId: { type: "string", required: false },
-        },
+        inputSchema: t.Object({
+            ...DocumentInput,
+            imageObjectId: t.String({ minLength: 1 }),
+            uri: PublicImageUri,
+            imageReplaceMethod: t.Optional(t.Literal("CENTER_CROP")),
+            tabId: t.Optional(t.String({ minLength: 1 })),
+        }, STRICT_OBJECT),
         async execute(input, ctx) {
             const p = (input ?? {});
             const documentId = extractDocumentId(p.document);