@openpets/quo 1.0.0

package/index.ts

@@ -0,0 +1,72 @@
+import { config as loadDotenv } from "dotenv"
+import { z, createPlugin, type ToolDefinition, createLogger, loadEnv } from "openpets-sdk"
+import openAPITools from "./openapi-tools"
+
+loadDotenv()
+
+const AUTH_ENV_VARS = ["QUO_API_KEY"]
+
+export const QuoPlugin = async () => {
+  const logger = createLogger("quo")
+  const env = loadEnv("quo") as Record<string, string | undefined>
+  const requiresAuth = true
+
+  const missingAuthVars = AUTH_ENV_VARS.filter((name) => {
+    const value = env[name] ?? process.env[name]
+    return !value
+  })
+
+  const isConfigured = !requiresAuth || missingAuthVars.length === 0
+
+  const testConnectionTool: ToolDefinition = {
+    name: "quo-test-connection",
+    description: "Test Quo configuration and generated OpenAPI tool availability",
+    schema: z.object({}),
+    async execute() {
+      if (!isConfigured) {
+        return JSON.stringify({
+          success: false,
+          status: "not_configured",
+          message: "Quo plugin is not configured. Set the required authentication environment variables.",
+          details: {
+            missingVariables: missingAuthVars,
+            requiredVariables: AUTH_ENV_VARS
+          }
+        }, null, 2)
+      }
+
+      return JSON.stringify({
+        success: true,
+        status: "connected",
+        message: "Quo OpenAPI tools loaded successfully",
+        details: {
+          toolCount: generatedTools.length,
+          requiresAuth,
+          configuredAuthVariables: AUTH_ENV_VARS
+        }
+      }, null, 2)
+    }
+  }
+
+  const generatedTools = openAPITools.filter(tool => tool.name !== "quo-test-connection")
+
+  if (!isConfigured) {
+    logger.warn("Quo plugin not configured - returning test-connection tool only", {
+      missingAuthVars
+    })
+    return createPlugin([testConnectionTool])
+  }
+
+  logger.info("Quo plugin configured - loading generated OpenAPI tools", {
+    toolCount: generatedTools.length
+  })
+
+  const tools: ToolDefinition[] = [
+    testConnectionTool,
+    ...generatedTools
+  ]
+
+  return createPlugin(tools)
+}
+
+export default QuoPlugin

package/openapi-client.ts

