terse-types 0.0.12 → 0.0.14

package/dist/ApiRouteBuilder.d.ts

@@ -124,6 +124,9 @@ export declare const ApiRoutes: {
         LIST: string;
         BY_ID: string;
     };
+    PROJECTS: {
+        BY_ID: string;
+    };
     SDK: {
         ME: string;
         SAMPLE_EVENTS: string;
@@ -134,6 +137,7 @@ export declare const ApiRoutes: {
         AGENT_RUN: string;
         APPROVAL_DECISION: string;
         SESSION_EVENTS: string;
+        CREATE_PROJECT: string;
         DEPLOY: string;
         DEVICE_TOKEN_EXCHANGE: string;
         INTEGRATION_FIELDS: string;
@@ -152,6 +156,7 @@ export declare const ApiRoutes: {
         WORKOS: string;
         LINEAR_BY_USER_ID: string;
         SCHEDULE_BY_INPUT_ID: string;
+        WEBMONITOR_BY_INPUT_ID: string;
         WORKOS_TRIGGER_BY_INTEGRATION_ID: string;
         WEBHOOK_TRIGGER_BY_TOKEN: string;
     };
@@ -160,6 +165,7 @@ export declare const ApiRoutes: {
         TRIGGER_WITH_EVENT: string;
     };
     REFRESH_TOKENS: string;
+    CLEAR_OLD_SECRET_VERSIONS: string;
     REVIEW_AGENTS: string;
     CLEANUP_SDK_IMAGES: string;
     USERS: {

package/dist/ApiRoutes.json

@@ -124,6 +124,9 @@
         "LIST": "/api-tokens",
         "BY_ID": "/api-tokens/:id"
     },
+    "PROJECTS": {
+        "BY_ID": "/projects/:id"
+    },
     "SDK": {
         "ME": "/sdk/me",
         "SAMPLE_EVENTS": "/sdk/sample-events",
@@ -134,6 +137,7 @@
         "AGENT_RUN": "/sdk/agent-run",
         "APPROVAL_DECISION": "/sdk/approval-decision",
         "SESSION_EVENTS": "/sdk/session-events",
+        "CREATE_PROJECT": "/sdk/projects",
         "DEPLOY": "/sdk/deploy",
         "DEVICE_TOKEN_EXCHANGE": "/sdk/auth/device-token-exchange",
         "INTEGRATION_FIELDS": "/sdk/integrations/:integrationType/fields",
@@ -152,6 +156,7 @@
         "WORKOS": "/webhooks/workos",
         "LINEAR_BY_USER_ID": "/webhooks/linear/:userId",
         "SCHEDULE_BY_INPUT_ID": "/webhooks/schedule/:inputId",
+        "WEBMONITOR_BY_INPUT_ID": "/webhooks/webmonitor/:inputId",
         "WORKOS_TRIGGER_BY_INTEGRATION_ID": "/webhooks/workos-trigger/:integrationId",
         "WEBHOOK_TRIGGER_BY_TOKEN": "/webhooks/trigger/:webhookToken"
     },
@@ -160,6 +165,7 @@
         "TRIGGER_WITH_EVENT": "/schedule/trigger-with-event/:automationId"
     },
     "REFRESH_TOKENS": "/refresh-tokens",
+    "CLEAR_OLD_SECRET_VERSIONS": "/clear-old-secret-versions",
     "REVIEW_AGENTS": "/review-agents",
     "CLEANUP_SDK_IMAGES": "/cleanup-sdk-images",
     "USERS": {

package/dist/Configs.d.ts

@@ -19,9 +19,16 @@ export declare enum ConfigType {
     WORKOS_OUTPUT = "workos_output",
     ATTIO_OUTPUT = "attio_output",
     SNOWFLAKE_OUTPUT = "snowflake_output",
-    WEBHOOK_INPUT = "webhook_input"
+    WEBHOOK_INPUT = "webhook_input",
+    WEBMONITOR = "webmonitor"
 }
 export declare const configTypeEnum: z.ZodEnum<typeof ConfigType>;
+export declare const frequencyUnitSchema: z.ZodEnum<{
+    hour: "hour";
+    day: "day";
+    week: "week";
+}>;
+export type FrequencyUnit = z.infer<typeof frequencyUnitSchema>;
 export interface ConfigDetails {
     configType: ConfigType;
     name: string;
@@ -182,6 +189,14 @@ export declare const WebhookInputConfigMetadata: {
     readonly isInput: true;
     readonly isOutput: false;
 };
+export declare const WebMonitorConfigMetadata: {
+    readonly configType: ConfigType.WEBMONITOR;
+    readonly name: "Web Monitor";
+    readonly description: "Run when scheduled web monitoring detects relevant changes";
+    readonly integrationType: IntegrationType.WEBMONITOR;
+    readonly isInput: true;
+    readonly isOutput: false;
+};
 export type ConfigDetailsMap = Record<ConfigType, ConfigDetails>;
 export declare const CONFIG_DETAILS: ConfigDetailsMap;
 export declare const SlackEventType: {
@@ -603,6 +618,50 @@ export declare class WebhookInputConfig extends BaseConfigInstance<IntegrationTy
     isComplete(): boolean;
     formatForAgent(): string;
 }
+export declare const WebMonitorOutputSchemaSchema: z.ZodObject<{
+    type: z.ZodLiteral<"json">;
+    jsonSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export type WebMonitorOutputSchema = z.infer<typeof WebMonitorOutputSchemaSchema>;
+export declare const WebMonitorConfigSchema: z.ZodObject<{
+    integrationId: z.ZodLiteral<"system">;
+    integrationType: z.ZodLiteral<IntegrationType.WEBMONITOR>;
+    configType: z.ZodLiteral<ConfigType.WEBMONITOR>;
+    query: z.ZodString;
+    frequency: z.ZodObject<{
+        number: z.ZodNumber;
+        unit: z.ZodEnum<{
+            hour: "hour";
+            day: "day";
+            week: "week";
+        }>;
+    }, z.core.$strip>;
+    outputSchema: z.ZodPipe<z.ZodTransform<{
+        type: "json";
+        jsonSchema: Record<string, unknown>;
+    } | undefined, unknown>, z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        type: z.ZodLiteral<"json">;
+        jsonSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>>>>;
+}, z.core.$strip>;
+export type WebMonitorConfigData = z.infer<typeof WebMonitorConfigSchema>;
+export type WebMonitorConfigInstance = WebMonitorConfigData & ConfigBehavior;
+export declare class WebMonitorConfig extends BaseConfigInstance<IntegrationType.WEBMONITOR, ConfigType.WEBMONITOR, "system"> implements WebMonitorConfigInstance {
+    query: string;
+    frequency: {
+        number: number;
+        unit: FrequencyUnit;
+    };
+    readonly outputSchema?: WebMonitorOutputSchema;
+    private readonly rawOutputSchema?;
+    constructor(query: string, frequency: {
+        number: number;
+        unit: FrequencyUnit;
+    }, outputSchema?: unknown);
+    isComplete(): boolean;
+    formatForAgent(): string;
+    toJSON(): WebMonitorConfigData;
+}
 export declare const configDataSchema: z.ZodUnion<readonly [z.ZodObject<{
     integrationId: z.ZodString;
     integrationType: z.ZodLiteral<IntegrationType.GMAIL>;
@@ -743,6 +802,26 @@ export declare const configDataSchema: z.ZodUnion<readonly [z.ZodObject<{
     integrationId: z.ZodLiteral<"system">;
     integrationType: z.ZodLiteral<IntegrationType.WEBHOOK>;
     configType: z.ZodLiteral<ConfigType.WEBHOOK_INPUT>;
+}, z.core.$strip>, z.ZodObject<{
+    integrationId: z.ZodLiteral<"system">;
+    integrationType: z.ZodLiteral<IntegrationType.WEBMONITOR>;
+    configType: z.ZodLiteral<ConfigType.WEBMONITOR>;
+    query: z.ZodString;
+    frequency: z.ZodObject<{
+        number: z.ZodNumber;
+        unit: z.ZodEnum<{
+            hour: "hour";
+            day: "day";
+            week: "week";
+        }>;
+    }, z.core.$strip>;
+    outputSchema: z.ZodPipe<z.ZodTransform<{
+        type: "json";
+        jsonSchema: Record<string, unknown>;
+    } | undefined, unknown>, z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        type: z.ZodLiteral<"json">;
+        jsonSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>>>>;
 }, z.core.$strip>]>;
 export type ConfigData = z.infer<typeof configDataSchema>;
 /** Configs that can serve as triggers (event sources). */
@@ -815,6 +894,26 @@ export declare const triggerConfigDataSchema: z.ZodUnion<readonly [z.ZodObject<{
     integrationId: z.ZodLiteral<"system">;
     integrationType: z.ZodLiteral<IntegrationType.WEBHOOK>;
     configType: z.ZodLiteral<ConfigType.WEBHOOK_INPUT>;
+}, z.core.$strip>, z.ZodObject<{
+    integrationId: z.ZodLiteral<"system">;
+    integrationType: z.ZodLiteral<IntegrationType.WEBMONITOR>;
+    configType: z.ZodLiteral<ConfigType.WEBMONITOR>;
+    query: z.ZodString;
+    frequency: z.ZodObject<{
+        number: z.ZodNumber;
+        unit: z.ZodEnum<{
+            hour: "hour";
+            day: "day";
+            week: "week";
+        }>;
+    }, z.core.$strip>;
+    outputSchema: z.ZodPipe<z.ZodTransform<{
+        type: "json";
+        jsonSchema: Record<string, unknown>;
+    } | undefined, unknown>, z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        type: z.ZodLiteral<"json">;
+        jsonSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>>>>;
 }, z.core.$strip>]>;
 export type TriggerConfigData = z.infer<typeof triggerConfigDataSchema>;
 /** Configs that can serve as skills (tools / outputs). */
@@ -914,6 +1013,7 @@ export type ConfigMetadataMap = EnsureExhaustiveMetadata<{
     [ConfigType.ATTIO_OUTPUT]: typeof AttioOutputConfig;
     [ConfigType.SNOWFLAKE_OUTPUT]: typeof SnowflakeOutputConfig;
     [ConfigType.WEBHOOK_INPUT]: typeof WebhookInputConfig;
+    [ConfigType.WEBMONITOR]: typeof WebMonitorConfig;
 }>;
 export declare const CONFIG_METADATA: ConfigMetadataMap;
 export {};

package/dist/Configs.js

@@ -21,8 +21,10 @@ export var ConfigType;
     ConfigType["ATTIO_OUTPUT"] = "attio_output";
     ConfigType["SNOWFLAKE_OUTPUT"] = "snowflake_output";
     ConfigType["WEBHOOK_INPUT"] = "webhook_input";
+    ConfigType["WEBMONITOR"] = "webmonitor";
 })(ConfigType || (ConfigType = {}));
 export const configTypeEnum = z.enum(ConfigType);
+export const frequencyUnitSchema = z.enum(["hour", "day", "week"]);
 // Metadata objects - using const objects instead of classes
 export const GmailConfigMetadata = {
     configType: ConfigType.GMAIL,
@@ -176,6 +178,14 @@ export const WebhookInputConfigMetadata = {
     isInput: true,
     isOutput: false
 };
+export const WebMonitorConfigMetadata = {
+    configType: ConfigType.WEBMONITOR,
+    name: "Web Monitor",
+    description: "Run when scheduled web monitoring detects relevant changes",
+    integrationType: IntegrationType.WEBMONITOR,
+    isInput: true,
+    isOutput: false
+};
 export const CONFIG_DETAILS = {
     [ConfigType.GMAIL]: GmailConfigMetadata,
     [ConfigType.GMAIL_OUTPUT]: GmailOutputConfigMetadata,
@@ -195,7 +205,8 @@ export const CONFIG_DETAILS = {
     [ConfigType.WORKOS_OUTPUT]: WorkOSOutputConfigMetadata,
     [ConfigType.ATTIO_OUTPUT]: AttioOutputConfigMetadata,
     [ConfigType.SNOWFLAKE_OUTPUT]: SnowflakeOutputConfigMetadata,
-    [ConfigType.WEBHOOK_INPUT]: WebhookInputConfigMetadata
+    [ConfigType.WEBHOOK_INPUT]: WebhookInputConfigMetadata,
+    [ConfigType.WEBMONITOR]: WebMonitorConfigMetadata
 };
 // MARK: Event Types — specific events within each integration trigger
 export const SlackEventType = {
@@ -241,6 +252,9 @@ export const ConfigInstanceSchema = z.object({
     integrationType: integrationTypeEnum,
     configType: configTypeEnum
 });
+function isZodSchemaLike(value) {
+    return !!value && typeof value === "object" && "_zod" in value;
+}
 class BaseConfigInstance {
     integrationId;
     integrationType;
@@ -735,6 +749,80 @@ export class WebhookInputConfig extends BaseConfigInstance {
         return "Type: Webhook Trigger";
     }
 }
+function isPlainObject(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+export const WebMonitorOutputSchemaSchema = z.object({
+    type: z.literal("json"),
+    jsonSchema: z.record(z.string(), z.unknown())
+});
+function normalizeWebMonitorOutputSchema(value) {
+    if (value == null) {
+        return undefined;
+    }
+    if (isZodSchemaLike(value)) {
+        const jsonSchema = z.toJSONSchema(value, {
+            target: "draft-2020-12",
+            unrepresentable: "any",
+            cycles: "throw"
+        });
+        if (!isPlainObject(jsonSchema)) {
+            throw new Error("WebMonitor outputSchema did not produce a valid JSON schema object.");
+        }
+        if ("$schema" in jsonSchema) {
+            delete jsonSchema.$schema;
+        }
+        return { type: "json", jsonSchema };
+    }
+    return WebMonitorOutputSchemaSchema.parse(value);
+}
+export const WebMonitorConfigSchema = ConfigInstanceSchema.extend({
+    integrationId: z.literal("system"),
+    integrationType: z.literal(IntegrationType.WEBMONITOR),
+    configType: z.literal(ConfigType.WEBMONITOR),
+    query: z.string(),
+    frequency: z.object({
+        number: z.number(),
+        unit: frequencyUnitSchema
+    }),
+    outputSchema: z.preprocess(value => normalizeWebMonitorOutputSchema(value), WebMonitorOutputSchemaSchema.nullable().optional())
+});
+export class WebMonitorConfig extends BaseConfigInstance {
+    query;
+    frequency;
+    outputSchema;
+    rawOutputSchema;
+    constructor(query, frequency, outputSchema) {
+        super("system", IntegrationType.WEBMONITOR, ConfigType.WEBMONITOR);
+        this.query = query;
+        this.frequency = frequency;
+        this.rawOutputSchema = outputSchema;
+        this.outputSchema = normalizeWebMonitorOutputSchema(outputSchema);
+    }
+    isComplete() {
+        return !!(this.query && this.frequency);
+    }
+    formatForAgent() {
+        const parts = [`Type: Web Monitor`];
+        if (this.query)
+            parts.push(`Query: ${this.query}`);
+        if (this.frequency)
+            parts.push(`Frequency: ${this.frequency.number}${this.frequency.unit}`);
+        if (this.outputSchema)
+            parts.push(`Structured Output: ${typeof this.outputSchema === "object" ? "enabled" : "configured"}`);
+        return parts.join("\n");
+    }
+    toJSON() {
+        return WebMonitorConfigSchema.parse({
+            integrationId: this.integrationId,
+            integrationType: this.integrationType,
+            configType: this.configType,
+            query: this.query,
+            frequency: this.frequency,
+            outputSchema: this.rawOutputSchema ?? this.outputSchema
+        });
+    }
+}
 export const configDataSchema = z.union([
     GmailConfigSchema,
     SlackConfigSchema,
@@ -755,7 +843,8 @@ export const configDataSchema = z.union([
     WorkOSOutputConfigSchema,
     AttioOutputConfigSchema,
     SnowflakeOutputConfigSchema,
-    WebhookInputConfigSchema
+    WebhookInputConfigSchema,
+    WebMonitorConfigSchema
 ]);
 /** Configs that can serve as triggers (event sources). */
 export const triggerConfigDataSchema = z.union([
@@ -765,7 +854,8 @@ export const triggerConfigDataSchema = z.union([
     GitHubConfigSchema,
     TimeTriggerConfigSchema,
     WorkOSInputConfigSchema,
-    WebhookInputConfigSchema
+    WebhookInputConfigSchema,
+    WebMonitorConfigSchema
 ]);
 /** Configs that can serve as skills (tools / outputs). */
 export const skillConfigDataSchema = z.union([
@@ -813,6 +903,8 @@ export function isConfigComplete(config) {
             return !!config.projectId;
         case ConfigType.TIME_TRIGGER:
             return !!config.cronExpression;
+        case ConfigType.WEBMONITOR:
+            return !!(config.query && config.frequency);
         case ConfigType.LAUNCHDARKLY:
             return !!(config.projectKey && config.environmentKeys.length > 0);
         case ConfigType.WORKOS_INPUT:
@@ -949,6 +1041,14 @@ export function formatConfigForAgent(config) {
             return `Type: Snowflake Output\nIntegration ID: ${config.integrationId}`;
         case ConfigType.WEBHOOK_INPUT:
             return "Type: Webhook Trigger";
+        case ConfigType.WEBMONITOR: {
+            const parts = [`Type: Web Event`];
+            if (config.query)
+                parts.push(`Query: ${config.query}`);
+            if (config.frequency)
+                parts.push(`Frequency: ${config.frequency.number}${config.frequency.unit}`);
+            return parts.join("\n");
+        }
         default: {
             const _exhaustive = config;
             return _exhaustive;
@@ -974,5 +1074,6 @@ export const CONFIG_METADATA = {
     [ConfigType.WORKOS_OUTPUT]: WorkOSOutputConfig,
     [ConfigType.ATTIO_OUTPUT]: AttioOutputConfig,
     [ConfigType.SNOWFLAKE_OUTPUT]: SnowflakeOutputConfig,
-    [ConfigType.WEBHOOK_INPUT]: WebhookInputConfig
+    [ConfigType.WEBHOOK_INPUT]: WebhookInputConfig,
+    [ConfigType.WEBMONITOR]: WebMonitorConfig
 };

package/dist/FrontendRoutes.json

@@ -16,6 +16,9 @@
         "ALERTS": "/app/agents/:id?tab=setup&section=alerts",
         "RUN_HISTORY": "/app/agents/:id?tab=history&runId=:runId"
     },
+    "PROJECTS": {
+        "BY_ID": "/app/projects/:id"
+    },
     "INTEGRATIONS": "/app/integrations",
     "ACTIVITY": "/app/activity",
     "STATS": "/app/stats",

package/dist/FrontendRoutesBuilder.d.ts

@@ -18,6 +18,9 @@ export declare const FrontendRoutes: {
         ALERTS: string;
         RUN_HISTORY: string;
     };
+    PROJECTS: {
+        BY_ID: string;
+    };
     INTEGRATIONS: string;
     ACTIVITY: string;
     STATS: string;

package/dist/Integrations.d.ts

@@ -13,7 +13,8 @@ export declare enum IntegrationType {
     WORKOS = "workos",
     ATTIO = "attio",
     SNOWFLAKE = "snowflake",
-    WEBHOOK = "webhook"
+    WEBHOOK = "webhook",
+    WEBMONITOR = "webmonitor"
 }
 export declare const integrationTypeEnum: z.ZodEnum<typeof IntegrationType>;
 export interface IntegrationDetails {
@@ -86,6 +87,13 @@ export declare const CronJobIntegrationMetadata: {
     readonly isInput: true;
     readonly isOutput: false;
 };
+export declare const WebMonitorIntegrationMetadata: {
+    readonly type: IntegrationType.WEBMONITOR;
+    readonly name: "Web Monitor";
+    readonly description: "Trigger when scheduled web monitoring detects relevant changes";
+    readonly isInput: true;
+    readonly isOutput: false;
+};
 export declare const LaunchDarklyIntegrationMetadata: {
     readonly type: IntegrationType.LAUNCHDARKLY;
     readonly name: "LaunchDarkly";
@@ -148,6 +156,7 @@ export type IntegrationInstallationOptions = EnsureExhaustiveInstallationOptions
     [IntegrationType.ATTIO]: NoInstallationOptions;
     [IntegrationType.SNOWFLAKE]: NoInstallationOptions;
     [IntegrationType.WEBHOOK]: NoInstallationOptions;
+    [IntegrationType.WEBMONITOR]: NoInstallationOptions;
 }>;
 export type InstallationOptionsFor<T extends IntegrationType> = IntegrationInstallationOptions[T];
 export declare const SlackIntegrationSchema: z.ZodObject<{

package/dist/Integrations.js

@@ -16,6 +16,7 @@ export var IntegrationType;
     IntegrationType["ATTIO"] = "attio";
     IntegrationType["SNOWFLAKE"] = "snowflake";
     IntegrationType["WEBHOOK"] = "webhook";
+    IntegrationType["WEBMONITOR"] = "webmonitor";
 })(IntegrationType || (IntegrationType = {}));
 export const integrationTypeEnum = z.enum(IntegrationType);
 // Metadata objects - using const objects instead of classes
@@ -82,6 +83,13 @@ export const CronJobIntegrationMetadata = {
     isInput: true,
     isOutput: false
 };
+export const WebMonitorIntegrationMetadata = {
+    type: IntegrationType.WEBMONITOR,
+    name: "Web Monitor",
+    description: "Trigger when scheduled web monitoring detects relevant changes",
+    isInput: true,
+    isOutput: false
+};
 export const LaunchDarklyIntegrationMetadata = {
     type: IntegrationType.LAUNCHDARKLY,
     name: "LaunchDarkly",
@@ -131,7 +139,8 @@ export const INTEGRATION_METADATA = {
     [IntegrationType.WORKOS]: WorkOSIntegrationMetadata,
     [IntegrationType.ATTIO]: AttioIntegrationMetadata,
     [IntegrationType.SNOWFLAKE]: SnowflakeIntegrationMetadata,
-    [IntegrationType.WEBHOOK]: WebhookIntegrationMetadata
+    [IntegrationType.WEBHOOK]: WebhookIntegrationMetadata,
+    [IntegrationType.WEBMONITOR]: WebMonitorIntegrationMetadata
 };
 // MARK: Integration Details
 export const IntegrationInstanceSchema = z.object({

package/dist/SandboxTypes.d.ts

@@ -0,0 +1,15 @@
+export type SandboxLogEntry = {
+    stream: "stdout" | "stderr";
+    text: string;
+    timestamp: number;
+};
+export type SandboxLogPayload = SandboxLogEntry & {
+    runId: string;
+    agentId: string;
+};
+export type SandboxLogsResponse = {
+    sandboxId: string | null;
+    entries: SandboxLogEntry[];
+    timestamp: number;
+    error?: string;
+};

package/dist/SandboxTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/TriggerEventPresenters.d.ts

@@ -0,0 +1,3 @@
+import type { Trigger } from "./Triggers.js";
+export declare function formatTriggerForAgent(event: Trigger): string;
+export declare function debugTrigger(event: Trigger): string;