-
Notifications
You must be signed in to change notification settings - Fork 3.7k
Expand file tree
/
Copy pathcreate.ts
More file actions
225 lines (200 loc) · 6.82 KB
/
Copy pathcreate.ts
File metadata and controls
225 lines (200 loc) · 6.82 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
import { createLogger } from '@sim/logger'
import { generateShortId } from '@sim/utils/id'
import type { GoogleDocsCreateResponse, GoogleDocsToolParams } from '@/tools/google_docs/types'
import type { ToolConfig } from '@/tools/types'
const logger = createLogger('GoogleDocsCreateTool')
const DOC_MIME_TYPE = 'application/vnd.google-apps.document'
/**
* Build a multipart/related body for Drive's files.create upload endpoint.
* Used when converting Markdown to a Google Doc in a single round-trip.
* See: https://developers.google.com/workspace/drive/api/guides/manage-uploads
*/
function buildMarkdownMultipartBody(
metadata: Record<string, unknown>,
markdownContent: string,
boundary: string
): string {
return (
`--${boundary}\r\n` +
`Content-Type: application/json; charset=UTF-8\r\n\r\n` +
`${JSON.stringify(metadata)}\r\n` +
`--${boundary}\r\n` +
`Content-Type: text/markdown\r\n\r\n` +
`${markdownContent}\r\n` +
`--${boundary}--`
)
}
function shouldUseMarkdownUpload(params: GoogleDocsToolParams): boolean {
return Boolean(params.markdown && params.content)
}
export const createTool: ToolConfig<GoogleDocsToolParams, GoogleDocsCreateResponse> = {
id: 'google_docs_create',
name: 'Create Google Docs Document',
description: 'Create a new Google Docs document',
version: '1.0',
oauth: {
required: true,
provider: 'google-docs',
},
params: {
accessToken: {
type: 'string',
required: true,
visibility: 'hidden',
description: 'The access token for the Google Docs API',
},
title: {
type: 'string',
required: true,
visibility: 'user-or-llm',
description: 'The title of the document to create',
},
content: {
type: 'string',
required: false,
visibility: 'user-or-llm',
description: 'The content of the document to create',
},
folderSelector: {
type: 'string',
required: false,
visibility: 'user-or-llm',
description: 'Google Drive folder ID to create the document in (e.g., 1ABCxyz...)',
},
folderId: {
type: 'string',
required: false,
visibility: 'hidden',
description: 'The ID of the folder to create the document in (internal use)',
},
markdown: {
type: 'boolean',
required: false,
visibility: 'user-or-llm',
description:
'When true, content is interpreted as Markdown and converted to formatted Google Docs content (headings, bold/italic, lists, tables, links, code blocks, blockquotes). Default: false (content inserted as plain text).',
},
},
request: {
url: (params) => {
return shouldUseMarkdownUpload(params)
? 'https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart&supportsAllDrives=true'
: 'https://www.googleapis.com/drive/v3/files?supportsAllDrives=true'
},
method: 'POST',
headers: (params) => {
if (!params.accessToken) {
throw new Error('Access token is required')
}
if (shouldUseMarkdownUpload(params)) {
const boundary = `sim_gdocs_md_${generateShortId(24)}`
// Stash on params so body() uses the matching boundary string
;(params as GoogleDocsToolParams & { _boundary?: string })._boundary = boundary
return {
Authorization: `Bearer ${params.accessToken}`,
'Content-Type': `multipart/related; boundary=${boundary}`,
}
}
return {
Authorization: `Bearer ${params.accessToken}`,
'Content-Type': 'application/json',
}
},
body: (params) => {
if (!params.title) {
throw new Error('Title is required')
}
const folderId = params.folderSelector || params.folderId
const metadata: Record<string, unknown> = {
name: params.title,
mimeType: DOC_MIME_TYPE,
}
if (folderId) {
metadata.parents = [folderId]
}
if (shouldUseMarkdownUpload(params)) {
const boundary = (params as GoogleDocsToolParams & { _boundary?: string })._boundary
if (!boundary) {
// headers() runs before body() in formatRequestParams and stashes the boundary
// on the same params reference. Missing _boundary means that contract was broken,
// which would silently produce a Content-Type / body boundary mismatch (HTTP 400).
// Throw loudly instead of fabricating a mismatched boundary.
throw new Error(
'Multipart boundary missing on params — headers() must run before body() for markdown upload'
)
}
return buildMarkdownMultipartBody(metadata, params.content ?? '', boundary)
}
return metadata
},
},
postProcess: async (result, params, executeTool) => {
if (!result.success) {
return result
}
const documentId = result.output.metadata.documentId
// When the markdown upload path ran, content was already inserted via Drive's
// text/markdown import conversion during files.create — no follow-up write needed.
if (shouldUseMarkdownUpload(params)) {
return result
}
if (params.content && documentId) {
try {
const writeParams = {
accessToken: params.accessToken,
documentId: documentId,
content: params.content,
}
const writeResult = await executeTool('google_docs_write', writeParams)
if (!writeResult.success) {
logger.warn(
'Failed to add content to document, but document was created:',
writeResult.error
)
}
} catch (error) {
logger.warn('Error adding content to document:', { error })
// Don't fail the overall operation if adding content fails
}
}
return result
},
transformResponse: async (response: Response) => {
try {
// Get the response data
const responseText = await response.text()
const data = JSON.parse(responseText)
const documentId = data.id
const title = data.name
const metadata = {
documentId,
title: title || 'Untitled Document',
mimeType: DOC_MIME_TYPE,
url: `https://docs.google.com/document/d/${documentId}/edit`,
}
return {
success: true,
output: {
metadata,
},
}
} catch (error) {
logger.error('Google Docs create - Error processing response:', {
error,
})
throw error
}
},
outputs: {
metadata: {
type: 'json',
description: 'Created document metadata including ID, title, and URL',
properties: {
documentId: { type: 'string', description: 'Google Docs document ID' },
title: { type: 'string', description: 'Document title' },
mimeType: { type: 'string', description: 'Document MIME type' },
url: { type: 'string', description: 'Document URL' },
},
},
},
}