@@ -0,0 +1,187 @@
+/**
+ * Auto-generated OpenAPI client utilities
+ *
+ * Source: https://openphone-public-api-prod.s3.us-west-2.amazonaws.com/public/openphone-public-api-v1-prod.json
+ * API: OpenPhone Public API v1.0.0
+ *
+ * This file contains reusable client utilities (getBaseUrl, getAuthHeaders, fetchAPI)
+ * that can be imported by custom tools or the generated openapi-tools.ts file.
+ *
+ * DO NOT EDIT MANUALLY - Regenerate with: pets generate-openapi
+ */
+
+// Auth env var: QUO_API_KEY
+
+export function getBaseUrl(): string {
+  const host = process.env.QUO_HOST || "https://api.openphone.com"
+  return host.endsWith('/') ? host.slice(0, -1) : host
+}
+
+function formatApiKey(apiKey: string): string {
+  const prefix = ""
+  return prefix && !apiKey.startsWith(prefix) ? `${prefix}${apiKey}` : apiKey
+}
+
+
+
+export function getAuthHeaders(): Record<string, string> {
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    "Accept": "application/json",
+  }
+
+  const apiKey = process.env.QUO_API_KEY
+  if (apiKey) {
+    headers["Authorization"] = formatApiKey(apiKey)
+  }
+
+  return headers
+}
+
+
+/**
+ * Convert JSON to TOON format (optimized for LLM consumption)
+ * TOON format: https://github.com/toon-format/toon
+ * This function is also exported from openpets-sdk as jsonToToon
+ */
+function jsonToToon(data: any, indent: string = ""): string {
+  if (data === null) return "null"
+  if (data === undefined) return "undefined"
+
+  const type = typeof data
+
+  if (type === "string") return data
+  if (type === "number" || type === "boolean") return String(data)
+
+  if (Array.isArray(data)) {
+    if (data.length === 0) return "[]"
+
+    const items = data.map((item, index) => {
+      const converted = jsonToToon(item, indent + "  ")
+      if (typeof item === "object" && item !== null) {
+        return `${indent}[${index}]\n${converted}`
+      }
+      return `${indent}[${index}] ${converted}`
+    })
+
+    return items.join("\n")
+  }
+
+  if (type === "object") {
+    const entries = Object.entries(data)
+    if (entries.length === 0) return "{}"
+
+    const lines = entries.map(([key, value]) => {
+      const converted = jsonToToon(value, indent + "  ")
+      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        return `${indent}${key}:\n${converted}`
+      } else if (Array.isArray(value) && value.length > 0 && typeof value[0] === "object") {
+        return `${indent}${key}:\n${converted}`
+      }
+      return `${indent}${key}: ${converted}`
+    })
+
+    return lines.join("\n")
+  }
+
+  return String(data)
+}
+
+
+type DebugContext = {
+  debug?: boolean
+  debugLog?: (stage: string, details?: Record<string, any>) => void
+}
+
+function redactHeaders(headers: Record<string, string>): Record<string, string> {
+  const redacted: Record<string, string> = {}
+  for (const [key, value] of Object.entries(headers)) {
+    redacted[key] = /authorization|api[-_]?key|token|secret/i.test(key)
+      ? "[redacted]"
+      : value
+  }
+  return redacted
+}
+
+function previewBody(body: string, maxChars: number = 20000): string {
+  if (body.length <= maxChars) return body
+  return `${body.slice(0, maxChars)}... [truncated]`
+}
+
+function emitDebug(context: DebugContext | undefined, stage: string, details: Record<string, any>) {
+  if (context?.debug !== true) return
+  if (typeof context.debugLog === "function") {
+    context.debugLog(stage, details)
+    return
+  }
+  console.error(`[openapi debug] ${stage} ${JSON.stringify(details)}`)
+}
+
+export async function fetchAPI(url: string, options: RequestInit, context?: DebugContext): Promise<string> {
+  const responseFormat = "toon"
+  const startedAt = Date.now()
+  try {
+    const authHeaders = getAuthHeaders()
+    const mergedHeaders = { ...authHeaders, ...(options.headers as Record<string, string> || {}) }
+
+    emitDebug(context, "openapi api request", {
+      method: options.method || "GET",
+      url,
+      headers: redactHeaders(mergedHeaders),
+      body: typeof options.body === "string" ? previewBody(options.body) : undefined
+    })
+
+    const response = await fetch(url, { ...options, headers: mergedHeaders })
+    const contentType = response.headers.get("content-type")
+    const responseText = await response.text()
+
+    emitDebug(context, "openapi api response", {
+      method: options.method || "GET",
+      url,
+      status: response.status,
+      ok: response.ok,
+      durationMs: Date.now() - startedAt,
+      contentType,
+      body: previewBody(responseText)
+    })
+
+    if (!response.ok) {
+      const errorObj = {
+        success: false,
+        error: `HTTP ${response.status}: ${responseText}`,
+        status: response.status
+      }
+
+      if (responseFormat === "toon") {
+        return jsonToToon(errorObj)
+      }
+      return JSON.stringify(errorObj, null, 2)
+    }
+
+    if (contentType?.includes("application/json")) {
+      const data = responseText.trim().length > 0 ? JSON.parse(responseText) : null
+
+      if (responseFormat === "toon") {
+        return jsonToToon(data)
+      }
+      return JSON.stringify(data, null, 2)
+    }
+
+    const result = { success: true, data: responseText }
+
+    if (responseFormat === "toon") {
+      return jsonToToon(result)
+    }
+    return JSON.stringify(result, null, 2)
+  } catch (error: any) {
+    const errorObj = {
+      success: false,
+      error: error.message
+    }
+
+    if (responseFormat === "toon") {
+      return jsonToToon(errorObj)
+    }
+    return JSON.stringify(errorObj, null, 2)
+  }
+}