terse-types 0.0.1 → 0.0.2

package/dist/ModelEvents.js

@@ -1,9 +1,79 @@
+import * as z from "zod";
+import { EntityType } from "./Entities.js";
+export const entityTypeSchema = z.enum(EntityType);
 export var ChangeEventType;
 (function (ChangeEventType) {
     ChangeEventType["CREATED"] = "CREATED";
     ChangeEventType["UPDATED"] = "UPDATED";
     ChangeEventType["ACTION_EXECUTED"] = "ACTION_EXECUTED";
 })(ChangeEventType || (ChangeEventType = {}));
+export const changeEventTypeSchema = z.enum(ChangeEventType);
+export const sharedErrorContextSchema = z.object({
+    error: z.unknown()
+});
+export const changedItemSchema = z.object({
+    type_name: entityTypeSchema,
+    id: z.string(),
+    change_event_type: changeEventTypeSchema
+});
+export const runErrorSchema = z.object({
+    error: z.string(),
+    code: z.string().optional(),
+    timestamp: z.number()
+});
+export const cancelledSchema = z.object({
+    reason: z.string().optional(),
+    timestamp: z.number()
+});
+export const functionCallSchema = z.object({
+    function_name: z.string(),
+    result: z.string(),
+    step_id: z.string()
+});
+export const naturalStopSchema = z.object({
+    step_id: z.string(),
+    timestamp: z.number()
+});
+export const sendModelRequestSchema = z.object({
+    user_message: z.string(),
+    timezone: z.string(),
+    ui_state: z.string().optional(),
+    client_turn_id: z.string(),
+    template_id: z.string().optional()
+});
+export const toolApprovalResponseSchema = z.object({
+    step_id: z.string(),
+    approved: z.boolean(),
+    rejection_reason: z.string().optional(),
+    timestamp: z.number()
+});
+export const toolApprovalRequestSchema = z.object({
+    step_id: z.string(),
+    name: z.string(),
+    arguments: z.string(),
+    timestamp: z.number()
+});
+export const textDeltaSchema = z.object({
+    delta: z.string(),
+    step_id: z.string(),
+    timestamp: z.number()
+});
+export const toolCallGeneratingSchema = z.object({
+    tool_name: z.string(),
+    step_id: z.string(),
+    timestamp: z.number()
+});
+export const toolCallSchema = z.object({
+    summary: z.string(),
+    step_id: z.string(),
+    parameters: z.string(),
+    integration: z.string(),
+    timestamp: z.number()
+});
+export const thinkingSchema = z.object({
+    step_id: z.string(),
+    timestamp: z.number()
+});
 export var ToolCallExecutionStatus;
 (function (ToolCallExecutionStatus) {
     ToolCallExecutionStatus["COMPLETED"] = "completed";
@@ -11,6 +81,25 @@ export var ToolCallExecutionStatus;
     ToolCallExecutionStatus["FAILED"] = "failed";
     ToolCallExecutionStatus["UNKNOWN"] = "unknown";
 })(ToolCallExecutionStatus || (ToolCallExecutionStatus = {}));
+export const toolCallExecutionStatusSchema = z.enum(ToolCallExecutionStatus);
+export const toolCallCompleteSchema = z.object({
+    tool_name: z.string(),
+    timestamp: z.number(),
+    status: toolCallExecutionStatusSchema,
+    step_id: z.string(),
+    changed_items: z.array(changedItemSchema),
+    integration: z.string(),
+    url: z.string().optional(),
+    result: z.string().optional(),
+    errorContext: sharedErrorContextSchema.optional()
+});
+export const filterResultSchema = z.object({
+    isRelevant: z.boolean(),
+    reason: z.string(),
+    confidence: z.number(),
+    step_id: z.string(),
+    timestamp: z.number()
+});
 export var SandboxStage;
 (function (SandboxStage) {
     SandboxStage["DOWNLOADING_SOURCE"] = "downloading_source";
@@ -19,6 +108,7 @@ export var SandboxStage;
     SandboxStage["INSTALLING_CLI"] = "installing_cli";
     SandboxStage["RUNNING"] = "running";
 })(SandboxStage || (SandboxStage = {}));
