@credal/actions 0.2.196 → 0.2.198

package/dist/actions/parse.js

@@ -1,12 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import Ajv from "ajv";
 import fs from "fs/promises";
 import yaml from "js-yaml";
@@ -70,255 +61,251 @@ z.object({
     userEmail: z.string().optional(),
 })
 `;
-function validateObject(object) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const ajv = new Ajv({
-            strict: true,
-            strictTypes: true,
-            strictTuples: true,
-            strictRequired: true,
-        });
-        // Add custom keyword - just allow it, we'll validate manually
-        ajv.addKeyword("tags");
-        // validate schema and check required fields
-        const validParameters = ajv.validateSchema(object);
-        if (!validParameters) {
-            throw new Error(`Error validating object: ${JSON.stringify(ajv.errors, null, 4)}`);
-        }
-        // Handle oneOf schemas
-        if (object.required && object.properties) {
-            // Handle regular object schemas - check required fields
-            for (const field of object.required) {
-                if (!object.properties[field]) {
-                    throw new Error(`Required field ${field} is missing`);
-                }
+async function validateObject(object) {
+    const ajv = new Ajv({
+        strict: true,
+        strictTypes: true,
+        strictTuples: true,
+        strictRequired: true,
+    });
+    // Add custom keyword - just allow it, we'll validate manually
+    ajv.addKeyword("tags");
+    // validate schema and check required fields
+    const validParameters = ajv.validateSchema(object);
+    if (!validParameters) {
+        throw new Error(`Error validating object: ${JSON.stringify(ajv.errors, null, 4)}`);
+    }
+    // Handle oneOf schemas
+    if (object.required && object.properties) {
+        // Handle regular object schemas - check required fields
+        for (const field of object.required) {
+            if (!object.properties[field]) {
+                throw new Error(`Required field ${field} is missing`);
             }
         }
-        // Validate tags in property schemas using Zod
-        if (object.properties) {
-            for (const [propName, propSchema] of Object.entries(object.properties)) {
-                if (propSchema && typeof propSchema === "object" && "tags" in propSchema) {
-                    const tags = propSchema.tags;
-                    if (tags !== undefined) {
-                        const result = z.array(parameterTagEnum).safeParse(tags);
-                        if (!result.success) {
-                            throw new Error(`Property "${propName}" has invalid tags: ${result.error.errors.map(e => e.message).join(", ")}`);
-                        }
+    }
+    // Validate tags in property schemas using Zod
+    if (object.properties) {
+        for (const [propName, propSchema] of Object.entries(object.properties)) {
+            if (propSchema && typeof propSchema === "object" && "tags" in propSchema) {
+                const tags = propSchema.tags;
+                if (tags !== undefined) {
+                    const result = z.array(parameterTagEnum).safeParse(tags);
+                    if (!result.success) {
+                        throw new Error(`Property "${propName}" has invalid tags: ${result.error.errors.map(e => e.message).join(", ")}`);
                     }
                 }
             }
         }
-    });
+    }
 }
-function addActionTypes(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ file, prefix, action }) {
-        // add parameter types
-        const paramsName = `${prefix}Params`;
-        yield addTypesToFile({
-            file,
-            obj: action.parameters,
-            fallback: "z.object({})",
-            name: paramsName,
-        });
-        // add output types
-        const outputName = `${prefix}Output`;
-        yield addTypesToFile({
-            file,
-            obj: action.output,
-            fallback: "z.void()",
-            name: outputName,
-        });
-        // add function type
-        const functionName = `${prefix}Function`;
-        file.addTypeAlias({
-            name: functionName,
-            type: `ActionFunction<${paramsName}Type, AuthParamsType, ${outputName}Type>`,
-            isExported: true,
-        });
+async function addActionTypes({ file, prefix, action }) {
+    // add parameter types
+    const paramsName = `${prefix}Params`;
+    await addTypesToFile({
+        file,
+        obj: action.parameters,
+        fallback: "z.object({})",
+        name: paramsName,
+    });
+    // add output types
+    const outputName = `${prefix}Output`;
+    await addTypesToFile({
+        file,
+        obj: action.output,
+        fallback: "z.void()",
+        name: outputName,
+    });
+    // add function type
+    const functionName = `${prefix}Function`;
+    file.addTypeAlias({
+        name: functionName,
+        type: `ActionFunction<${paramsName}Type, AuthParamsType, ${outputName}Type>`,
+        isExported: true,
     });
 }
-function addTypesToFile(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ file, obj, fallback, name, }) {
-        // Tool calling framework currently having trouble filling in records as opposed to objects
-        const zodSchema = obj ? convert(obj).replace(/z\.record\(z\.any\(\)\)/g, "z.object({}).catchall(z.any())") : fallback;
-        const zodName = `${name}Schema`;
-        file.addVariableStatement({
-            declarationKind: VariableDeclarationKind.Const,
-            isExported: true,
-            declarations: [
-                {
-                    name: zodName,
-                    initializer: zodSchema,
-                },
-            ],
-        });
-        file.addTypeAlias({
-            name: `${name}Type`,
-            type: `z.infer<typeof ${zodName}>`,
-            isExported: true,
-        });
+async function addTypesToFile({ file, obj, fallback, name, }) {
+    // Tool calling framework currently having trouble filling in records as opposed to objects
+    const zodSchema = obj ? convert(obj).replace(/z\.record\(z\.any\(\)\)/g, "z.object({}).catchall(z.any())") : fallback;
+    const zodName = `${name}Schema`;
+    file.addVariableStatement({
+        declarationKind: VariableDeclarationKind.Const,
+        isExported: true,
+        declarations: [
+            {
+                name: zodName,
+                initializer: zodSchema,
+            },
+        ],
+    });
+    file.addTypeAlias({
+        name: `${name}Type`,
+        type: `z.infer<typeof ${zodName}>`,
+        isExported: true,
     });
 }
-function generateTypes(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ inputPath = "src/actions/schema.yaml", outputPath = "src/actions/autogen/templates.ts", templatesOutputPath = "src/actions/autogen/types.ts", }) {
-        const yamlContent = yield fs.readFile(inputPath, "utf8");
-        const rawConfig = yaml.load(yamlContent);
-        // Validate the config
-        const parsedConfig = configSchema.parse(rawConfig);
-        // Generate the TypeScript file
-        // Initialize ts-morph project
-        const project = new Project();
-        const templatesFile = project.createSourceFile(outputPath, "", { overwrite: true });
-        const typesFile = project.createSourceFile(templatesOutputPath, "", { overwrite: true });
-        // Set the ProviderName enum based on the schema providers
-        typesFile
-            .addEnum({
-            name: "ProviderName",
-            members: Object.keys(parsedConfig.actions).map(providerName => ({
-                name: providerName.toUpperCase().replace(/-/g, "_"),
-                value: providerName,
-            })),
-        })
-            .setIsExported(true);
-        typesFile
-            .addEnum({
-            name: "ActionName",
-            members: Array.from(new Set(Object.values(parsedConfig.actions).flatMap(provider => Object.keys(provider)))).map(actionName => ({
-                name: actionName.toUpperCase().replace(/-/g, "_"),
-                value: actionName,
-            })),
-        })
-            .setIsExported(true);
-        // Add imports
-        templatesFile.addImportDeclaration({
-            moduleSpecifier: "../../actions/parse",
-            namedImports: ["ActionTemplate"],
-        });
-        typesFile.addImportDeclaration({
-            moduleSpecifier: "zod",
-            namedImports: ["z"],
-        });
-        // Initialization: set up generic ActionFunction type
-        typesFile.addTypeAlias({
-            name: "ActionFunction",
-            typeParameters: ["P", "A", "O"],
-            type: "(input: {params: P, authParams: A}) => Promise<O>",
-            isExported: true,
-        });
-        // Initialization: set up authparams zod schema and type
-        typesFile.addVariableStatement({
-            declarationKind: VariableDeclarationKind.Const,
-            isExported: true,
-            declarations: [
-                {
-                    name: "AuthParamsSchema",
-                    initializer: authParamsSchemaStr,
-                },
-            ],
-        });
-        typesFile.addTypeAlias({
-            name: "AuthParamsType",
-            type: "z.infer<typeof AuthParamsSchema>",
-            isExported: true,
-        });
-        // ActionTag enum for action-level tags (using values defined at top of file)
-        typesFile.addVariableStatement({
-            declarationKind: VariableDeclarationKind.Const,
-            isExported: true,
-            declarations: [
-                {
-                    name: "ActionTagSchema",
-                    initializer: `z.enum([${actionTagValues.map(t => `"${t}"`).join(", ")}])`,
-                },
-            ],
-        });
-        typesFile.addTypeAlias({
-            name: "ActionTag",
-            type: "z.infer<typeof ActionTagSchema>",
-            isExported: true,
-        });
-        typesFile.addVariableStatement({
-            declarationKind: VariableDeclarationKind.Const,
-            isExported: true,
-            declarations: [
-                {
-                    name: "ACTION_TAGS",
-                    initializer: `[${actionTagValues.map(t => `"${t}"`).join(", ")}] as const`,
-                },
-            ],
-        });
-        // ParameterTag enum for parameter property tags (using values defined at top of file)
-        typesFile.addVariableStatement({
-            declarationKind: VariableDeclarationKind.Const,
-            isExported: true,
-            declarations: [
-                {
-                    name: "ParameterTagSchema",
-                    initializer: `z.enum([${parameterTagValues.map(t => `"${t}"`).join(", ")}])`,
-                },
-            ],
-        });
-        typesFile.addTypeAlias({
-            name: "ParameterTag",
-            type: "z.infer<typeof ParameterTagSchema>",
-            isExported: true,
-        });
-        typesFile.addVariableStatement({
-            declarationKind: VariableDeclarationKind.Const,
-            isExported: true,
-            declarations: [
-                {
-                    name: "PARAMETER_TAGS",
-                    initializer: `[${parameterTagValues.map(t => `"${t}"`).join(", ")}] as const`,
-                },
-            ],
-        });
-        for (const [categoryName, category] of Object.entries(parsedConfig.actions)) {
-            for (const [actionName, action] of Object.entries(category)) {
-                // Validate action-level tags
-                if (action.tags && action.tags.length > 0) {
-                    const invalidTags = action.tags.filter(tag => !actionTagValues.includes(tag));
-                    if (invalidTags.length > 0) {
-                        throw new Error(`Action "${categoryName}.${actionName}" has invalid tag values: ${invalidTags.join(", ")}. Valid values are: ${actionTagValues.join(", ")}`);
-                    }
-                }
-                if (action.parameters) {
-                    yield validateObject(action.parameters);
-                }
-                if (action.output) {
-                    yield validateObject(action.output);
+async function generateTypes({ inputPath = "src/actions/schema.yaml", outputPath = "src/actions/autogen/templates.ts", templatesOutputPath = "src/actions/autogen/types.ts", }) {
+    const yamlContent = await fs.readFile(inputPath, "utf8");
+    const rawConfig = yaml.load(yamlContent);
+    // Validate the config
+    const parsedConfig = configSchema.parse(rawConfig);
+    // Generate the TypeScript file
+    // Initialize ts-morph project
+    const project = new Project();
+    const templatesFile = project.createSourceFile(outputPath, "", { overwrite: true });
+    const typesFile = project.createSourceFile(templatesOutputPath, "", { overwrite: true });
+    // Set the ProviderName enum based on the schema providers
+    typesFile
+        .addEnum({
+        name: "ProviderName",
+        members: Object.keys(parsedConfig.actions).map(providerName => ({
+            name: providerName.toUpperCase().replace(/-/g, "_"),
+            value: providerName,
+        })),
+    })
+        .setIsExported(true);
+    typesFile
+        .addEnum({
+        name: "ActionName",
+        members: Array.from(new Set(Object.values(parsedConfig.actions).flatMap(provider => Object.keys(provider)))).map(actionName => ({
+            name: actionName.toUpperCase().replace(/-/g, "_"),
+            value: actionName,
+        })),
+    })
+        .setIsExported(true);
+    // Add imports
+    templatesFile.addImportDeclaration({
+        moduleSpecifier: "../../actions/parse",
+        namedImports: ["ActionTemplate"],
+    });
+    typesFile.addImportDeclaration({
+        moduleSpecifier: "zod",
+        namedImports: ["z"],
+    });
+    // Initialization: set up generic ActionFunction type
+    typesFile.addTypeAlias({
+        name: "ActionFunction",
+        typeParameters: ["P", "A", "O"],
+        type: "(input: {params: P, authParams: A}) => Promise<O>",
+        isExported: true,
+    });
+    // Initialization: set up authparams zod schema and type
+    typesFile.addVariableStatement({
+        declarationKind: VariableDeclarationKind.Const,
+        isExported: true,
+        declarations: [
+            {
+                name: "AuthParamsSchema",
+                initializer: authParamsSchemaStr,
+            },
+        ],
+    });
+    typesFile.addTypeAlias({
+        name: "AuthParamsType",
+        type: "z.infer<typeof AuthParamsSchema>",
+        isExported: true,
+    });
+    // ActionTag enum for action-level tags (using values defined at top of file)
+    typesFile.addVariableStatement({
+        declarationKind: VariableDeclarationKind.Const,
+        isExported: true,
+        declarations: [
+            {
+                name: "ActionTagSchema",
+                initializer: `z.enum([${actionTagValues.map(t => `"${t}"`).join(", ")}])`,
+            },
+        ],
+    });
+    typesFile.addTypeAlias({
+        name: "ActionTag",
+        type: "z.infer<typeof ActionTagSchema>",
+        isExported: true,
+    });
+    typesFile.addVariableStatement({
+        declarationKind: VariableDeclarationKind.Const,
+        isExported: true,
+        declarations: [
+            {
+                name: "ACTION_TAGS",
+                initializer: `[${actionTagValues.map(t => `"${t}"`).join(", ")}] as const`,
+            },
+        ],
+    });
+    // ParameterTag enum for parameter property tags (using values defined at top of file)
+    typesFile.addVariableStatement({
+        declarationKind: VariableDeclarationKind.Const,
+        isExported: true,
+        declarations: [
+            {
+                name: "ParameterTagSchema",
+                initializer: `z.enum([${parameterTagValues.map(t => `"${t}"`).join(", ")}])`,
+            },
+        ],
+    });
+    typesFile.addTypeAlias({
+        name: "ParameterTag",
+        type: "z.infer<typeof ParameterTagSchema>",
+        isExported: true,
+    });
+    typesFile.addVariableStatement({
+        declarationKind: VariableDeclarationKind.Const,
+        isExported: true,
+        declarations: [
+            {
+                name: "PARAMETER_TAGS",
+                initializer: `[${parameterTagValues.map(t => `"${t}"`).join(", ")}] as const`,
+            },
+        ],
+    });
+    for (const [categoryName, category] of Object.entries(parsedConfig.actions)) {
+        for (const [actionName, action] of Object.entries(category)) {
+            // Validate action-level tags
+            if (action.tags && action.tags.length > 0) {
+                const invalidTags = action.tags.filter(tag => !actionTagValues.includes(tag));
+                if (invalidTags.length > 0) {
+                    throw new Error(`Action "${categoryName}.${actionName}" has invalid tag values: ${invalidTags.join(", ")}. Valid values are: ${actionTagValues.join(", ")}`);
                 }
-                const actionPrefix = `${categoryName}${snakeToPascal(actionName)}`;
-                const constName = `${actionPrefix}Definition`;
-                // Convert the action definition to a string representation
-                const templateObj = Object.assign({ provider: categoryName, name: actionName }, action);
-                // Validate the template object
-                const template = actionTemplateSchema.parse(templateObj);
-                // Add the constant declaration
-                const templateStr = JSON.stringify(template, null, 4);
-                templatesFile.addVariableStatement({
-                    declarationKind: VariableDeclarationKind.Const,
-                    isExported: true,
-                    declarations: [
-                        {
-                            name: constName,
-                            type: "ActionTemplate",
-                            initializer: templateStr,
-                        },
-                    ],
-                });
-                // parameter types
-                yield addActionTypes({
-                    file: typesFile,
-                    prefix: actionPrefix,
-                    action,
-                });
             }
+            if (action.parameters) {
+                await validateObject(action.parameters);
+            }
+            if (action.output) {
+                await validateObject(action.output);
+            }
+            const actionPrefix = `${categoryName}${snakeToPascal(actionName)}`;
+            const constName = `${actionPrefix}Definition`;
+            // Convert the action definition to a string representation
+            const templateObj = {
+                provider: categoryName,
+                name: actionName,
+                ...action,
+            };
+            // Validate the template object
+            const template = actionTemplateSchema.parse(templateObj);
+            // Add the constant declaration
+            const templateStr = JSON.stringify(template, null, 4);
+            templatesFile.addVariableStatement({
+                declarationKind: VariableDeclarationKind.Const,
+                isExported: true,
+                declarations: [
+                    {
+                        name: constName,
+                        type: "ActionTemplate",
+                        initializer: templateStr,
+                    },
+                ],
+            });
+            // parameter types
+            await addActionTypes({
+                file: typesFile,
+                prefix: actionPrefix,
+                action,
+            });
         }
-        // Save the generated TypeScript file
-        yield templatesFile.save();
-        yield typesFile.save();
-    });
+    }
+    // Save the generated TypeScript file
+    await templatesFile.save();
+    await typesFile.save();
 }
 generateTypes({}).catch(error => {
     console.error("Error generating types:", error);

package/dist/actions/providers/asana/commentAsanaTask.js

@@ -1,29 +1,22 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { axiosClient } from "../../util/axiosClient.js";
 import { MISSING_AUTH_TOKEN } from "../../util/missingAuthConstants.js";
-const commentAsanaTask = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
-    var _b, _c;
+const commentAsanaTask = async ({ params, authParams, }) => {
     const { authToken } = authParams;
     const { commentText, isPinned, taskId } = params;
     if (!authToken) {
         return { success: false, error: MISSING_AUTH_TOKEN };
     }
     try {
-        const response = yield axiosClient.post(`https://app.asana.com/api/1.0/tasks/${taskId}/stories`, {
-            data: Object.assign({ text: commentText }, (isPinned !== undefined && { is_pinned: isPinned })),
+        const response = await axiosClient.post(`https://app.asana.com/api/1.0/tasks/${taskId}/stories`, {
+            data: {
+                text: commentText,
+                ...(isPinned !== undefined && { is_pinned: isPinned }),
+            },
         }, {
             headers: { Authorization: `Bearer ${authToken}` },
         });
         // Validate response
