@jclvsh/iris 0.10.0 → 0.15.0

package/dist/cli-utils.d.ts

@@ -9,7 +9,7 @@
  */
 export declare function formatOutput(data: unknown, format?: string): void;
 /**
- * Map an iris error-code prefix to a CLI exit code.
+ * Map a fleet error-code prefix to a CLI exit code.
  *
  * Convention so shell scripts can branch on failure type without parsing stderr:
  * - 0: success (not handled here)
@@ -20,14 +20,14 @@ export declare function formatOutput(data: unknown, format?: string): void;
  * - 5: payment / billing (PAYMENT_*, BILLING_*)
  * - 6: not found (any *_NOT_FOUND)
  *
- * Domain-specific codes (CAMP_001, CONTACT_001, etc.) are categorized by their
+ * Domain-specific codes (e.g. CAMP_001, LAUNCH_001) are categorized by their
  * suffix shape — *_NOT_FOUND maps to 6, others fall through to 1.
  */
 export declare function exitCodeForMessage(message: string): number;
 export declare function handleError(error: unknown): never;
 /**
- * Parse the `[CODE] message (field: x)` string format that IrisClient.handleError
- * builds, recovering the structured fields.
+ * Parse the `[CODE] message (field: x)` string format that the API client's
+ * handleError builds, recovering the structured fields.
  *
  * Returns `{code, message, field?}`. Falls back to `{code: "UNKNOWN_ERROR", message}`
  * when no bracketed code is present (shouldn't happen for API errors, but safe
@@ -42,7 +42,7 @@ export declare function parseErrorMessage(raw: string): {
  * Format an error caught in an MCP tool handler as the structured response
  * the MCP SDK returns to the model.
  *
- * Returns the canonical iris error envelope `{success: false, error: {code, message, field?}}`
+ * Returns the canonical v1 error envelope `{success: false, error: {code, message, field?}}`
  * as JSON text inside the MCP `content` block, plus `isError: true` so the SDK
  * surfaces it as an error to the model. Lets the LLM read `error.code`
  * structurally instead of regexing it out of a flattened message.

package/dist/cli-utils.js

@@ -26,7 +26,7 @@ export function formatOutput(data, format = "json") {
     console.log(JSON.stringify(data, null, 2));
 }
 /**
- * Map an iris error-code prefix to a CLI exit code.
+ * Map a fleet error-code prefix to a CLI exit code.
  *
  * Convention so shell scripts can branch on failure type without parsing stderr:
  * - 0: success (not handled here)
@@ -37,7 +37,7 @@ export function formatOutput(data, format = "json") {
  * - 5: payment / billing (PAYMENT_*, BILLING_*)
  * - 6: not found (any *_NOT_FOUND)
  *
- * Domain-specific codes (CAMP_001, CONTACT_001, etc.) are categorized by their
+ * Domain-specific codes (e.g. CAMP_001, LAUNCH_001) are categorized by their
  * suffix shape — *_NOT_FOUND maps to 6, others fall through to 1.
  */
 export function exitCodeForMessage(message) {
@@ -75,8 +75,8 @@ export function handleError(error) {
     process.exit(exitCodeForMessage(message));
 }
 /**
- * Parse the `[CODE] message (field: x)` string format that IrisClient.handleError
- * builds, recovering the structured fields.
+ * Parse the `[CODE] message (field: x)` string format that the API client's
+ * handleError builds, recovering the structured fields.
  *
  * Returns `{code, message, field?}`. Falls back to `{code: "UNKNOWN_ERROR", message}`
  * when no bracketed code is present (shouldn't happen for API errors, but safe
@@ -97,7 +97,7 @@ export function parseErrorMessage(raw) {
  * Format an error caught in an MCP tool handler as the structured response
  * the MCP SDK returns to the model.
  *
- * Returns the canonical iris error envelope `{success: false, error: {code, message, field?}}`
+ * Returns the canonical v1 error envelope `{success: false, error: {code, message, field?}}`
  * as JSON text inside the MCP `content` block, plus `isError: true` so the SDK
  * surfaces it as an error to the model. Lets the LLM read `error.code`
  * structurally instead of regexing it out of a flattened message.

package/dist/commands/ai.js

@@ -3,11 +3,12 @@ export function registerAICommands(program, client) {
     const ai = program.command("ai").description("AI content generation and analysis");
     ai.command("generate")
         .description("generate AI content (email draft, subject line, etc.)")
-        .requiredOption("-t, --generation-type <type>", "generation type (e.g. email_draft, subject_line)")
+        .requiredOption("-t, --generation-type <type>", "generation type: initial_outreach, follow_up, response_negotiation, meeting_request, or closing")
         .requiredOption("--tone <tone>", "tone (e.g. professional, casual, friendly)")
         .option("--contact-id <id>", "contact ID for personalization")
         .option("--campaign-id <id>", "campaign ID for context")
         .option("--prompt <text>", "free-form prompt context")
+        .option("--format <format>", "email (default) or dm - dm is short platform-native text, empty subject")
         .action(async (opts) => {
         try {
             const body = {
@@ -20,6 +21,8 @@ export function registerAICommands(program, client) {
                 body.campaign_id = opts.campaignId;
             if (opts.prompt)
                 body.prompt = opts.prompt;
+            if (opts.format)
+                body.format = opts.format;
             const result = await client.post("/ai/generate", body);
             formatOutput(result, getFormat(program.opts()));
         }

package/dist/commands/conversations.js

@@ -11,7 +11,7 @@ export function registerConversationCommands(program, client) {
         .option("-s, --page-size <n>", "items per page (max 100)", "50")
         .option("--status <status>", "filter by status")
         .option("--campaign-id <id>", "filter by campaign")
-        .option("--channel <channel>", "filter by channel: email, instagram, twitter")
+        .option("--channel <channel>", "filter by channel: email, instagram, twitter, tiktok")
         .action(async (opts) => {
         try {
             const params = {};
@@ -44,6 +44,44 @@ export function registerConversationCommands(program, client) {
             handleError(error);
         }
     });
+    conversations
+        .command("create")
+        .description("find-or-create the hub conversation for a contact (not tied to a campaign)")
+        .requiredOption("--contact-id <id>", "contact ID to converse with")
+        .action(async (opts) => {
+        try {
+            const result = await client.post("/conversations", { contact_id: opts.contactId });
+            formatOutput(result, getFormat(program.opts()));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    conversations
+        .command("send <id>")
+        .description("create a message in a conversation (status pending_approval routes to the review queue)")
+        .requiredOption("--content <text>", "message content")
+        .requiredOption("--direction <direction>", "inbound or outbound")
+        .requiredOption("--status <status>", "draft, queued, sending, pending_approval, sent, delivered, failed, bounced, or rejected")
+        .requiredOption("--channel <channel>", "email, twitter, instagram, or tiktok (tiktok records only - manual send)")
+        .option("--platform-recipient-id <id>", "platform recipient id (twitter/instagram channels)")
+        .action(async (id, opts) => {
+        try {
+            const body = {
+                content: opts.content,
+                direction: opts.direction,
+                status: opts.status,
+                channel: opts.channel,
+            };
+            if (opts.platformRecipientId)
+                body.platform_recipient_id = opts.platformRecipientId;
+            const result = await client.post(`/conversations/${id}/messages`, body);
+            formatOutput(result, getFormat(program.opts()));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
     conversations
         .command("messages <id>")
         .description("list messages in a conversation")

package/dist/index.js

@@ -16,6 +16,9 @@ import { registerNotificationTools } from "./tools/notifications.js";
 import { registerKeyTools } from "./tools/keys.js";
 import { registerWebhookTools } from "./tools/webhooks.js";
 import { registerAgentCreditTools } from "./tools/agent-credits.js";
+import { registerUsageTools } from "./tools/usage.js";
+import { registerAutopilotTools } from "./tools/autopilot.js";
+import { registerAudienceTools } from "./tools/audiences.js";
 const requireFromHere = createRequire(import.meta.url);
 const pkg = requireFromHere("../package.json");
 const server = new McpServer({
@@ -49,5 +52,8 @@ registerNotificationTools(server, client);
 registerKeyTools(server, client);
 registerWebhookTools(server, client);
 registerAgentCreditTools(server, client);
+registerUsageTools(server, client);
+registerAutopilotTools(server, client);
+registerAudienceTools(server, client);
 const transport = new StdioServerTransport();
 await server.connect(transport);

package/dist/tools/ai.js

@@ -1,14 +1,32 @@
 import { z } from "zod";
 import { formatMcpError } from "../cli-utils.js";
 export function registerAiTools(server, client) {
-    server.tool("generate_content", "generate AI content for a specific contact conversation (email draft, follow-up, reply). requires generate scope.", {
-        contact_id: z.string().uuid().describe("contact ID"),
-        conversation_id: z.string().uuid().describe("conversation ID"),
-        generation_type: z.enum(["initial_email", "follow_up", "reply"]).describe("type of content to generate"),
-        context: z.string().max(2000).optional().describe("additional context for the AI"),
-    }, async (args) => {
+    server.tool("generate_content", "generate AI outreach content (email or DM draft) for a contact/campaign. the contact's tags + enrichment_data feed the generation context automatically. requires generate scope.", {
+        generation_type: z
+            .enum(["initial_outreach", "follow_up", "response_negotiation", "meeting_request", "closing"])
+            .describe("type of content to generate"),
+        tone: z
+            .string()
+            .min(1)
+            .describe("tone (e.g. professional, friendly, casual, formal, persuasive, informative)"),
+        campaign_id: z.string().uuid().optional().describe("campaign to scope the generation to"),
+        contact_id: z
+            .string()
+            .uuid()
+            .optional()
+            .describe("target contact - its tags + enrichment_data are used automatically"),
+        prompt: z.string().optional().describe("additional freeform instructions"),
+        format: z
+            .enum(["email", "dm"])
+            .optional()
+            .describe("dm = short platform-native message text with empty subject. defaults to email"),
+        include_cta: z.boolean().optional().describe("include a clear call-to-action"),
+    }, async ({ include_cta, ...rest }) => {
         try {
-            const result = await client.post("/ai/generate", args);
+            const body = { ...rest };
+            if (include_cta !== undefined)
+                body.input_context = { include_cta };
+            const result = await client.post("/ai/generate", body);
             return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
         }
         catch (error) {
@@ -17,7 +35,10 @@ export function registerAiTools(server, client) {
     });
     server.tool("generate_campaign_content", "generate campaign-level outreach content (email sequence, templates) from a campaign brief. content-first: takes the strategy inline, not a campaign id. requires generate scope.", {
         campaign_name: z.string().min(1).describe("campaign name (used as the brief title)"),
-        objective: z.string().min(1).describe("campaign objective (e.g. 'book DJ gigs', 'sell SaaS to VPs of Eng')"),
+        objective: z
+            .string()
+            .min(1)
+            .describe("campaign objective (e.g. 'book DJ gigs', 'sell SaaS to VPs of Eng')"),
         target_audience: z.string().min(1).describe("target audience description"),
         key_benefits: z.array(z.string().min(1)).min(1).describe("non-empty list of key benefits to emphasise"),
         tone: z.string().min(1).describe("tone (e.g. professional, casual, warm-direct)"),

package/dist/tools/audiences.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { IrisClient } from "../client.js";
+export declare function registerAudienceTools(server: McpServer, client: IrisClient): void;

package/dist/tools/audiences.js

@@ -0,0 +1,99 @@
+import { z } from "zod";
+import { formatMcpError } from "../cli-utils.js";
+const TARGET_PROFILE_TYPES = [
+    "local_business",
+    "content_creator",
+    "influencer",
+    "b2b_professional",
+    "ecommerce",
+    "saas_company",
+    "agency",
+    "freelancer",
+    "other",
+];
+export function registerAudienceTools(server, client) {
+    server.tool("list_audiences", "list the audience library - reusable target profiles created once and attachable to any campaign. requires read scope.", {
+        page: z.number().int().positive().optional().describe("page number (default 1)"),
+        page_size: z.number().int().min(1).max(100).optional().describe("items per page (default 50, max 100)"),
+    }, async ({ page, page_size }) => {
+        try {
+            const params = {};
+            if (page !== undefined)
+                params.page = String(page);
+            if (page_size !== undefined)
+                params.page_size = String(page_size);
+            const result = await client.get("/audiences", params);
+            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (error) {
+            return formatMcpError(error);
+        }
+    });
+    server.tool("create_audience", "create a library audience profile manually. names are unique per library (case-insensitive). requires write scope.", {
+        name: z.string().min(1).max(100).describe("audience name"),
+        profile_type: z.enum(TARGET_PROFILE_TYPES).describe("target profile type"),
+        description: z.string().max(500).optional().describe("who this audience is"),
+        fit_score: z.number().int().min(0).max(100).optional().describe("how well this audience fits (0-100)"),
+        job_titles: z.array(z.string().max(100)).max(10).optional().describe("target job titles"),
+        industries: z.array(z.string().max(100)).max(10).optional().describe("target industries"),
+        pain_points: z.array(z.string().max(100)).max(10).optional().describe("problems they feel"),
+        buying_signals: z.array(z.string().max(100)).max(10).optional().describe("signals they're ready to buy"),
+        discovery_keywords: z
+            .array(z.string().max(100))
+            .max(10)
+            .optional()
+            .describe("keywords for contact discovery"),
+        outreach_angle: z.string().max(500).optional().describe("the hook messages should lead with"),
+    }, async (args) => {
+        try {
+            const body = Object.fromEntries(Object.entries(args).filter(([, value]) => value !== undefined));
+            const result = await client.post("/audiences", body);
+            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (error) {
+            return formatMcpError(error);
+        }
+    });
+    server.tool("generate_audiences", "AI-generate audience profiles from a product (scrape + analysis) into the library. generated names already in the library are skipped, not overwritten. rate limited to 5 per hour. requires generate scope.", {
+        product_name: z.string().min(1).max(200).describe("product name"),
+        product_url: z.string().url().optional().describe("product website - scraped for extra context"),
+        product_description: z.string().max(2000).optional().describe("what it does and who it's for"),
+    }, async (args) => {
+        try {
+            const body = Object.fromEntries(Object.entries(args).filter(([, value]) => value !== undefined));
+            const result = await client.post("/audiences/generate", body);
+            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (error) {
+            return formatMcpError(error);
+        }
+    });
+    server.tool("attach_audience_to_campaign", "copy a library audience into a campaign. the response is the campaign's own copy (a target profile) - editing it never touches the library master. if the campaign already has a same-named profile, the existing copy is returned. requires write scope.", {
+        id: z.string().uuid().describe("audience (library profile) ID"),
+        campaign_id: z
+            .string()
+            .uuid()
+            .describe("campaign to attach to (must be yours and not completed or deleted)"),
+    }, async ({ id, campaign_id }) => {
+        try {
+            const result = await client.post(`/audiences/${id}/attach`, {
+                campaign_id,
+            });
+            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (error) {
+            return formatMcpError(error);
+        }
+    });
+    server.tool("delete_audience", "delete a library audience profile. campaigns it was attached to keep their copy. requires write scope.", {
+        id: z.string().uuid().describe("audience (library profile) ID"),
+    }, async ({ id }) => {
+        try {
+            await client.delete(`/audiences/${id}`);
+            return { content: [{ type: "text", text: `audience ${id} deleted` }] };
+        }
+        catch (error) {
+            return formatMcpError(error);
+        }
+    });
+}

package/dist/tools/autopilot.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { IrisClient } from "../client.js";
+export declare function registerAutopilotTools(server: McpServer, client: IrisClient): void;

package/dist/tools/autopilot.js

@@ -0,0 +1,70 @@
+import { z } from "zod";
+import { formatMcpError } from "../cli-utils.js";
+export function registerAutopilotTools(server, client) {
+    server.tool("get_autopilot_status", "get autopilot status: whether it's configured, the current config, the pending-review count for the standing campaign, and the latest run's step results. requires read scope.", {}, async () => {
+        try {
+            const result = await client.get("/autopilot");
+            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (error) {
+            return formatMcpError(error);
+        }
+    });
+    server.tool("configure_autopilot", "create or update the autopilot config (merge: only the fields you send change; first call creates the config with defaults). autopilot is review-only - drafts wait in the approval queue, nothing sends without approval. requires write scope.", {
+        enabled: z
+            .boolean()
+            .optional()
+            .describe("turn the nightly loop on or off (enabling requires a campaign_id and clears pause state)"),
+        campaign_id: z
+            .string()
+            .uuid()
+            .nullable()
+            .optional()
+            .describe("the ONE standing campaign autopilot tends (draft, scheduled, or active); null to unset"),
+        max_new_contacts_per_run: z
+            .number()
+            .int()
+            .min(10)
+            .max(50)
+            .optional()
+            .describe("discovery batch size per nightly run (default 10)"),
+        max_pending_reviews: z
+            .number()
+            .int()
+            .min(5)
+            .max(200)
+            .optional()
+            .describe("skip discovery while this many drafts sit unreviewed (default 25)"),
+        run_hour: z
+            .number()
+            .int()
+            .min(0)
+            .max(23)
+            .optional()
+            .describe("local hour the nightly run fires (default 2)"),
+        timezone: z
+            .string()
+            .min(1)
+            .max(64)
+            .optional()
+            .describe("IANA timezone for run_hour (default America/New_York)"),
+    }, async (args) => {
+        try {
+            const body = Object.fromEntries(Object.entries(args).filter(([, value]) => value !== undefined));
+            const result = await client.patch("/autopilot", body);
+            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (error) {
+            return formatMcpError(error);
+        }
+    });
+    server.tool("run_autopilot_now", "queue a manual autopilot run immediately (insights refresh + discovery top-up on the standing campaign). steps that already completed today are skipped. rate limited to 2 per hour. requires generate scope.", {}, async () => {
+        try {
+            const result = await client.post("/autopilot/run");
+            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (error) {
+            return formatMcpError(error);
+        }
+    });
+}

package/dist/tools/conversations.js

@@ -1,6 +1,17 @@
 import { z } from "zod";
 import { formatMcpError } from "../cli-utils.js";
 const CONVERSATION_STATUSES = ["active", "completed", "failed", "human_review"];
+const MESSAGE_STATUSES = [
+    "draft",
+    "queued",
+    "sending",
+    "pending_approval",
+    "sent",
+    "delivered",
+    "failed",
+    "bounced",
+    "rejected",
+];
 export function registerConversationTools(server, client) {
     server.tool("list_conversations", "list conversations with optional filtering. requires read scope.", {
         page: z.number().int().positive().optional().describe("page number (default 1)"),
@@ -36,6 +47,39 @@ export function registerConversationTools(server, client) {
             return formatMcpError(error);
         }
     });
+    server.tool("create_conversation", "find-or-create the hub conversation for a contact (not tied to a campaign) - the entry point for starting outreach outside a campaign flow. requires write scope.", {
+        contact_id: z.string().uuid().describe("contact ID to converse with"),
+    }, async ({ contact_id }) => {
+        try {
+            const result = await client.post("/conversations", { contact_id });
+            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (error) {
+            return formatMcpError(error);
+        }
+    });
+    server.tool("create_conversation_message", "create a message in a conversation. status pending_approval places it in the human review queue instead of sending. requires write scope.", {
+        id: z.string().uuid().describe("conversation ID"),
+        content: z.string().min(1).describe("message content"),
+        direction: z.enum(["inbound", "outbound"]).describe("message direction"),
+        status: z.enum(MESSAGE_STATUSES).describe("initial message status"),
+        channel: z.enum(["email", "twitter", "instagram", "tiktok"]).describe("delivery channel (tiktok is manual-send: record only)"),
+        platform_recipient_id: z
+            .string()
+            .optional()
+            .describe("platform recipient id (twitter/instagram channels)"),
+    }, async ({ id, content, direction, status, channel, platform_recipient_id }) => {
+        try {
+            const body = { content, direction, status, channel };
+            if (platform_recipient_id !== undefined)
+                body.platform_recipient_id = platform_recipient_id;
+            const result = await client.post(`/conversations/${id}/messages`, body);
+            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (error) {
+            return formatMcpError(error);
+        }
+    });
     server.tool("get_conversation_messages", "get all messages in a conversation. requires read scope.", {
         id: z.string().uuid().describe("conversation ID"),
     }, async ({ id }) => {

package/dist/tools/keys.js

@@ -41,9 +41,9 @@ export function registerKeyTools(server, client) {
         scopes: z
             .array(z.enum(SCOPES_WITH_WILDCARD))
             .min(1, "scopes must be a non-empty array; omit the field for all scopes")
-            .refine((s) => !s.includes("*") || s.length === 1, "wildcard scope \"*\" must be the only element; mixing it with named scopes is rejected to prevent accidental privilege escalation")
+            .refine((s) => !s.includes("*") || s.length === 1, 'wildcard scope "*" must be the only element; mixing it with named scopes is rejected to prevent accidental privilege escalation')
             .optional()
-            .describe("permission scopes — any subset of [read, write, generate, send, admin], or [\"*\"] for all. omit the field for all scopes. empty array and mixed wildcard (e.g. [\"read\", \"*\"]) are rejected with 422."),
+            .describe('permission scopes — any subset of [read, write, generate, send, admin], or ["*"] for all. omit the field for all scopes. empty array and mixed wildcard (e.g. ["read", "*"]) are rejected with 422.'),
         expires_at: z.string().optional().describe("expiration date in ISO 8601 format (must be in the future)"),
     }, async (args) => {
         try {

package/dist/tools/usage.d.ts

@@ -0,0 +1,7 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { IrisClient } from "../client.js";
+/**
+ * Unified plan-usage tool: current plan, quota usage, and billing period in
+ * one call (the campaign envelope plus per-campaign contact/message limits).
+ */
+export declare function registerUsageTools(server: McpServer, client: IrisClient): void;

package/dist/tools/usage.js

@@ -0,0 +1,16 @@
+import { formatMcpError } from "../cli-utils.js";
+/**
+ * Unified plan-usage tool: current plan, quota usage, and billing period in
+ * one call (the campaign envelope plus per-campaign contact/message limits).
+ */
+export function registerUsageTools(server, client) {
+    server.tool("get_usage", "get your current plan, quota usage (campaigns used/remaining this period), and billing period (requires read scope)", {}, async () => {
+        try {
+            const result = await client.get("/usage");
+            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (error) {
+            return formatMcpError(error);
+        }
+    });
+}

package/dist/types.d.ts

@@ -249,3 +249,54 @@ export interface WebhookDelivery {
     response_body: string | null;
     created_at: string;
 }
+export interface AutopilotConfig {
+    enabled: boolean;
+    campaign_id: string | null;
+    max_new_contacts_per_run: number;
+    max_pending_reviews: number;
+    run_hour: number;
+    timezone: string;
+    paused: boolean;
+    pause_reason: string | null;
+    created_at: string;
+    updated_at: string;
+}
+export interface AutopilotStatus {
+    configured: boolean;
+    config: AutopilotConfig | null;
+    pending_reviews: number;
+    last_run: {
+        run_date: string;
+        steps: Array<{
+            step: string;
+            status: string;
+        }>;
+    } | null;
+}
+export interface AutopilotRunQueued {
+    queued: boolean;
+    run_date: string;
+}
+/**
+ * Library (audience) profile — a reusable target profile owned by the user,
+ * not scoped to a campaign. Attaching copies it into a campaign, and the
+ * attach response is a TargetProfile (the campaign's own copy).
+ */
+export interface AudienceProfile {
+    id: string;
+    name: string;
+    description: string | null;
+    profile_type: string;
+    fit_score: number | null;
+    job_titles: string[];
+    industries: string[];
+    company_sizes: string[];
+    pain_points: string[];
+    buying_signals: string[];
+    discovery_sources: string[];
+    discovery_keywords: string[];
+    outreach_angle: string | null;
+    contacts_discovered: number;
+    created_at: string;
+    updated_at: string;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@jclvsh/iris",
-	"version": "0.10.0",
+	"version": "0.15.0",
 	"description": "MCP server for the Iris API",
 	"type": "module",
 	"main": "dist/index.js",
@@ -15,6 +15,7 @@
 	],
 	"scripts": {
 		"build": "tsc",
+		"prepublishOnly": "npm run build",
 		"start": "node dist/index.js"
 	},
 	"dependencies": {