+export const sandboxStageSchema = z.enum(SandboxStage);
 export const SANDBOX_STAGE_LABELS = {
     [SandboxStage.DOWNLOADING_SOURCE]: "Downloading source code",
     [SandboxStage.BOOTING]: "Booting sandbox",
@@ -26,3 +116,97 @@ export const SANDBOX_STAGE_LABELS = {
     [SandboxStage.INSTALLING_CLI]: "Installing CLI",
     [SandboxStage.RUNNING]: "Running agent"
 };
+export const userMessageSchema = z.object({
+    message: z.string(),
+    step_id: z.string(),
+    client_turn_id: z.string(),
+    timestamp: z.number()
+});
+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({
+    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 modelRequestSchema = z.discriminatedUnion("type", [
+    sendModelRequestSchema.extend({
+        type: z.literal("SendModelRequest")
+    }),
+    toolApprovalResponseSchema.extend({
+        type: z.literal("ToolApprovalResponse")
+    })
+]);

package/dist/Notifications.d.ts

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import { RunHistoryActionType } from "./RunHistoryTypes.js";
 export interface NotificationDestination {
     id: string;
@@ -30,13 +31,25 @@ export interface SlackNotificationDestination extends NotificationDestination {
     slackUserId?: string;
     slackUserName?: string;
 }
-export interface CreateNotificationDestinationRequest {
-    type: NotificationDestinationType;
-    email?: string;
-    integrationId?: string;
-    slackChannelId?: string;
-    slackChannelName?: string;
-    slackUserId?: string;
-    slackUserName?: string;
-    isActive?: boolean;
-}
+export declare const createNotificationDestinationRequestSchema: z.ZodObject<{
+    type: z.ZodEnum<typeof NotificationDestinationType>;
+    email: z.ZodOptional<z.ZodEmail>;
+    integrationId: z.ZodOptional<z.ZodString>;
+    slackChannelId: z.ZodOptional<z.ZodString>;
+    slackChannelName: z.ZodOptional<z.ZodString>;
+    slackUserId: z.ZodOptional<z.ZodString>;
+    slackUserName: z.ZodOptional<z.ZodString>;
+    isActive: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type CreateNotificationDestinationRequest = z.infer<typeof createNotificationDestinationRequestSchema>;
+export declare const updateNotificationDestinationRequestSchema: z.ZodObject<{
+    type: z.ZodOptional<z.ZodEnum<typeof NotificationDestinationType>>;
+    email: z.ZodOptional<z.ZodOptional<z.ZodEmail>>;
+    integrationId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    slackChannelId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    slackChannelName: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    slackUserId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    slackUserName: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    isActive: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+export type UpdateNotificationDestinationRequest = z.infer<typeof updateNotificationDestinationRequestSchema>;

package/dist/Notifications.js

@@ -1,5 +1,17 @@
+import { z } from "zod";
 export var NotificationDestinationType;
 (function (NotificationDestinationType) {
     NotificationDestinationType["EMAIL"] = "email";
     NotificationDestinationType["SLACK"] = "slack";
 })(NotificationDestinationType || (NotificationDestinationType = {}));
+export const createNotificationDestinationRequestSchema = z.object({
+    type: z.enum(NotificationDestinationType),
+    email: z.email().optional(),
+    integrationId: z.string().optional(),
+    slackChannelId: z.string().optional(),
+    slackChannelName: z.string().optional(),
+    slackUserId: z.string().optional(),
+    slackUserName: z.string().optional(),
+    isActive: z.boolean().optional()
+});
+export const updateNotificationDestinationRequestSchema = createNotificationDestinationRequestSchema.partial();

package/dist/RunHistoryTypes.d.ts

@@ -1,5 +1,4 @@
 import * as z from "zod";
-import { ConfigType } from "./Configs.js";
 import { IntegrationType } from "./Integrations.js";
 import type { ModelEvent } from "./ModelEvents.js";
 import type { User } from "./types.js";
@@ -14,6 +13,11 @@ export declare enum RunHistoryStatus {
 export type RunHistoryDecisionAction = "processed" | "skipped";
 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 outputItemSchema: z.ZodObject<{
+    output_item_id: z.ZodString;
+    output_item_type: z.ZodEnum<typeof import("./Configs.js").ConfigType>;
+}, z.core.$strip>;
+export type OutputItem = z.infer<typeof outputItemSchema>;
 export declare const runHistoryActionBaseSchema: z.ZodObject<{
     action: z.ZodString;
     integration: z.ZodEnum<typeof IntegrationType>;
@@ -22,17 +26,17 @@ export declare const runHistoryActionBaseSchema: z.ZodObject<{
     url: z.ZodOptional<z.ZodString>;
     step_id: z.ZodOptional<z.ZodString>;
     type: z.ZodEnum<{
+        error: "error";
         create: "create";
         update: "update";
         delete: "delete";
         read: "read";
         approve: "approve";
-        error: "error";
     }>;
     isReadOnly: z.ZodOptional<z.ZodBoolean>;
     output_items: z.ZodOptional<z.ZodArray<z.ZodObject<{
         output_item_id: z.ZodString;
-        output_item_type: z.ZodEnum<typeof ConfigType>;
+        output_item_type: z.ZodEnum<typeof import("./Configs.js").ConfigType>;
     }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type RunHistoryAction = z.infer<typeof runHistoryActionBaseSchema>;

package/dist/RunHistoryTypes.js

@@ -11,6 +11,10 @@ export var RunHistoryStatus;
     RunHistoryStatus["AWAITING_APPROVAL"] = "awaiting_approval";
 })(RunHistoryStatus || (RunHistoryStatus = {}));
 export const RUN_HISTORY_ACTION_TYPES = ["create", "update", "delete", "read", "approve", "error"];
+export const outputItemSchema = z.object({
+    output_item_id: z.string(),
+    output_item_type: configTypeEnum
+});
 export const runHistoryActionBaseSchema = z.object({
     action: z.string(),
     integration: integrationTypeEnum,
@@ -20,10 +24,5 @@ export const runHistoryActionBaseSchema = z.object({
     step_id: z.string().optional(),
     type: z.enum(RUN_HISTORY_ACTION_TYPES),
     isReadOnly: z.boolean().optional(),
-    output_items: z
-        .array(z.object({
-        output_item_id: z.string(),
-        output_item_type: configTypeEnum
-    }))
-        .optional()
+    output_items: z.array(outputItemSchema).optional()
 });