-        const commentGid = (_c = (_b = response === null || response === void 0 ? void 0 : response.data) === null || _b === void 0 ? void 0 : _b.data) === null || _c === void 0 ? void 0 : _c.gid;
+        const commentGid = response?.data?.data?.gid;
         if (!commentGid) {
             throw new Error("Failed to create task: No valid comment ID returned from Asana");
         }
@@ -39,5 +32,5 @@ const commentAsanaTask = (_a) => __awaiter(void 0, [_a], void 0, function* ({ pa
             error: error instanceof Error ? error.message : "Unknown error",
         };
     }
-});
+};
 export default commentAsanaTask;

package/dist/actions/providers/asana/createAsanaTask.js

@@ -1,19 +1,10 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { axiosClient } from "../../util/axiosClient.js";
 import { MISSING_AUTH_TOKEN } from "../../util/missingAuthConstants.js";
 import { getWorkspaceIdFromProject, getUserIdByEmail } from "./utils.js";
-const getTaskTemplates = (authToken, projectId) => __awaiter(void 0, void 0, void 0, function* () {
+const getTaskTemplates = async (authToken, projectId) => {
     const url = `https://app.asana.com/api/1.0/task_templates/?project=${projectId}`;
     try {
-        const response = yield axiosClient.get(url, {
+        const response = await axiosClient.get(url, {
             headers: { Authorization: `Bearer ${authToken}` },
         });
         return response.data.data;
@@ -22,21 +13,20 @@ const getTaskTemplates = (authToken, projectId) => __awaiter(void 0, void 0, voi
         console.error("Error fetching Asana task templates:", error);
         return [];
     }
-});
-const createAsanaTask = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
-    var _b, _c;
+};
+const createAsanaTask = async ({ params, authParams, }) => {
     const { authToken } = authParams;
     const { name, projectId, description, customFields, taskTemplate, assignee, approvalStatus, dueAt } = params;
     if (!authToken) {
         return { success: false, error: MISSING_AUTH_TOKEN };
     }
-    const workspaceId = yield getWorkspaceIdFromProject(projectId, authToken);
+    const workspaceId = await getWorkspaceIdFromProject(projectId, authToken);
     if (!workspaceId) {
         return { success: false, error: "Project ID invalid: unable to get workspaceID" };
     }
     let assigneeId;
     if (assignee && assignee.includes("@")) {
-        assigneeId = yield getUserIdByEmail(authToken, workspaceId, assignee);
+        assigneeId = await getUserIdByEmail(authToken, workspaceId, assignee);
     }
     else {
         assigneeId = assignee;
@@ -44,7 +34,7 @@ const createAsanaTask = (_a) => __awaiter(void 0, [_a], void 0, function* ({ par
     let templateId = null;
     try {
         if (taskTemplate) {
-            const templates = yield getTaskTemplates(authToken, projectId);
+            const templates = await getTaskTemplates(authToken, projectId);
             if (/^\d+$/.test(taskTemplate)) {
                 // Numeric: try ID match
                 if (templates.some((t) => t.gid === taskTemplate)) {
@@ -66,13 +56,22 @@ const createAsanaTask = (_a) => __awaiter(void 0, [_a], void 0, function* ({ par
                 };
             }
         }
-        const response = yield axiosClient.post(`https://app.asana.com/api/1.0/tasks`, {
-            data: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ name, projects: [projectId] }, (description && { notes: description })), (customFields && { custom_fields: customFields })), (templateId && { task_template: templateId })), (assigneeId && { assignee: assigneeId })), (approvalStatus && { approval_status: approvalStatus })), (dueAt && { due_at: dueAt })),
+        const response = await axiosClient.post(`https://app.asana.com/api/1.0/tasks`, {
+            data: {
+                name,
+                projects: [projectId],
+                ...(description && { notes: description }),
+                ...(customFields && { custom_fields: customFields }),
+                ...(templateId && { task_template: templateId }),
+                ...(assigneeId && { assignee: assigneeId }),
+                ...(approvalStatus && { approval_status: approvalStatus }),
+                ...(dueAt && { due_at: dueAt }),
+            },
         }, {
             headers: { Authorization: `Bearer ${authToken}` },
         });
         // Validate response
-        const taskGid = (_c = (_b = response === null || response === void 0 ? void 0 : response.data) === null || _b === void 0 ? void 0 : _b.data) === null || _c === void 0 ? void 0 : _c.gid;
+        const taskGid = response?.data?.data?.gid;
         if (!taskGid) {
             throw new Error("Failed to create task: No valid task ID returned from Asana");
         }
@@ -88,5 +87,5 @@ const createAsanaTask = (_a) => __awaiter(void 0, [_a], void 0, function* ({ par
             error: error instanceof Error ? error.message : "Unknown error",
         };
     }
-});
+};
 export default createAsanaTask;