Zapier Integration

Copyimport { version as platformVersion } from 'zapier-platform-core';
import authentication from './authentication';
import { includeApiKey, handleBadResponses } from './middleware';
import addMemory from './creates/add_memory';
import deleteMemory from './creates/delete_memory';
import searchMemories from './searches/search_memories';
import getMemories from './searches/get_memories';
import pkg from '../package.json';
 
const app = {
	version: pkg.version,
	platformVersion,

Copy	authentication,
 
	beforeRequest: [includeApiKey],
	afterResponse: [handleBadResponses],
 
	creates: {
		[addMemory.key]: addMemory,
		[deleteMemory.key]: deleteMemory,
	},
 
	searches: {
		[searchMemories.key]: searchMemories,
		[getMemories.key]: getMemories,
	},
 
	resources: {},
	triggers: {},
};
 
export = app;

Copy// Custom (API key) authentication for Mem0.
// The key is sent as "Authorization: Token <apiKey>" (matches Mem0's SDKs).
const test = (z: ZObject, _bundle: Bundle) => z.request({ url: '/v1/ping/', method: 'GET' });
 
export default {
	type: 'custom',
	test,

Copyfields: [
	{
		key: 'apiKey',
		label: 'Mem0 API Key',
		// `password` so Zapier masks the key in the connection UI (it is a secret).
		type: 'password',
		required: true,
		helpText:
			'Your Mem0 API key (starts with `m0-`). Create one at [app.mem0.ai](https://app.mem0.ai) → Settings → API Keys.',
	},
	{
		key: 'baseUrl',
		label: 'Base URL',
		type: 'string',
		required: false,
		default: 'https://api.mem0.ai',
		helpText: 'Override only for self-hosted or non-default deployments.',
	},
],

Copyexport const includeApiKey = (
	request: MutableRequest,
	_z: ZObject,
	bundle: Bundle,
): MutableRequest => {
	if (bundle.authData && bundle.authData.apiKey) {
		request.headers = request.headers || {};
		request.headers.Authorization = `Token ${bundle.authData.apiKey}`;
	}
	// Resolve relative URLs against the configured base URL.
	if (request.url && request.url.startsWith('/')) {
		const base = (bundle.authData && bundle.authData.baseUrl) || 'https://api.mem0.ai';
		request.url = `${base.replace(/\/$/, '')}${request.url}`;
	}
	return request;
};

Copyexport const handleBadResponses = (
	response: ZResponse,
	z: ZObject,
	_bundle: Bundle,
): ZResponse => {
	if (response.status === 401 || response.status === 403) {
		throw new z.errors.Error(
			'The Mem0 API key you supplied is invalid or lacks access.',
			'AuthenticationError',
			response.status,
		);
	}
	if (response.status >= 400) {
		const data = (response.data as Record<string, unknown>) || {};
		const raw =
			data.detail || data.error || data.message || response.content || 'unknown error';
		// DRF sometimes returns detail as an object/array; stringify so the
		// thrown message never renders as "[object Object]".
		const detail = typeof raw === 'string' ? raw : JSON.stringify(raw);
		throw new z.errors.Error(
			`Mem0 API request failed (HTTP ${response.status}): ${detail}`,
			'Mem0ApiError',
			response.status,
		);
	}
	return response;
};

Copyconst perform = async (z: ZObject, bundle: Bundle): Promise<AddResponse | EventResponse> => {
	// Zapier boolean fields can arrive as the strings 'true'/'false'; coerce
	// explicitly so "Infer = No" / "Wait = No" are honored.
	const infer = String(bundle.inputData.infer) !== 'false';
	// Waiting is opt-in (the poll path can exceed Zapier's step timeout).
	const wait = String(bundle.inputData.waitForCompletion) === 'true';
 
	const body: Record<string, unknown> = {
		messages: [{ role: bundle.inputData.role || 'user', content: bundle.inputData.content }],
		infer,
		// Attribution is recorded server-side by Mem0 from this source tag.
		source: 'ZAPIER',
	};
	if (bundle.inputData.user_id) body.user_id = bundle.inputData.user_id;
	if (bundle.inputData.agent_id) body.agent_id = bundle.inputData.agent_id;
	if (bundle.inputData.run_id) body.run_id = bundle.inputData.run_id;
	if (bundle.inputData.metadata) {
		try {
			body.metadata =
				typeof bundle.inputData.metadata === 'string'
					? JSON.parse(bundle.inputData.metadata)
					: bundle.inputData.metadata;
		} catch {
			throw new z.errors.Error('Metadata must be valid JSON.', 'InvalidInput', 400);
		}
	}
	// Custom extraction controls (optional): steer what the API extracts.
	if (bundle.inputData.custom_instructions) {
		body.custom_instructions = bundle.inputData.custom_instructions;
	}
	if (bundle.inputData.custom_categories) {
		try {
			body.custom_categories =
				typeof bundle.inputData.custom_categories === 'string'
					? JSON.parse(bundle.inputData.custom_categories)
					: bundle.inputData.custom_categories;
		} catch {
			throw new z.errors.Error('Custom Categories must be valid JSON.', 'InvalidInput', 400);
		}
	}
	if (bundle.inputData.includes) body.includes = bundle.inputData.includes;
	if (bundle.inputData.excludes) body.excludes = bundle.inputData.excludes;
 

Copyconst pollEvent = async (z: ZObject, eventId: string): Promise<EventResponse> => {
	for (let attempt = 0; attempt < MAX_POLL_ATTEMPTS; attempt++) {
		const res = await z.request({ url: `/v1/event/${eventId}/`, method: 'GET' });
		const data = res.data as EventResponse;
		const status = data && data.status;
		if (status === 'SUCCEEDED') {
			return data;
		}
		if (status === 'FAILED') {
			const reason = (data && (data.error || data.message)) || 'unknown error';
			throw new z.errors.Error(`Mem0 memory event ${eventId} failed: ${reason}`, 'Mem0EventFailed', 400);
		}
		await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
	}
	throw new z.errors.Error(
		`Timed out waiting for memory event ${eventId}. The add was accepted and is ` +
			`likely still completing on the server — a timeout here does not mean it failed.`,
		'Mem0Timeout',
		408,
	);
};

Copyexport default {
	key: 'delete_memory',
	noun: 'Memory',
	display: {
		label: 'Delete Memory',
		description: 'Deletes a memory by its ID.',
	},
	operation: {
		perform,
		inputFields: [{ key: 'memory_id', label: 'Memory ID', type: 'string', required: true }],
		sample: { message: 'Memory deleted successfully' },
	},
};

Copyconst perform = async (z: ZObject, bundle: Bundle) => {
	// Trailing slash required (Django APPEND_SLASH); id encoded so a stray slash can't mistarget the path.
	const response = await z.request({
		url: `/v1/memories/${encodeURIComponent(String(bundle.inputData.memory_id))}/`,
		method: 'DELETE',
	});
	return response.data || { message: 'Deleted', memory_id: bundle.inputData.memory_id };
};

Copyreturn response.data || { message: 'Deleted', memory_id: bundle.inputData.memory_id };

Copyconst perform = async (z: ZObject, bundle: Bundle): Promise<Memory[]> => {
	const body: Record<string, unknown> = {
		query: bundle.inputData.query,
		output_format: 'v1.1',
		top_k: Math.max(1, Math.floor(Number(bundle.inputData.limit) || 50)),
	};
	if (bundle.inputData.user_id) body.filters = { user_id: bundle.inputData.user_id };
 

Copy	const response = await z.request({
		url: '/v3/memories/search/',
		method: 'POST',
		body,
	});
	// Searches must return an array; guard against a null/empty body.
	const data = response.data as Memory[] | { results?: Memory[] } | null;
	return Array.isArray(data) ? data : data?.results ?? [];
};

Copyconst perform = async (z: ZObject, bundle: Bundle): Promise<Memory[]> => {
	const body: Record<string, unknown> = {};
	if (bundle.inputData.user_id) body.filters = { user_id: bundle.inputData.user_id };
 

Copyconst response = await z.request({
	url: '/v3/memories/',
	method: 'POST',
	params: {
		page: Math.max(1, Math.floor(Number(bundle.inputData.page) || 1)),
		page_size: Math.max(1, Math.floor(Number(bundle.inputData.limit) || 50)),
	},
	body,
});