@mcp-z/mcp-sheets 1.0.0

package/dist/cjs/mcp/tools/chart-create.d.ts

@@ -0,0 +1,94 @@
+import type { EnrichedExtra } from '@mcp-z/oauth-google';
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+declare const inputSchema: z.ZodObject<{
+    id: z.ZodString;
+    gid: z.ZodCoercedString<unknown>;
+    chartType: z.ZodEnum<{
+        PIE: "PIE";
+        BAR: "BAR";
+        COLUMN: "COLUMN";
+        LINE: "LINE";
+    }>;
+    dataRange: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    position: z.ZodObject<{
+        anchorCell: z.ZodString;
+        offsetX: z.ZodDefault<z.ZodNumber>;
+        offsetY: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    legend: z.ZodDefault<z.ZodEnum<{
+        LEFT: "LEFT";
+        RIGHT: "RIGHT";
+        BOTTOM: "BOTTOM";
+        TOP: "TOP";
+        NONE: "NONE";
+    }>>;
+    is3D: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const outputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"success">;
+    id: z.ZodString;
+    gid: z.ZodString;
+    sheetTitle: z.ZodString;
+    sheetUrl: z.ZodString;
+    chartId: z.ZodNumber;
+    anchorCell: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"auth_required">;
+    provider: z.ZodString;
+    message: z.ZodString;
+    url: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "type">;
+export type Input = z.infer<typeof inputSchema>;
+export type Output = z.infer<typeof outputSchema>;
+declare function handler({ id, gid, chartType, dataRange, title, position, legend, is3D }: Input, extra: EnrichedExtra): Promise<CallToolResult>;
+export default function createTool(): {
+    name: string;
+    config: {
+        readonly description: "Create charts (pie, bar, column, line) from spreadsheet data ranges. Charts anchor to specific cells with optional pixel offsets. Data range should include headers. PIE charts use 2 columns (labels, values). BAR/COLUMN/LINE charts use first row as headers. Best for visualizing spreadsheet data.";
+        readonly inputSchema: z.ZodObject<{
+            id: z.ZodString;
+            gid: z.ZodCoercedString<unknown>;
+            chartType: z.ZodEnum<{
+                PIE: "PIE";
+                BAR: "BAR";
+                COLUMN: "COLUMN";
+                LINE: "LINE";
+            }>;
+            dataRange: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+            position: z.ZodObject<{
+                anchorCell: z.ZodString;
+                offsetX: z.ZodDefault<z.ZodNumber>;
+                offsetY: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>;
+            legend: z.ZodDefault<z.ZodEnum<{
+                LEFT: "LEFT";
+                RIGHT: "RIGHT";
+                BOTTOM: "BOTTOM";
+                TOP: "TOP";
+                NONE: "NONE";
+            }>>;
+            is3D: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>;
+        readonly outputSchema: z.ZodObject<{
+            result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"success">;
+                id: z.ZodString;
+                gid: z.ZodString;
+                sheetTitle: z.ZodString;
+                sheetUrl: z.ZodString;
+                chartId: z.ZodNumber;
+                anchorCell: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"auth_required">;
+                provider: z.ZodString;
+                message: z.ZodString;
+                url: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>], "type">;
+        }, z.core.$strip>;
+    };
+    handler: typeof handler;
+};
+export {};

package/dist/cjs/mcp/tools/chart-create.js

@@ -0,0 +1,575 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return createTool;
+    }
+});
+var _oauthgoogle = require("@mcp-z/oauth-google");
+var _types = require("@modelcontextprotocol/sdk/types.js");
+var _googleapis = require("googleapis");
+var _zod = require("zod");
+var _index = require("../../schemas/index.js");
+var _rangeoperations = require("../../spreadsheet/range-operations.js");
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var AuthRequiredBranchSchema = _oauthgoogle.schemas.AuthRequiredBranchSchema;
+// Input schema for chart position
+var ChartPositionSchema = _zod.z.object({
+    anchorCell: _zod.z.string().min(1).describe('A1 notation cell where chart top-left anchors (e.g., "F2")'),
+    offsetX: _zod.z.number().int().default(0).describe('Horizontal pixel offset from anchor'),
+    offsetY: _zod.z.number().int().default(0).describe('Vertical pixel offset from anchor')
+});
+var inputSchema = _zod.z.object({
+    id: _index.SpreadsheetIdSchema,
+    gid: _index.SheetGidSchema,
+    chartType: _zod.z.enum([
+        'PIE',
+        'BAR',
+        'COLUMN',
+        'LINE'
+    ]).describe('Type of chart to create'),
+    dataRange: _zod.z.string().min(1).describe('A1 notation range containing chart data including headers (e.g., "A1:C10")'),
+    title: _zod.z.string().optional().describe('Chart title displayed at top'),
+    position: ChartPositionSchema,
+    legend: _zod.z.enum([
+        'BOTTOM',
+        'RIGHT',
+        'TOP',
+        'LEFT',
+        'NONE'
+    ]).default('BOTTOM').describe('Legend position'),
+    is3D: _zod.z.boolean().default(false).describe('Render as 3D chart (PIE only)')
+});
+// Success branch schema
+var successBranchSchema = _zod.z.object({
+    type: _zod.z.literal('success'),
+    id: _index.SpreadsheetIdOutput,
+    gid: _index.SheetGidOutput,
+    sheetTitle: _zod.z.string().describe('Title of the sheet containing the chart'),
+    sheetUrl: _zod.z.string().describe('URL of the sheet containing the chart'),
+    chartId: _zod.z.number().int().describe('Unique chart ID for future updates/deletion'),
+    anchorCell: _zod.z.string().describe('Where chart was anchored')
+});
+// Output schema with auth_required support
+var outputSchema = _zod.z.discriminatedUnion('type', [
+    successBranchSchema,
+    AuthRequiredBranchSchema
+]);
+var config = {
+    description: 'Create charts (pie, bar, column, line) from spreadsheet data ranges. Charts anchor to specific cells with optional pixel offsets. Data range should include headers. PIE charts use 2 columns (labels, values). BAR/COLUMN/LINE charts use first row as headers. Best for visualizing spreadsheet data.',
+    inputSchema: inputSchema,
+    outputSchema: _zod.z.object({
+        result: outputSchema
+    })
+};
+// Parse A1 notation anchor cell to row/column indices
+function parseAnchorCell(anchorCell) {
+    // Simple A1 notation parser for single cells
+    var match = anchorCell.match(/^([A-Z]+)(\d+)$/);
+    if (!match || !match[1] || !match[2]) {
+        throw new Error("Invalid anchor cell format: ".concat(anchorCell));
+    }
+    var colLetters = match[1];
+    var rowNumber = match[2];
+    // Convert column letters to index (A=0, B=1, ..., Z=25, AA=26, etc.)
+    var columnIndex = 0;
+    for(var i = 0; i < colLetters.length; i++){
+        columnIndex = columnIndex * 26 + (colLetters.charCodeAt(i) - 65 + 1);
+    }
+    columnIndex--; // Convert to 0-based
+    // Convert row number to index (1-based to 0-based)
+    var rowIndex = Number.parseInt(rowNumber, 10) - 1;
+    return {
+        rowIndex: rowIndex,
+        columnIndex: columnIndex
+    };
+}
+function handler(_0, _1) {
+    return _async_to_generator(function(param, extra) {
+        var id, gid, chartType, dataRange, title, position, _param_legend, legend, _param_is3D, is3D, logger, _sheet_properties_title, _dataGridRange_sheetId, _spreadsheetResponse_data_sheets, _replies__addChart_chart, _replies__addChart, _replies_, sheets, spreadsheetResponse, sheet, sheetTitle, sheetId, sheetUrl, anchorRowIndex, anchorColumnIndex, anchorIndices, message, dataGridRange, rangeRef, message1, dataStartRowIndex, dataEndRowIndex, dataStartColumnIndex, dataEndColumnIndex, dataSheetId, chartSpec, legendPositionMap, apiLegendPosition, baseSheetId, domainRange, seriesRange, baseSheetId1, domainRange1, numDataColumns, series, i, seriesRange1, basicChart, embeddedObjectPosition, requestBody, response, replies, chartId, result, e, _error_response, _error_response1, _$error, message2;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    id = param.id, gid = param.gid, chartType = param.chartType, dataRange = param.dataRange, title = param.title, position = param.position, _param_legend = param.legend, legend = _param_legend === void 0 ? 'BOTTOM' : _param_legend, _param_is3D = param.is3D, is3D = _param_is3D === void 0 ? false : _param_is3D;
+                    logger = extra.logger;
+                    logger.info('sheets.chart.create called', {
+                        id: id,
+                        gid: gid,
+                        chartType: chartType,
+                        dataRange: dataRange,
+                        title: title,
+                        position: position,
+                        legend: legend,
+                        is3D: is3D
+                    });
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        4,
+                        ,
+                        5
+                    ]);
+                    sheets = _googleapis.google.sheets({
+                        version: 'v4',
+                        auth: extra.authContext.auth
+                    });
+                    return [
+                        4,
+                        sheets.spreadsheets.get({
+                            spreadsheetId: id,
+                            fields: 'sheets.properties.sheetId,sheets.properties.title'
+                        })
+                    ];
+                case 2:
+                    spreadsheetResponse = _state.sent();
+                    // Find sheet by gid
+                    sheet = (_spreadsheetResponse_data_sheets = spreadsheetResponse.data.sheets) === null || _spreadsheetResponse_data_sheets === void 0 ? void 0 : _spreadsheetResponse_data_sheets.find(function(s) {
+                        var _s_properties;
+                        return String((_s_properties = s.properties) === null || _s_properties === void 0 ? void 0 : _s_properties.sheetId) === gid;
+                    });
+                    if (!(sheet === null || sheet === void 0 ? void 0 : sheet.properties)) {
+                        logger.info('Sheet not found for chart create', {
+                            id: id,
+                            gid: gid,
+                            chartType: chartType
+                        });
+                        throw new _types.McpError(_types.ErrorCode.InvalidParams, "Sheet not found: ".concat(gid));
+                    }
+                    sheetTitle = (_sheet_properties_title = sheet.properties.title) !== null && _sheet_properties_title !== void 0 ? _sheet_properties_title : gid;
+                    sheetId = sheet.properties.sheetId;
+                    sheetUrl = "https://docs.google.com/spreadsheets/d/".concat(id, "/edit#gid=").concat(sheetId);
+                    // Validate 3D only for PIE charts
+                    // Note: Google Sheets API only supports 3D for PIE charts, not COLUMN/BAR/LINE
+                    if (is3D && chartType !== 'PIE') {
+                        logger.info('3D mode not supported for this chart type', {
+                            chartType: chartType,
+                            is3D: is3D
+                        });
+                        throw new _types.McpError(_types.ErrorCode.InvalidParams, "3D mode is only supported for PIE charts, not ".concat(chartType));
+                    }
+                    try {
+                        anchorIndices = parseAnchorCell(position.anchorCell);
+                        anchorRowIndex = anchorIndices.rowIndex;
+                        anchorColumnIndex = anchorIndices.columnIndex;
+                    } catch (error) {
+                        message = _instanceof(error, Error) ? error.message : String(error);
+                        logger.info('Failed to parse anchor cell', {
+                            anchorCell: position.anchorCell,
+                            error: message
+                        });
+                        throw new _types.McpError(_types.ErrorCode.InvalidParams, "Failed to parse anchor cell: ".concat(message));
+                    }
+                    try {
+                        rangeRef = (0, _rangeoperations.parseA1Notation)(dataRange);
+                        dataGridRange = (0, _rangeoperations.rangeReferenceToGridRange)(rangeRef, sheetId);
+                        // Validate that required properties are defined for chart creation
+                        if (dataGridRange.startColumnIndex === undefined || dataGridRange.startColumnIndex === null) {
+                            throw new Error('Data range must include column information');
+                        }
+                        if (dataGridRange.endColumnIndex === undefined || dataGridRange.endColumnIndex === null) {
+                            throw new Error('Data range must include column information');
+                        }
+                        if (dataGridRange.startRowIndex === undefined || dataGridRange.startRowIndex === null) {
+                            throw new Error('Data range must include row information');
+                        }
+                        if (dataGridRange.endRowIndex === undefined || dataGridRange.endRowIndex === null) {
+                            throw new Error('Data range must include row information');
+                        }
+                    } catch (error) {
+                        message1 = _instanceof(error, Error) ? error.message : String(error);
+                        logger.info('Failed to parse data range', {
+                            dataRange: dataRange,
+                            error: message1
+                        });
+                        throw new _types.McpError(_types.ErrorCode.InvalidParams, "Failed to parse data range: ".concat(message1));
+                    }
+                    // Extract validated properties with defined types
+                    dataStartRowIndex = dataGridRange.startRowIndex;
+                    dataEndRowIndex = dataGridRange.endRowIndex;
+                    dataStartColumnIndex = dataGridRange.startColumnIndex;
+                    dataEndColumnIndex = dataGridRange.endColumnIndex;
+                    dataSheetId = (_dataGridRange_sheetId = dataGridRange.sheetId) !== null && _dataGridRange_sheetId !== void 0 ? _dataGridRange_sheetId : sheetId;
+                    logger.info('Building chart spec', {
+                        chartType: chartType,
+                        dataGridRange: dataGridRange,
+                        sheetId: sheetId
+                    });
+                    // Map legend position to API format (add _LEGEND suffix)
+                    legendPositionMap = {
+                        BOTTOM: 'BOTTOM_LEGEND',
+                        RIGHT: 'RIGHT_LEGEND',
+                        TOP: 'TOP_LEGEND',
+                        LEFT: 'LEFT_LEGEND',
+                        NONE: 'NO_LEGEND'
+                    };
+                    apiLegendPosition = legendPositionMap[legend] || 'BOTTOM_LEGEND';
+                    if (chartType === 'PIE') {
+                        // PIE charts use a separate pieChart property, not basicChart
+                        baseSheetId = dataSheetId;
+                        domainRange = {
+                            sheetId: baseSheetId,
+                            startRowIndex: dataStartRowIndex,
+                            endRowIndex: dataEndRowIndex,
+                            startColumnIndex: dataStartColumnIndex,
+                            endColumnIndex: dataStartColumnIndex + 1
+                        };
+                        seriesRange = {
+                            sheetId: baseSheetId,
+                            startRowIndex: dataStartRowIndex,
+                            endRowIndex: dataEndRowIndex,
+                            startColumnIndex: dataStartColumnIndex + 1,
+                            endColumnIndex: dataStartColumnIndex + 2
+                        };
+                        logger.info('PIE chart ranges', {
+                            dataGridRange: dataGridRange,
+                            domainRange: domainRange,
+                            seriesRange: seriesRange,
+                            apiLegendPosition: apiLegendPosition
+                        });
+                        chartSpec = {
+                            pieChart: {
+                                // Use pieChart for PIE charts
+                                legendPosition: legend === 'NONE' ? 'NO_LEGEND' : apiLegendPosition,
+                                domain: {
+                                    // Note: domain/series are direct objects, not arrays
+                                    sourceRange: {
+                                        sources: [
+                                            domainRange
+                                        ]
+                                    }
+                                },
+                                series: {
+                                    sourceRange: {
+                                        sources: [
+                                            seriesRange
+                                        ]
+                                    }
+                                },
+                                threeDimensional: is3D
+                            }
+                        };
+                        if (title) {
+                            chartSpec.title = title;
+                        }
+                    } else {
+                        // For BAR, COLUMN, LINE charts: domain is first column, each subsequent column is a series
+                        baseSheetId1 = dataSheetId;
+                        domainRange1 = {
+                            sheetId: baseSheetId1,
+                            startRowIndex: dataStartRowIndex,
+                            endRowIndex: dataEndRowIndex,
+                            startColumnIndex: dataStartColumnIndex,
+                            endColumnIndex: dataStartColumnIndex + 1
+                        };
+                        // Calculate number of data columns (excluding the first domain column)
+                        numDataColumns = dataEndColumnIndex - dataStartColumnIndex - 1;
+                        series = [];
+                        // Create a series for each data column
+                        for(i = 0; i < numDataColumns; i++){
+                            seriesRange1 = {
+                                sheetId: baseSheetId1,
+                                startRowIndex: dataStartRowIndex,
+                                endRowIndex: dataEndRowIndex,
+                                startColumnIndex: dataStartColumnIndex + 1 + i,
+                                endColumnIndex: dataStartColumnIndex + 2 + i
+                            };
+                            series.push({
+                                series: {
+                                    sourceRange: {
+                                        sources: [
+                                            seriesRange1
+                                        ]
+                                    }
+                                }
+                            });
+                        }
+                        // If no data columns were found, default to using the entire range as a fallback
+                        if (series.length === 0) {
+                            series.push({
+                                series: {
+                                    sourceRange: {
+                                        sources: [
+                                            dataGridRange
+                                        ]
+                                    }
+                                }
+                            });
+                        }
+                        basicChart = {
+                            chartType: chartType,
+                            headerCount: 1,
+                            // Note: Google Sheets API does not support threeDimensional for basicChart (BAR/COLUMN/LINE)
+                            // threeDimensional is only supported for pieChart
+                            domains: [
+                                {
+                                    domain: {
+                                        sourceRange: {
+                                            sources: [
+                                                domainRange1
+                                            ]
+                                        }
+                                    }
+                                }
+                            ],
+                            series: series
+                        };
+                        if (legend !== 'NONE') {
+                            basicChart.legendPosition = apiLegendPosition;
+                        }
+                        chartSpec = {
+                            basicChart: basicChart
+                        };
+                        if (title) {
+                            chartSpec.title = title;
+                        }
+                    }
+                    // Build embedded object position
+                    embeddedObjectPosition = {
+                        overlayPosition: {
+                            anchorCell: {
+                                sheetId: sheetId,
+                                rowIndex: anchorRowIndex,
+                                columnIndex: anchorColumnIndex
+                            },
+                            offsetXPixels: position.offsetX,
+                            offsetYPixels: position.offsetY
+                        }
+                    };
+                    requestBody = {
+                        requests: [
+                            {
+                                addChart: {
+                                    chart: {
+                                        spec: chartSpec,
+                                        position: embeddedObjectPosition
+                                    }
+                                }
+                            }
+                        ]
+                    };
+                    logger.info('sheets.chart.create executing addChart request', {
+                        spreadsheetId: id,
+                        sheetTitle: sheetTitle,
+                        chartType: chartType,
+                        dataRange: dataRange,
+                        anchorCell: position.anchorCell,
+                        requestBody: JSON.stringify(requestBody)
+                    });
+                    return [
+                        4,
+                        sheets.spreadsheets.batchUpdate({
+                            spreadsheetId: id,
+                            requestBody: requestBody
+                        })
+                    ];
+                case 3:
+                    response = _state.sent();
+                    // Extract chart ID from response
+                    replies = response.data.replies || [];
+                    if (replies.length === 0 || !((_replies_ = replies[0]) === null || _replies_ === void 0 ? void 0 : (_replies__addChart = _replies_.addChart) === null || _replies__addChart === void 0 ? void 0 : (_replies__addChart_chart = _replies__addChart.chart) === null || _replies__addChart_chart === void 0 ? void 0 : _replies__addChart_chart.chartId)) {
+                        logger.error('Chart creation failed - no chart ID returned', {
+                            spreadsheetId: id,
+                            sheetTitle: sheetTitle,
+                            chartType: chartType
+                        });
+                        throw new _types.McpError(_types.ErrorCode.InternalError, 'Chart creation failed: no chart ID returned from Google Sheets API');
+                    }
+                    chartId = replies[0].addChart.chart.chartId;
+                    logger.info('sheets.chart.create completed successfully', {
+                        chartId: chartId,
+                        chartType: chartType,
+                        anchorCell: position.anchorCell
+                    });
+                    result = {
+                        type: 'success',
+                        id: id,
+                        gid: String(sheetId),
+                        sheetTitle: sheetTitle,
+                        sheetUrl: sheetUrl,
+                        chartId: chartId,
+                        anchorCell: position.anchorCell
+                    };
+                    return [
+                        2,
+                        {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: JSON.stringify(result)
+                                }
+                            ],
+                            structuredContent: {
+                                result: result
+                            }
+                        }
+                    ];
+                case 4:
+                    e = _state.sent();
+                    _$error = e;
+                    message2 = _$error.message || String(e);
+                    logger.error('Chart create operation failed', {
+                        id: id,
+                        gid: gid,
+                        chartType: chartType,
+                        dataRange: dataRange,
+                        error: message2,
+                        response: (_error_response = _$error.response) === null || _error_response === void 0 ? void 0 : _error_response.data,
+                        status: (_error_response1 = _$error.response) === null || _error_response1 === void 0 ? void 0 : _error_response1.status
+                    });
+                    throw new _types.McpError(_types.ErrorCode.InternalError, "Error creating chart: ".concat(message2), {
+                        stack: _instanceof(e, Error) ? e.stack : undefined
+                    });
+                case 5:
+                    return [
+                        2
+                    ];
+            }
+        });
+    }).apply(this, arguments);
+}
+function createTool() {
+    return {
+        name: 'chart-create',
+        config: config,
+        handler: handler
+    };
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }