@slates/google-people-recipes 1.0.0-rc.1

package/dist/index.cjs

@@ -0,0 +1,479 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_PERSON_FIELDS: () => DEFAULT_PERSON_FIELDS,
+  GOOGLE_PEOPLE_API_BASE_URL: () => GOOGLE_PEOPLE_API_BASE_URL,
+  GooglePeopleClient: () => GooglePeopleClient,
+  READONLY_PERSON_FIELDS: () => READONLY_PERSON_FIELDS,
+  addressSchema: () => addressSchema,
+  biographySchema: () => biographySchema,
+  birthdaySchema: () => birthdaySchema,
+  contactInputSchema: () => contactInputSchema,
+  contactOutputSchema: () => contactOutputSchema,
+  createGooglePeopleClient: () => createGooglePeopleClient,
+  customFieldSchema: () => customFieldSchema,
+  dateFieldSchema: () => dateFieldSchema,
+  emailSchema: () => emailSchema,
+  eventSchema: () => eventSchema,
+  formatContact: () => formatContact,
+  getContactInputSchema: () => getContactInputSchema,
+  getContactRecipe: () => getContactRecipe,
+  googlePeopleApiError: () => googlePeopleApiError,
+  googlePeopleReadonlyScopes: () => googlePeopleReadonlyScopes,
+  googlePeopleScopes: () => googlePeopleScopes,
+  googlePeopleServiceError: () => googlePeopleServiceError,
+  listContactsInputSchema: () => listContactsInputSchema,
+  listContactsOutputSchema: () => listContactsOutputSchema,
+  listContactsRecipe: () => listContactsRecipe,
+  membershipSchema: () => membershipSchema,
+  nameSchema: () => nameSchema,
+  nicknameSchema: () => nicknameSchema,
+  occupationSchema: () => occupationSchema,
+  organizationSchema: () => organizationSchema,
+  phoneSchema: () => phoneSchema,
+  relationSchema: () => relationSchema,
+  searchContactsInputSchema: () => searchContactsInputSchema,
+  searchContactsOutputSchema: () => searchContactsOutputSchema,
+  searchContactsRecipe: () => searchContactsRecipe,
+  urlSchema: () => urlSchema
+});
+module.exports = __toCommonJS(index_exports);
+var import_error = require("@lowerdeck/error");
+var import_tool_recipes = require("@slates/tool-recipes");
+var import_slates = require("slates");
+var import_zod = require("zod");
+var GOOGLE_PEOPLE_API_BASE_URL = "https://people.googleapis.com/v1/";
+var peopleAxios = (0, import_slates.createAxios)({
+  baseURL: GOOGLE_PEOPLE_API_BASE_URL
+});
+var googlePeopleScopes = {
+  contactsReadonly: "https://www.googleapis.com/auth/contacts.readonly"
+};
+var googlePeopleReadonlyScopes = (0, import_slates.anyOf)(googlePeopleScopes.contactsReadonly);
+var DEFAULT_PERSON_FIELDS = "names,emailAddresses,phoneNumbers,addresses,organizations,birthdays,urls,biographies,events,genders,occupations,nicknames,relations,userDefined,memberships";
+var READONLY_PERSON_FIELDS = "names,emailAddresses,phoneNumbers";
+var nameSchema = import_zod.z.object({
+  displayName: import_zod.z.string().optional().describe("Full display name"),
+  givenName: import_zod.z.string().optional().describe("First/given name"),
+  familyName: import_zod.z.string().optional().describe("Last/family name"),
+  middleName: import_zod.z.string().optional().describe("Middle name"),
+  prefix: import_zod.z.string().optional().describe("Name prefix (e.g., Mr., Dr.)"),
+  suffix: import_zod.z.string().optional().describe("Name suffix (e.g., Jr., III)")
+}).describe("Name of the contact");
+var emailSchema = import_zod.z.object({
+  value: import_zod.z.string().describe("Email address"),
+  type: import_zod.z.string().optional().describe("Type of email (e.g., home, work, other)")
+}).describe("Email address");
+var phoneSchema = import_zod.z.object({
+  value: import_zod.z.string().describe("Phone number"),
+  type: import_zod.z.string().optional().describe("Type of phone (e.g., home, work, mobile)")
+}).describe("Phone number");
+var addressSchema = import_zod.z.object({
+  streetAddress: import_zod.z.string().optional().describe("Street address"),
+  city: import_zod.z.string().optional().describe("City"),
+  region: import_zod.z.string().optional().describe("State or region"),
+  postalCode: import_zod.z.string().optional().describe("Postal/ZIP code"),
+  country: import_zod.z.string().optional().describe("Country"),
+  type: import_zod.z.string().optional().describe("Type of address (e.g., home, work)")
+}).describe("Physical address");
+var organizationSchema = import_zod.z.object({
+  name: import_zod.z.string().optional().describe("Organization name"),
+  title: import_zod.z.string().optional().describe("Job title"),
+  department: import_zod.z.string().optional().describe("Department name")
+}).describe("Organization/company");
+var dateFieldSchema = import_zod.z.object({
+  year: import_zod.z.number().optional().describe("Year (omit for recurring events)"),
+  month: import_zod.z.number().optional().describe("Month (1-12)"),
+  day: import_zod.z.number().optional().describe("Day of month (1-31)")
+}).describe("Date");
+var birthdaySchema = import_zod.z.object({
+  date: dateFieldSchema.optional()
+}).describe("Birthday");
+var urlSchema = import_zod.z.object({
+  value: import_zod.z.string().describe("URL"),
+  type: import_zod.z.string().optional().describe("Type of URL (e.g., homePage, blog, profile)")
+}).describe("URL");
+var biographySchema = import_zod.z.object({
+  value: import_zod.z.string().describe("Biography or notes text")
+}).describe("Biography/notes");
+var customFieldSchema = import_zod.z.object({
+  key: import_zod.z.string().describe("Custom field label"),
+  value: import_zod.z.string().describe("Custom field value")
+}).describe("Custom field");
+var nicknameSchema = import_zod.z.object({
+  value: import_zod.z.string().describe("Nickname")
+}).describe("Nickname");
+var relationSchema = import_zod.z.object({
+  person: import_zod.z.string().describe("Name of the related person"),
+  type: import_zod.z.string().optional().describe("Relationship type (e.g., spouse, parent, child, friend)")
+}).describe("Relationship");
+var eventSchema = import_zod.z.object({
+  date: dateFieldSchema.optional(),
+  type: import_zod.z.string().optional().describe("Type of event (e.g., anniversary)")
+}).describe("Event/date");
+var occupationSchema = import_zod.z.object({
+  value: import_zod.z.string().describe("Occupation")
+}).describe("Occupation");
+var membershipSchema = import_zod.z.object({
+  contactGroupResourceName: import_zod.z.string().optional().describe("Resource name of the contact group")
+}).describe("Group membership");
+var contactInputSchema = import_zod.z.object({
+  names: import_zod.z.array(nameSchema).optional().describe("Names for the contact"),
+  emailAddresses: import_zod.z.array(emailSchema).optional().describe("Email addresses"),
+  phoneNumbers: import_zod.z.array(phoneSchema).optional().describe("Phone numbers"),
+  addresses: import_zod.z.array(addressSchema).optional().describe("Physical addresses"),
+  organizations: import_zod.z.array(organizationSchema).optional().describe("Organizations/companies"),
+  birthdays: import_zod.z.array(birthdaySchema).optional().describe("Birthdays"),
+  urls: import_zod.z.array(urlSchema).optional().describe("URLs"),
+  biographies: import_zod.z.array(biographySchema).optional().describe("Biographies/notes"),
+  userDefined: import_zod.z.array(customFieldSchema).optional().describe("Custom fields"),
+  nicknames: import_zod.z.array(nicknameSchema).optional().describe("Nicknames"),
+  relations: import_zod.z.array(relationSchema).optional().describe("Relationships"),
+  events: import_zod.z.array(eventSchema).optional().describe("Events/dates"),
+  occupations: import_zod.z.array(occupationSchema).optional().describe("Occupations")
+});
+var contactOutputSchema = import_zod.z.object({
+  resourceName: import_zod.z.string().describe("Unique resource name (e.g., people/c12345)"),
+  etag: import_zod.z.string().optional().describe("ETag for concurrency control, required when updating"),
+  names: import_zod.z.array(nameSchema).optional(),
+  emailAddresses: import_zod.z.array(emailSchema).optional(),
+  phoneNumbers: import_zod.z.array(phoneSchema).optional(),
+  addresses: import_zod.z.array(addressSchema).optional(),
+  organizations: import_zod.z.array(organizationSchema).optional(),
+  birthdays: import_zod.z.array(birthdaySchema).optional(),
+  urls: import_zod.z.array(urlSchema).optional(),
+  biographies: import_zod.z.array(biographySchema).optional(),
+  userDefined: import_zod.z.array(customFieldSchema).optional(),
+  nicknames: import_zod.z.array(nicknameSchema).optional(),
+  relations: import_zod.z.array(relationSchema).optional(),
+  events: import_zod.z.array(eventSchema).optional(),
+  occupations: import_zod.z.array(occupationSchema).optional(),
+  memberships: import_zod.z.array(membershipSchema).optional()
+});
+var listContactsInputSchema = import_zod.z.object({
+  pageSize: import_zod.z.number().optional().describe("Number of contacts to return per page (max 1000, default 100)"),
+  pageToken: import_zod.z.string().optional().describe("Token for fetching the next page of results"),
+  sortOrder: import_zod.z.enum([
+    "LAST_MODIFIED_ASCENDING",
+    "LAST_MODIFIED_DESCENDING",
+    "FIRST_NAME_ASCENDING",
+    "LAST_NAME_ASCENDING"
+  ]).optional().describe("Sort order for the results")
+});
+var listContactsOutputSchema = import_zod.z.object({
+  contacts: import_zod.z.array(contactOutputSchema).describe("List of contacts"),
+  nextPageToken: import_zod.z.string().optional().describe("Token for fetching the next page"),
+  totalPeople: import_zod.z.number().optional().describe("Total number of contacts"),
+  totalItems: import_zod.z.number().optional().describe("Total number of items in response")
+});
+var searchContactsInputSchema = import_zod.z.object({
+  query: import_zod.z.string().describe(
+    "Search query \u2014 matches against names, emails, phone numbers, and other contact fields"
+  ),
+  pageSize: import_zod.z.number().optional().describe("Maximum number of results to return (default 30)")
+});
+var searchContactsOutputSchema = import_zod.z.object({
+  contacts: import_zod.z.array(contactOutputSchema).describe("Matching contacts")
+});
+var getContactInputSchema = import_zod.z.object({
+  resourceName: import_zod.z.string().describe('Resource name of the contact (e.g., "people/c12345" or "people/me")')
+});
+var formatContact = (person) => {
+  return {
+    resourceName: person.resourceName,
+    etag: person.etag,
+    names: person.names,
+    emailAddresses: person.emailAddresses,
+    phoneNumbers: person.phoneNumbers,
+    addresses: person.addresses,
+    organizations: person.organizations,
+    birthdays: person.birthdays,
+    urls: person.urls,
+    biographies: person.biographies,
+    userDefined: person.userDefined,
+    nicknames: person.nicknames,
+    relations: person.relations,
+    events: person.events,
+    occupations: person.occupations,
+    memberships: person.memberships?.map((membership) => ({
+      contactGroupResourceName: membership.contactGroupMembership?.contactGroupResourceName
+    }))
+  };
+};
+var isRecord = (value) => typeof value === "object" && value !== null;
+var addMessage = (messages, value) => {
+  if (typeof value !== "string") return;
+  let trimmed = value.trim();
+  if (trimmed && !messages.includes(trimmed)) {
+    messages.push(trimmed);
+  }
+};
+var collectMessages = (value, messages) => {
+  if (!isRecord(value)) {
+    addMessage(messages, value);
+    return;
+  }
+  for (let key of ["message", "error_description", "error", "detail", "reason"]) {
+    addMessage(messages, value[key]);
+  }
+  let nestedError = value.error;
+  if (isRecord(nestedError)) {
+    collectMessages(nestedError, messages);
+  }
+  let errors = value.errors;
+  if (Array.isArray(errors)) {
+    for (let item of errors) {
+      collectMessages(item, messages);
+    }
+  }
+};
+var extractGooglePeopleMessage = (error) => {
+  let response = isRecord(error) ? error.response : void 0;
+  let messages = [];
+  collectMessages(response?.data, messages);
+  if (isRecord(error)) {
+    collectMessages(error.data, messages);
+  }
+  if (messages.length > 0) {
+    return messages.join(" - ");
+  }
+  if (error instanceof Error && error.message) {
+    return error.message;
+  }
+  return "Unknown error";
+};
+var getErrorStatus = (error) => {
+  if (!isRecord(error)) return void 0;
+  let response = error.response;
+  if (typeof response?.status === "number") return response.status;
+  if (typeof error.status === "number") return error.status;
+  if (isRecord(error.data) && typeof error.data.status === "number") return error.data.status;
+  if (isRecord(error.upstream) && typeof error.upstream.status === "number") {
+    return error.upstream.status;
+  }
+  return void 0;
+};
+var getErrorStatusText = (error) => {
+  if (!isRecord(error)) return void 0;
+  let response = error.response;
+  if (typeof response?.statusText === "string") return response.statusText;
+  if (isRecord(error.upstream) && typeof error.upstream.statusText === "string") {
+    return error.upstream.statusText;
+  }
+  return void 0;
+};
+var googlePeopleServiceError = (message) => new import_error.ServiceError((0, import_error.badRequestError)({ message }));
+var googlePeopleApiError = (error, operation = "request") => {
+  if (error instanceof import_error.ServiceError) {
+    return error;
+  }
+  let status = getErrorStatus(error);
+  let statusText = getErrorStatusText(error);
+  let statusLabel = status !== void 0 ? `HTTP ${status}${statusText ? ` ${statusText}` : ""}: ` : "";
+  let serviceError = googlePeopleServiceError(
+    `Google People API ${operation} failed: ${statusLabel}${extractGooglePeopleMessage(error)}`
+  );
+  serviceError.data.reason = "google_people_api_error";
+  serviceError.data.upstreamStatus = status;
+  if (error instanceof Error) {
+    serviceError.setParent(error);
+  }
+  return serviceError;
+};
+var GooglePeopleClient = class {
+  constructor(config) {
+    this.config = config;
+    this.api = config.api ?? peopleAxios;
+  }
+  config;
+  api;
+  headers() {
+    return {
+      Authorization: `Bearer ${this.config.token}`
+    };
+  }
+  async getContact(resourceName, personFields) {
+    try {
+      let response = await this.api.get(resourceName, {
+        params: { personFields: personFields || DEFAULT_PERSON_FIELDS },
+        headers: this.headers()
+      });
+      return response.data;
+    } catch (error) {
+      throw googlePeopleApiError(error, "get contact");
+    }
+  }
+  async listContacts(params) {
+    try {
+      let response = await this.api.get("people/me/connections", {
+        params: {
+          personFields: params.personFields || DEFAULT_PERSON_FIELDS,
+          pageSize: params.pageSize || 100,
+          pageToken: params.pageToken,
+          sortOrder: params.sortOrder,
+          syncToken: params.syncToken,
+          requestSyncToken: params.requestSyncToken
+        },
+        headers: this.headers()
+      });
+      return response.data;
+    } catch (error) {
+      throw googlePeopleApiError(error, "list contacts");
+    }
+  }
+  async searchContacts(query, personFields, pageSize) {
+    try {
+      let response = await this.api.get("people:searchContacts", {
+        params: {
+          query,
+          readMask: personFields || DEFAULT_PERSON_FIELDS,
+          pageSize: pageSize || 30
+        },
+        headers: this.headers()
+      });
+      return response.data;
+    } catch (error) {
+      throw googlePeopleApiError(error, "search contacts");
+    }
+  }
+};
+var createGooglePeopleClient = (ctx) => new GooglePeopleClient({ token: ctx.auth.token });
+var listContactsRecipe = (0, import_tool_recipes.defineToolRecipe)({
+  name: "List Contacts",
+  key: "list_contacts",
+  description: `Lists the authenticated user's contacts with pagination support. Returns contacts sorted by the specified order. Use the \`pageToken\` from a previous response to fetch the next page.`,
+  tags: {
+    destructive: false,
+    readOnly: true
+  },
+  defaultScopes: googlePeopleReadonlyScopes,
+  inputSchema: listContactsInputSchema,
+  outputSchema: listContactsOutputSchema,
+  handleInvocation: async ({
+    ctx,
+    dependencies
+  }) => {
+    let client = dependencies.createClient(ctx);
+    let result = await client.listContacts({
+      pageSize: ctx.input.pageSize,
+      pageToken: ctx.input.pageToken,
+      sortOrder: ctx.input.sortOrder
+    });
+    let contacts = (result.connections || []).map(formatContact);
+    return {
+      output: {
+        contacts,
+        nextPageToken: result.nextPageToken,
+        totalPeople: result.totalPeople,
+        totalItems: result.totalItems
+      },
+      message: `Listed **${contacts.length}** contacts${result.totalPeople ? ` out of ${result.totalPeople} total` : ""}.${result.nextPageToken ? " More pages available." : ""}`
+    };
+  }
+});
+var searchContactsRecipe = (0, import_tool_recipes.defineToolRecipe)({
+  name: "Search Contacts",
+  key: "search_contacts",
+  description: `Searches the authenticated user's contacts by name, email address, phone number, or other fields. Returns matching contacts ranked by relevance.`,
+  tags: {
+    destructive: false,
+    readOnly: true
+  },
+  defaultScopes: googlePeopleReadonlyScopes,
+  inputSchema: searchContactsInputSchema,
+  outputSchema: searchContactsOutputSchema,
+  handleInvocation: async ({
+    ctx,
+    dependencies
+  }) => {
+    let client = dependencies.createClient(ctx);
+    let result = await client.searchContacts(ctx.input.query, void 0, ctx.input.pageSize);
+    let contacts = (result.results || []).map((item) => formatContact(item.person));
+    return {
+      output: { contacts },
+      message: `Found **${contacts.length}** contacts matching "${ctx.input.query}".`
+    };
+  }
+});
+var getContactRecipe = (0, import_tool_recipes.defineToolRecipe)({
+  name: "Get Contact",
+  key: "get_contact",
+  description: `Retrieves detailed information about a specific contact by their resource name. Use \`people/me\` to get the authenticated user's profile. Returns all available contact fields.`,
+  tags: {
+    destructive: false,
+    readOnly: true
+  },
+  defaultScopes: googlePeopleReadonlyScopes,
+  inputSchema: getContactInputSchema,
+  outputSchema: contactOutputSchema,
+  handleInvocation: async ({
+    ctx,
+    dependencies
+  }) => {
+    let client = dependencies.createClient(ctx);
+    let result = await client.getContact(ctx.input.resourceName);
+    let contact = formatContact(result);
+    let displayName = contact.names?.[0]?.displayName || contact.emailAddresses?.[0]?.value || ctx.input.resourceName;
+    return {
+      output: contact,
+      message: `Retrieved contact **${displayName}**.`
+    };
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_PERSON_FIELDS,
+  GOOGLE_PEOPLE_API_BASE_URL,
+  GooglePeopleClient,
+  READONLY_PERSON_FIELDS,
+  addressSchema,
+  biographySchema,
+  birthdaySchema,
+  contactInputSchema,
+  contactOutputSchema,
+  createGooglePeopleClient,
+  customFieldSchema,
+  dateFieldSchema,
+  emailSchema,
+  eventSchema,
+  formatContact,
+  getContactInputSchema,
+  getContactRecipe,
+  googlePeopleApiError,
+  googlePeopleReadonlyScopes,
+  googlePeopleScopes,
+  googlePeopleServiceError,
+  listContactsInputSchema,
+  listContactsOutputSchema,
+  listContactsRecipe,
+  membershipSchema,
+  nameSchema,
+  nicknameSchema,
+  occupationSchema,
+  organizationSchema,
+  phoneSchema,
+  relationSchema,
+  searchContactsInputSchema,
+  searchContactsOutputSchema,
+  searchContactsRecipe,
+  urlSchema
+});