terse-types 0.0.3 → 0.0.5

package/dist/ModelEvents.js

@@ -17,11 +17,13 @@ export const changedItemSchema = z.object({
     change_event_type: changeEventTypeSchema
 });
 export const runErrorSchema = z.object({
+    type: z.literal("RunError"),
     error: z.string(),
     code: z.string().optional(),
     timestamp: z.number()
 });
 export const cancelledSchema = z.object({
+    type: z.literal("Cancelled"),
     reason: z.string().optional(),
     timestamp: z.number()
 });
@@ -32,9 +34,11 @@ export const functionCallSchema = z.object({
 });
 export const naturalStopSchema = z.object({
     step_id: z.string(),
+    type: z.literal("NaturalStop"),
     timestamp: z.number()
 });
 export const sendModelRequestSchema = z.object({
+    type: z.literal("SendModelRequest"),
     user_message: z.string(),
     timezone: z.string(),
     ui_state: z.string().optional(),
@@ -43,12 +47,14 @@ export const sendModelRequestSchema = z.object({
 });
 export const toolApprovalResponseSchema = z.object({
     step_id: z.string(),
+    type: z.literal("ToolApprovalResponse"),
     approved: z.boolean(),
     rejection_reason: z.string().optional(),
     timestamp: z.number()
 });
 export const toolApprovalRequestSchema = z.object({
     step_id: z.string(),
+    type: z.literal("ToolApprovalRequest"),
     name: z.string(),
     arguments: z.string(),
     timestamp: z.number()
@@ -56,22 +62,26 @@ export const toolApprovalRequestSchema = z.object({
 export const textDeltaSchema = z.object({
     delta: z.string(),
     step_id: z.string(),
+    type: z.literal("TextDelta"),
     timestamp: z.number()
 });
 export const toolCallGeneratingSchema = z.object({
     tool_name: z.string(),
     step_id: z.string(),
+    type: z.literal("ToolCallGenerating"),
     timestamp: z.number()
 });
 export const toolCallSchema = z.object({
     summary: z.string(),
     step_id: z.string(),
+    type: z.literal("ToolCall"),
     parameters: z.string(),
     integration: z.string(),
     timestamp: z.number()
 });
 export const thinkingSchema = z.object({
     step_id: z.string(),
+    type: z.literal("Thinking"),
     timestamp: z.number()
 });
 export var ToolCallExecutionStatus;
@@ -87,6 +97,7 @@ export const toolCallCompleteSchema = z.object({
     timestamp: z.number(),
     status: toolCallExecutionStatusSchema,
     step_id: z.string(),
+    type: z.literal("ToolCallComplete"),
     changed_items: z.array(changedItemSchema),
     integration: z.string(),
     url: z.string().optional(),
@@ -98,6 +109,7 @@ export const filterResultSchema = z.object({
     reason: z.string(),
     confidence: z.number(),
     step_id: z.string(),
+    type: z.literal("FilterResult"),
     timestamp: z.number()
 });
 export var SandboxStage;
@@ -117,6 +129,7 @@ export const SANDBOX_STAGE_LABELS = {
     [SandboxStage.RUNNING]: "Running agent"
 };
 export const userMessageSchema = z.object({
+    type: z.literal("UserMessage"),
     message: z.string(),
     step_id: z.string(),
     client_turn_id: z.string(),
@@ -126,87 +139,63 @@ export const multipleChoiceOptionSchema = z.object({
     label: z.string(),
     value: z.string()
 });
-export const snippetVariantSchema = z.discriminatedUnion("type", [
-    z.object({
-        type: z.literal("button"),
-        label: z.string(),
-        url: z.string()
-    }),
-    z.object({
-        type: z.literal("integration_prompt"),
-        integration: z.string(),
-        message: z.string(),
-        stateToken: z.string().optional()
-    }),
-    z.object({
-        type: z.literal("navigate"),
-        path: z.string()
-    }),
-    z.object({
-        type: z.literal("multiple_choice"),
-        questionId: z.string(),
-        question: z.string(),
-        options: z.array(multipleChoiceOptionSchema),
-        allowMultiple: z.boolean().optional()
-    }),
-    z.object({
-        type: z.literal("image"),
-        url: z.string()
-    })
-]);
-export const chatSnippetSchema = z.intersection(z.object({
+export const buttonSchema = z.object({
+    type: z.literal("button"),
+    label: z.string(),
+    url: z.string()
+});
+export const integrationPromptSchema = z.object({
+    type: z.literal("integration_prompt"),
+    integration: z.string(),
+    message: z.string(),
+    stateToken: z.string().optional()
+});
+export const navigateSchema = z.object({
+    type: z.literal("navigate"),
+    path: z.string()
+});
+export const multipleChoiceSchema = z.object({
+    type: z.literal("multiple_choice"),
+    questionId: z.string(),
+    question: z.string(),
+    options: z.array(multipleChoiceOptionSchema),
+    allowMultiple: z.boolean().optional()
+});
+export const imageSchema = z.object({
+    type: z.literal("image"),
+    url: z.string()
+});
+export const snippetVariantSchema = z.discriminatedUnion("type", [buttonSchema, integrationPromptSchema, navigateSchema, multipleChoiceSchema, imageSchema]);
+const chatSnippetMetadataSchema = {
     id: z.string().optional(),
     step_id: z.string().optional(),
     selectedValue: z.string().optional()
-}), snippetVariantSchema);
-export const modelEventSchema = z.discriminatedUnion("type", [
-    toolApprovalResponseSchema.extend({
-        type: z.literal("ToolApprovalResponse")
-    }),
-    toolApprovalRequestSchema.extend({
-        type: z.literal("ToolApprovalRequest")
-    }),
-    toolCallGeneratingSchema.extend({
-        type: z.literal("ToolCallGenerating")
-    }),
-    toolCallSchema.extend({
-        type: z.literal("ToolCall")
-    }),
-    toolCallCompleteSchema.extend({
-        type: z.literal("ToolCallComplete")
-    }),
-    textDeltaSchema.extend({
-        type: z.literal("TextDelta")
-    }),
-    runErrorSchema.extend({
-        type: z.literal("RunError")
-    }),
-    cancelledSchema.extend({
-        type: z.literal("Cancelled")
-    }),
-    naturalStopSchema.extend({
-        type: z.literal("NaturalStop")
-    }),
-    filterResultSchema.extend({
-        type: z.literal("FilterResult")
-    }),
-    userMessageSchema.extend({
-        type: z.literal("UserMessage")
-    }),
-    thinkingSchema.extend({
-        type: z.literal("Thinking")
-    }),
-    z.object({
-        type: z.literal("Snippet"),
-        timestamp: z.number(),
-        snippet: chatSnippetSchema
-    })
+};
+export const chatSnippetSchema = z.discriminatedUnion("type", [
+    buttonSchema.extend(chatSnippetMetadataSchema),
+    integrationPromptSchema.extend(chatSnippetMetadataSchema),
+    navigateSchema.extend(chatSnippetMetadataSchema),
+    multipleChoiceSchema.extend(chatSnippetMetadataSchema),
+    imageSchema.extend(chatSnippetMetadataSchema)
 ]);
-export const modelRequestSchema = z.discriminatedUnion("type", [
-    sendModelRequestSchema.extend({
-        type: z.literal("SendModelRequest")
-    }),
-    toolApprovalResponseSchema.extend({
-        type: z.literal("ToolApprovalResponse")
-    })
+export const modelEventChatSnippetSchema = z.object({
+    type: z.literal("Snippet"),
+    timestamp: z.number(),
+    snippet: chatSnippetSchema
+});
+export const modelEventSchema = z.discriminatedUnion("type", [
+    toolApprovalResponseSchema,
+    toolApprovalRequestSchema,
+    toolCallGeneratingSchema,
+    toolCallSchema,
+    toolCallCompleteSchema,
+    textDeltaSchema,
+    runErrorSchema,
+    cancelledSchema,
+    naturalStopSchema,
+    filterResultSchema,
+    userMessageSchema,
+    thinkingSchema,
+    modelEventChatSnippetSchema
 ]);
+export const modelRequestSchema = z.discriminatedUnion("type", [sendModelRequestSchema, toolApprovalResponseSchema]);

package/dist/Notifications.d.ts

@@ -15,16 +15,21 @@ export interface UpdateNotificationSettingsRequest {
     weeklyAgentImprovements: boolean;
     applyToAllAgents?: boolean;
 }
-export declare enum NotificationDestinationType {
-    EMAIL = "email",
-    SLACK = "slack"
-}
+export declare const NotificationDestinationType: {
+    readonly EMAIL: "email";
+    readonly SLACK: "slack";
+};
+export declare const notificationDestinationTypeSchema: z.ZodEnum<{
+    readonly EMAIL: "email";
+    readonly SLACK: "slack";
+}>;
+export type NotificationDestinationType = z.infer<typeof notificationDestinationTypeSchema>;
 export interface EmailNotificationDestination extends NotificationDestination {
-    type: NotificationDestinationType.EMAIL;
+    type: "email";
     email: string;
 }
 export interface SlackNotificationDestination extends NotificationDestination {
-    type: NotificationDestinationType.SLACK;
+    type: "slack";
     integrationId: string;
     slackChannelId?: string;
     slackChannelName?: string;
@@ -32,7 +37,10 @@ export interface SlackNotificationDestination extends NotificationDestination {
     slackUserName?: string;
 }
 export declare const createNotificationDestinationRequestSchema: z.ZodObject<{
-    type: z.ZodEnum<typeof NotificationDestinationType>;
+    type: z.ZodEnum<{
+        readonly EMAIL: "email";
+        readonly SLACK: "slack";
+    }>;
     email: z.ZodOptional<z.ZodEmail>;
     integrationId: z.ZodOptional<z.ZodString>;
     slackChannelId: z.ZodOptional<z.ZodString>;
@@ -43,7 +51,10 @@ export declare const createNotificationDestinationRequestSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type CreateNotificationDestinationRequest = z.infer<typeof createNotificationDestinationRequestSchema>;
 export declare const updateNotificationDestinationRequestSchema: z.ZodObject<{
-    type: z.ZodOptional<z.ZodEnum<typeof NotificationDestinationType>>;
+    type: z.ZodOptional<z.ZodEnum<{
+        readonly EMAIL: "email";
+        readonly SLACK: "slack";
+    }>>;
     email: z.ZodOptional<z.ZodOptional<z.ZodEmail>>;
     integrationId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
     slackChannelId: z.ZodOptional<z.ZodOptional<z.ZodString>>;

package/dist/Notifications.js

@@ -1,11 +1,11 @@
 import { z } from "zod";
-export var NotificationDestinationType;
-(function (NotificationDestinationType) {
-    NotificationDestinationType["EMAIL"] = "email";
-    NotificationDestinationType["SLACK"] = "slack";
-})(NotificationDestinationType || (NotificationDestinationType = {}));
+export const NotificationDestinationType = {
+    EMAIL: "email",
+    SLACK: "slack"
+};
+export const notificationDestinationTypeSchema = z.enum(NotificationDestinationType);
 export const createNotificationDestinationRequestSchema = z.object({
-    type: z.enum(NotificationDestinationType),
+    type: notificationDestinationTypeSchema,
     email: z.email().optional(),
     integrationId: z.string().optional(),
     slackChannelId: z.string().optional(),

package/dist/RunHistoryTypes.d.ts

@@ -1,18 +1,38 @@
 import * as z from "zod";
-import { IntegrationType } from "./Integrations.js";
 import type { ModelEvent } from "./ModelEvents.js";
-import type { User } from "./types.js";
-export declare enum RunHistoryStatus {
-    SUCCESS = "success",
-    FAILED = "failed",
-    CANCELLED = "cancelled",
-    SKIPPED = "skipped",
-    IN_PROGRESS = "in_progress",
-    AWAITING_APPROVAL = "awaiting_approval"
-}
-export type RunHistoryDecisionAction = "processed" | "skipped";
+import type { RunHistoryRecord, RunHistoryRecordWithAgent, User } from "./types.js";
+export declare const RunHistoryStatus: {
+    readonly SUCCESS: "success";
+    readonly FAILED: "failed";
+    readonly CANCELLED: "cancelled";
+    readonly SKIPPED: "skipped";
+    readonly IN_PROGRESS: "in_progress";
+    readonly AWAITING_APPROVAL: "awaiting_approval";
+};
+export declare const runHistoryStatusSchema: z.ZodEnum<{
+    readonly SUCCESS: "success";
+    readonly FAILED: "failed";
+    readonly CANCELLED: "cancelled";
+    readonly SKIPPED: "skipped";
+    readonly IN_PROGRESS: "in_progress";
+    readonly AWAITING_APPROVAL: "awaiting_approval";
+}>;
+export type RunHistoryStatus = z.infer<typeof runHistoryStatusSchema>;
+export declare const runHistoryDecisionActionSchema: z.ZodEnum<{
+    processed: "processed";
+    skipped: "skipped";
+}>;
+export type RunHistoryDecisionAction = z.infer<typeof runHistoryDecisionActionSchema>;
 export declare const RUN_HISTORY_ACTION_TYPES: readonly ["create", "update", "delete", "read", "approve", "error"];
-export type RunHistoryActionType = (typeof RUN_HISTORY_ACTION_TYPES)[number];
+export declare const runHistoryActionTypeSchema: z.ZodEnum<{
+    error: "error";
+    create: "create";
+    update: "update";
+    delete: "delete";
+    read: "read";
+    approve: "approve";
+}>;
+export type RunHistoryActionType = z.infer<typeof runHistoryActionTypeSchema>;
 export declare const outputItemSchema: z.ZodObject<{
     output_item_id: z.ZodString;
     output_item_type: z.ZodEnum<typeof import("./Configs.js").ConfigType>;
@@ -20,7 +40,7 @@ export declare const outputItemSchema: z.ZodObject<{
 export type OutputItem = z.infer<typeof outputItemSchema>;
 export declare const runHistoryActionBaseSchema: z.ZodObject<{
     action: z.ZodString;
-    integration: z.ZodEnum<typeof IntegrationType>;
+    integration: z.ZodEnum<typeof import("./Integrations.js").IntegrationType>;
     target: z.ZodString;
     details: z.ZodString;
     url: z.ZodOptional<z.ZodString>;
@@ -43,29 +63,7 @@ export type RunHistoryAction = z.infer<typeof runHistoryActionBaseSchema>;
 export type RunHistoryActionWithId = RunHistoryAction & {
     id: string;
 };
-export type RunHistoryTrigger = {
-    event: string;
-    integration: IntegrationType;
-    source: string;
-    title?: string;
-    subheader?: string;
-    url?: string;
-};
-export type RunHistoryDecision = {
-    action: RunHistoryDecisionAction;
-    reasoning: string;
-};
-export type RunHistoryRecord = {
-    id: string;
-    agentId: string;
-    timestamp: string;
-    trigger: RunHistoryTrigger;
-    filtered: boolean;
-    decision: RunHistoryDecision;
-    actions?: RunHistoryAction[];
-    status: RunHistoryStatus;
-    isManuallyTriggered: boolean;
-};
+export type { RunHistoryTrigger, RunHistoryDecision, RunHistoryRecord, RunHistoryRecordWithAgent } from "./types.js";
 export type GetRunHistoryParamsRequest = {
     agentId: string;
 };
@@ -83,9 +81,6 @@ export type GetRunHistoryResponse = {
     pageSize: number;
     total: number;
 };
-export type RunHistoryRecordWithAgent = RunHistoryRecord & {
-    agentName: string;
-};
 export type GetAllRunHistoryResponse = {
     items: RunHistoryRecordWithAgent[];
     page: number;

package/dist/RunHistoryTypes.js

@@ -1,16 +1,18 @@
 import * as z from "zod";
 import { configTypeEnum } from "./Configs.js";
 import { integrationTypeEnum } from "./Integrations.js";
-export var RunHistoryStatus;
-(function (RunHistoryStatus) {
-    RunHistoryStatus["SUCCESS"] = "success";
-    RunHistoryStatus["FAILED"] = "failed";
-    RunHistoryStatus["CANCELLED"] = "cancelled";
-    RunHistoryStatus["SKIPPED"] = "skipped";
-    RunHistoryStatus["IN_PROGRESS"] = "in_progress";
-    RunHistoryStatus["AWAITING_APPROVAL"] = "awaiting_approval";
-})(RunHistoryStatus || (RunHistoryStatus = {}));
+export const RunHistoryStatus = {
+    SUCCESS: "success",
+    FAILED: "failed",
+    CANCELLED: "cancelled",
+    SKIPPED: "skipped",
+    IN_PROGRESS: "in_progress",
+    AWAITING_APPROVAL: "awaiting_approval"
+};
+export const runHistoryStatusSchema = z.enum(RunHistoryStatus);
+export const runHistoryDecisionActionSchema = z.enum(["processed", "skipped"]);
 export const RUN_HISTORY_ACTION_TYPES = ["create", "update", "delete", "read", "approve", "error"];
+export const runHistoryActionTypeSchema = z.enum(RUN_HISTORY_ACTION_TYPES);
 export const outputItemSchema = z.object({
     output_item_id: z.string(),
     output_item_type: configTypeEnum
@@ -22,7 +24,7 @@ export const runHistoryActionBaseSchema = z.object({
     details: z.string(),
     url: z.string().optional(),
     step_id: z.string().optional(),
-    type: z.enum(RUN_HISTORY_ACTION_TYPES),
+    type: runHistoryActionTypeSchema,
     isReadOnly: z.boolean().optional(),
     output_items: z.array(outputItemSchema).optional()
 });

package/dist/SlackTypes.d.ts

@@ -0,0 +1,23 @@
+import type { ConversationsHistoryResponse } from "@slack/web-api";
+import type { ConversationsInfoResponse } from "@slack/web-api";
+import type { UsersInfoResponse } from "@slack/web-api";
+import * as z from "zod";
+export declare enum SlackChannelType {
+    CHANNEL = "channel",
+    GROUP = "group",
+    MPIM = "mpim",
+    IM = "im"
+}
+export declare const slackChannelTypeSchema: z.ZodEnum<typeof SlackChannelType>;
+export type SlackUser = UsersInfoResponse["user"];
+export type SlackChannelResp = ConversationsInfoResponse["channel"];
+export type SlackMessages = NonNullable<ConversationsHistoryResponse["messages"]>;
+export type SlackMessage = SlackMessages[number];
+export type SlackFiles = NonNullable<SlackMessage["files"]>;
+export type SlackFile = SlackFiles[number];
+export type SlackReactions = NonNullable<SlackMessage["reactions"]>;
+export type SlackReaction = SlackReactions[number];
+export type SlackAttachments = NonNullable<SlackMessage["attachments"]>;
+export type SlackAttachment = SlackAttachments[number];
+export type SlackBlocks = NonNullable<SlackMessage["blocks"]>;
+export type SlackBlock = SlackBlocks[number];

package/dist/SlackTypes.js

@@ -0,0 +1,9 @@
+import * as z from "zod";
+export var SlackChannelType;
+(function (SlackChannelType) {
+    SlackChannelType["CHANNEL"] = "channel";
+    SlackChannelType["GROUP"] = "group";
+    SlackChannelType["MPIM"] = "mpim";
+    SlackChannelType["IM"] = "im";
+})(SlackChannelType || (SlackChannelType = {}));
+export const slackChannelTypeSchema = z.enum(SlackChannelType);

package/dist/TicketSystem.d.ts

@@ -1,5 +1,4 @@
 export declare enum TicketSystemType {
-    Jira = "jira",
     Linear = "linear"
 }
 /**

package/dist/TicketSystem.js

@@ -1,6 +1,5 @@
 export var TicketSystemType;
 (function (TicketSystemType) {
-    TicketSystemType["Jira"] = "jira";
     TicketSystemType["Linear"] = "linear";
     // Future ticket systems can be added here
 })(TicketSystemType || (TicketSystemType = {}));

package/dist/ToolDisplayUtils.js

@@ -341,64 +341,6 @@ const TOOL_DISPLAY_CONFIG = {
         }
     },
     // ===================
-    // Jira Tools
-    // ===================
-    jira_create_ticket: {
-        preparing: "Getting a task ready",
-        executing: params => {
-            const title = params?.title;
-            return title ? `Creating task: "${truncate(title)}"` : "Creating task";
-        },
-        complete: (params, result) => {
-            const parsed = safeParseResult(result);
-            const issue = parsed?.issue;
-            const key = issue?.key;
-            const title = params?.title || issue?.title;
-            if (key && title)
-                return `Created task ${key}: "${truncate(title, 30)}"`;
-            if (key)
-                return `Created task ${key}`;
-            if (title)
-                return `Created task "${truncate(title)}"`;
-            return "Task created";
-        },
-        approval: params => {
-            const title = params?.title;
-            return title ? `Create Jira ticket: "${truncate(title)}"?` : "Create this Jira ticket?";
-        }
-    },
-    jira_update_ticket: {
-        preparing: "Getting your updates ready",
-        executing: params => {
-            const issueKey = params?.issueKey;
-            return issueKey ? `Updating task ${issueKey}` : "Updating task";
-        },
-        complete: params => {
-            const issueKey = params?.issueKey;
-            return issueKey ? `Updated task ${issueKey}` : "Task updated";
-        },
-        approval: () => "Update this task?"
-    },
-    jira_search_ticket: {
-        preparing: "Looking for tasks",
-        executing: params => {
-            const text = params?.text;
-            return text ? `Looking for tasks about "${truncate(text)}"` : "Looking for tasks";
-        },
-        complete: (params, result) => {
-            const parsed = safeParseResult(result);
-            const count = parsed?.count;
-            const text = params?.text;
-            if (count !== undefined && text)
-                return `Found ${count} task${count !== 1 ? "s" : ""} about "${truncate(text, 25)}"`;
-            if (count !== undefined)
-                return `Found ${count} task${count !== 1 ? "s" : ""}`;
-            if (text)
-                return `Looked for "${truncate(text)}"`;
-            return "Search complete";
-        }
-    },
-    // ===================
     // Notion Tools
     // ===================
     notion_create_or_update_database_row: {
@@ -576,24 +518,6 @@ const TOOL_DISPLAY_CONFIG = {
         }
     },
     // ===================
-    // Confluence Tools
-    // ===================
-    confluence_query_page: {
-        preparing: "Finding page",
-        executing: () => "Loading page",
-        complete: (_params, result) => {
-            const parsed = safeParseResult(result);
-            const title = parsed?.title;
-            return title ? `Opened "${truncate(title)}"` : "Page loaded";
-        }
-    },
-    confluence_add_comment: {
-        preparing: "Getting your note ready",
-        executing: () => "Adding your note",
-        complete: () => "Note added",
-        approval: () => "Add this comment?"
-    },
-    // ===================
     // GitHub Tools
     // ===================
     searchGitHubCode: {