@automate.ax/integration-contracts 0.136.0 → 0.138.0

package/dist/anthropic/index.d.ts

@@ -0,0 +1,128 @@
+import type { Beta } from "@anthropic-ai/sdk/resources/beta/beta";
+import type { Encodable } from "@automate.ax/codec";
+import * as z from "zod";
+import type { CamelCasedPropertiesDeep } from "type-fest";
+export declare const ANTHROPIC_SESSION_WEBHOOK_TYPES: readonly ["session.status_run_started", "session.status_idled", "session.budget_reached", "session.status_rescheduled", "session.status_terminated", "session.thread_created", "session.thread_idled", "session.thread_terminated", "session.outcome_evaluation_ended", "session.updated", "session.deleted"];
+export declare const ANTHROPIC_AGENT_WEBHOOK_TYPES: readonly ["agent.created", "agent.updated", "agent.archived", "agent.deleted"];
+export declare const ANTHROPIC_ENVIRONMENT_WEBHOOK_TYPES: readonly ["environment.created", "environment.updated", "environment.archived", "environment.deleted"];
+export declare const ANTHROPIC_WEBHOOK_TYPES: readonly ["session.status_run_started", "session.status_idled", "session.budget_reached", "session.status_rescheduled", "session.status_terminated", "session.thread_created", "session.thread_idled", "session.thread_terminated", "session.outcome_evaluation_ended", "session.updated", "session.deleted", "agent.created", "agent.updated", "agent.archived", "agent.deleted", "environment.created", "environment.updated", "environment.archived", "environment.deleted"];
+export type AnthropicWebhookType = (typeof ANTHROPIC_WEBHOOK_TYPES)[number];
+export declare const ANTHROPIC_TRIGGER_CONFIG_SCHEMA: z.ZodObject<{}, z.core.$strip>;
+export declare const ANTHROPIC_IDLE_EVENT_SCHEMA: z.ZodObject<{
+    id: z.ZodString;
+    processedAt: z.ZodISODateTime;
+    stopReason: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"end_turn">;
+    }, z.core.$strip>, z.ZodObject<{
+        eventIds: z.ZodArray<z.ZodString>;
+        type: z.ZodLiteral<"requires_action">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"budget_reached">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"retries_exhausted">;
+    }, z.core.$strip>], "type">;
+    type: z.ZodLiteral<"session.status_idle">;
+}, z.core.$strip>;
+/** Public camel-case form of an authoritative Managed Agents object. */
+export type AnthropicAgentResource = CamelCasedPropertiesDeep<Beta.BetaManagedAgentsAgent> & Encodable;
+/** Public camel-case form of an authoritative Managed Agents environment. */
+export type AnthropicEnvironmentResource = CamelCasedPropertiesDeep<Beta.BetaEnvironment> & Encodable;
+/** Public camel-case form of an authoritative Managed Agents session. */
+export type AnthropicSessionResource = CamelCasedPropertiesDeep<Beta.BetaManagedAgentsSession> & Encodable;
+/** Authoritative resource type carried by one provider event type. */
+type AnthropicEventResource<TType extends AnthropicWebhookType> = TType extends `${string}.deleted` ? null : TType extends `agent.${string}` ? AnthropicAgentResource : TType extends `environment.${string}` ? AnthropicEnvironmentResource : AnthropicSessionResource;
+/** Thread identifier presence carried by one provider event type. */
+type AnthropicEventThreadId<TType extends AnthropicWebhookType> = TType extends "session.thread_created" | "session.thread_idled" | "session.thread_terminated" ? string : null;
+/** Exact public payload for one Managed Agents webhook type. */
+export type AnthropicSemanticEvent<TType extends AnthropicWebhookType> = TType extends AnthropicWebhookType ? {
+    createdAt: string;
+    id: string;
+    idleEvent: TType extends "session.status_idled" ? z.output<typeof ANTHROPIC_IDLE_EVENT_SCHEMA> : null;
+    organizationId: string;
+    providerEventType: TType;
+    resource: AnthropicEventResource<TType>;
+    resourceId: string;
+    sessionThreadId: AnthropicEventThreadId<TType>;
+    workspaceId: string;
+} : never;
+export type AnthropicAgentEvent = AnthropicSemanticEvent<(typeof ANTHROPIC_AGENT_WEBHOOK_TYPES)[number]>;
+export type AnthropicEnvironmentEvent = AnthropicSemanticEvent<(typeof ANTHROPIC_ENVIRONMENT_WEBHOOK_TYPES)[number]>;
+export type AnthropicSessionEvent = AnthropicSemanticEvent<(typeof ANTHROPIC_SESSION_WEBHOOK_TYPES)[number]>;
+export type AnthropicEvent = AnthropicSemanticEvent<AnthropicWebhookType>;
+export type AnthropicRunEvent = AnthropicSemanticEvent<"session.status_idled" | "session.status_terminated">;
+export declare const ANTHROPIC_AGENT_EVENT_SCHEMA: z.ZodType<AnthropicAgentEvent>;
+export declare const ANTHROPIC_ENVIRONMENT_EVENT_SCHEMA: z.ZodType<AnthropicEnvironmentEvent>;
+export declare const ANTHROPIC_SESSION_EVENT_SCHEMA: z.ZodType<AnthropicSessionEvent>;
+export declare const ANTHROPIC_RUN_EVENT_SCHEMA: z.ZodType<AnthropicRunEvent>;
+export declare const ANTHROPIC_EVENT_SCHEMA: z.ZodType<AnthropicEvent>;
+export declare const anthropicEventTypeMap: {
+    readonly "agent.archived": "anthropic.agent.archived";
+    readonly "agent.created": "anthropic.agent.created";
+    readonly "agent.deleted": "anthropic.agent.deleted";
+    readonly "agent.updated": "anthropic.agent.updated";
+    readonly "environment.archived": "anthropic.environment.archived";
+    readonly "environment.created": "anthropic.environment.created";
+    readonly "environment.deleted": "anthropic.environment.deleted";
+    readonly "environment.updated": "anthropic.environment.updated";
+    readonly "session.budget_reached": "anthropic.session.budgetReached";
+    readonly "session.deleted": "anthropic.session.deleted";
+    readonly "session.outcome_evaluation_ended": "anthropic.session.outcomeEvaluationEnded";
+    readonly "session.status_idled": "anthropic.session.idled";
+    readonly "session.status_rescheduled": "anthropic.session.rescheduled";
+    readonly "session.status_run_started": "anthropic.session.runStarted";
+    readonly "session.status_terminated": "anthropic.session.terminated";
+    readonly "session.thread_created": "anthropic.session.threadCreated";
+    readonly "session.thread_idled": "anthropic.session.threadIdled";
+    readonly "session.thread_terminated": "anthropic.session.threadTerminated";
+    readonly "session.updated": "anthropic.session.updated";
+};
+export declare const ANTHROPIC_BROAD_EVENT_TYPES: {
+    readonly agent: "anthropic.agent.event";
+    readonly environment: "anthropic.environment.event";
+    readonly session: "anthropic.session.event";
+};
+type AnthropicTriggerEventTypes = {
+    readonly "anthropic.agent.archived": AnthropicSemanticEvent<"agent.archived">;
+    readonly "anthropic.agent.created": AnthropicSemanticEvent<"agent.created">;
+    readonly "anthropic.agent.deleted": AnthropicSemanticEvent<"agent.deleted">;
+    readonly "anthropic.agent.event": AnthropicAgentEvent;
+    readonly "anthropic.agent.updated": AnthropicSemanticEvent<"agent.updated">;
+    readonly "anthropic.environment.archived": AnthropicSemanticEvent<"environment.archived">;
+    readonly "anthropic.environment.created": AnthropicSemanticEvent<"environment.created">;
+    readonly "anthropic.environment.deleted": AnthropicSemanticEvent<"environment.deleted">;
+    readonly "anthropic.environment.event": AnthropicEnvironmentEvent;
+    readonly "anthropic.environment.updated": AnthropicSemanticEvent<"environment.updated">;
+    readonly "anthropic.session.budgetReached": AnthropicSemanticEvent<"session.budget_reached">;
+    readonly "anthropic.session.deleted": AnthropicSemanticEvent<"session.deleted">;
+    readonly "anthropic.session.event": AnthropicSessionEvent;
+    readonly "anthropic.session.idled": AnthropicSemanticEvent<"session.status_idled">;
+    readonly "anthropic.session.outcomeEvaluationEnded": AnthropicSemanticEvent<"session.outcome_evaluation_ended">;
+    readonly "anthropic.session.rescheduled": AnthropicSemanticEvent<"session.status_rescheduled">;
+    readonly "anthropic.session.runStarted": AnthropicSemanticEvent<"session.status_run_started">;
+    readonly "anthropic.session.terminated": AnthropicSemanticEvent<"session.status_terminated">;
+    readonly "anthropic.session.threadCreated": AnthropicSemanticEvent<"session.thread_created">;
+    readonly "anthropic.session.threadIdled": AnthropicSemanticEvent<"session.thread_idled">;
+    readonly "anthropic.session.threadTerminated": AnthropicSemanticEvent<"session.thread_terminated">;
+    readonly "anthropic.session.updated": AnthropicSemanticEvent<"session.updated">;
+};
+/** Named trigger registry shape keeps declaration emission compact. */
+type AnthropicTriggerContracts = {
+    readonly [TType in keyof AnthropicTriggerEventTypes]: {
+        readonly configSchema: typeof ANTHROPIC_TRIGGER_CONFIG_SCHEMA;
+        readonly eventSchema: z.ZodType<AnthropicTriggerEventTypes[TType]>;
+    };
+};
+export declare const anthropicTriggerContracts: AnthropicTriggerContracts;
+/**
+ * Returns the broad and semantic event types for one verified delivery.
+ *
+ * @param type - Provider webhook event type.
+ */
+export declare function getAnthropicEventTypes(type: AnthropicWebhookType): readonly ["anthropic.agent.event" | "anthropic.environment.event" | "anthropic.session.event", "anthropic.agent.archived" | "anthropic.agent.created" | "anthropic.agent.deleted" | "anthropic.agent.updated" | "anthropic.environment.archived" | "anthropic.environment.created" | "anthropic.environment.deleted" | "anthropic.environment.updated" | "anthropic.session.budgetReached" | "anthropic.session.deleted" | "anthropic.session.outcomeEvaluationEnded" | "anthropic.session.idled" | "anthropic.session.rescheduled" | "anthropic.session.runStarted" | "anthropic.session.terminated" | "anthropic.session.threadCreated" | "anthropic.session.threadIdled" | "anthropic.session.threadTerminated" | "anthropic.session.updated"];
+/**
+ * Converts Anthropic provider response keys to the public camelCase contract.
+ *
+ * @param value - Provider response value.
+ */
+export declare function normalizeAnthropicValue(value: unknown): unknown;
+export {};

package/dist/anthropic/index.js

@@ -0,0 +1,261 @@
+import * as z from "zod";
+import { isPlainObject } from "@zachsents/zippy";
+export const ANTHROPIC_SESSION_WEBHOOK_TYPES = [
+    "session.status_run_started",
+    "session.status_idled",
+    "session.budget_reached",
+    "session.status_rescheduled",
+    "session.status_terminated",
+    "session.thread_created",
+    "session.thread_idled",
+    "session.thread_terminated",
+    "session.outcome_evaluation_ended",
+    "session.updated",
+    "session.deleted",
+];
+export const ANTHROPIC_AGENT_WEBHOOK_TYPES = [
+    "agent.created",
+    "agent.updated",
+    "agent.archived",
+    "agent.deleted",
+];
+export const ANTHROPIC_ENVIRONMENT_WEBHOOK_TYPES = [
+    "environment.created",
+    "environment.updated",
+    "environment.archived",
+    "environment.deleted",
+];
+export const ANTHROPIC_WEBHOOK_TYPES = [
+    ...ANTHROPIC_SESSION_WEBHOOK_TYPES,
+    ...ANTHROPIC_AGENT_WEBHOOK_TYPES,
+    ...ANTHROPIC_ENVIRONMENT_WEBHOOK_TYPES,
+];
+export const ANTHROPIC_TRIGGER_CONFIG_SCHEMA = z.object({});
+export const ANTHROPIC_IDLE_EVENT_SCHEMA = z.object({
+    id: z.string(),
+    processedAt: z.iso.datetime(),
+    stopReason: z.discriminatedUnion("type", [
+        z.object({ type: z.literal("end_turn") }),
+        z.object({
+            eventIds: z.string().array(),
+            type: z.literal("requires_action"),
+        }),
+        z.object({ type: z.literal("budget_reached") }),
+        z.object({ type: z.literal("retries_exhausted") }),
+    ]),
+    type: z.literal("session.status_idle"),
+});
+const ANTHROPIC_EVENT_FIELDS = {
+    createdAt: z.iso.datetime(),
+    id: z.string(),
+    organizationId: z.string(),
+    resourceId: z.string(),
+    workspaceId: z.string(),
+};
+const ANTHROPIC_RESOURCE_SCHEMA = z
+    .object({ id: z.string(), type: z.string() })
+    .catchall(z.json());
+const ANTHROPIC_AGENT_RESOURCE_SCHEMA = z.custom((value) => ANTHROPIC_RESOURCE_SCHEMA.safeParse(value).success);
+const ANTHROPIC_ENVIRONMENT_RESOURCE_SCHEMA = z.custom((value) => ANTHROPIC_RESOURCE_SCHEMA.safeParse(value).success);
+const ANTHROPIC_SESSION_RESOURCE_SCHEMA = z.custom((value) => ANTHROPIC_RESOURCE_SCHEMA.safeParse(value).success);
+/**
+ * Builds one exact non-deletion webhook payload schema.
+ *
+ * @param providerEventType - Exact provider event discriminator.
+ * @param resource - Authoritative resource schema for the event family.
+ */
+function resourceEventSchema(providerEventType, resource) {
+    return z.object({
+        ...ANTHROPIC_EVENT_FIELDS,
+        idleEvent: z.null(),
+        providerEventType: z.literal(providerEventType),
+        resource,
+        sessionThreadId: z.null(),
+    });
+}
+/**
+ * Builds one exact deletion webhook payload schema.
+ *
+ * @param providerEventType - Exact provider event discriminator.
+ */
+function deletedEventSchema(providerEventType) {
+    return z.object({
+        ...ANTHROPIC_EVENT_FIELDS,
+        idleEvent: z.null(),
+        providerEventType: z.literal(providerEventType),
+        resource: z.null(),
+        sessionThreadId: z.null(),
+    });
+}
+/** Builds the exact enriched session-idled payload schema. */
+function sessionIdledEventSchema() {
+    return z.object({
+        ...ANTHROPIC_EVENT_FIELDS,
+        idleEvent: ANTHROPIC_IDLE_EVENT_SCHEMA,
+        providerEventType: z.literal("session.status_idled"),
+        resource: ANTHROPIC_SESSION_RESOURCE_SCHEMA,
+        sessionThreadId: z.null(),
+    });
+}
+/**
+ * Builds an exact session-thread lifecycle payload schema.
+ *
+ * @param providerEventType - Exact thread event discriminator.
+ */
+function sessionThreadEventSchema(providerEventType) {
+    return z.object({
+        ...ANTHROPIC_EVENT_FIELDS,
+        idleEvent: z.null(),
+        providerEventType: z.literal(providerEventType),
+        resource: ANTHROPIC_SESSION_RESOURCE_SCHEMA,
+        sessionThreadId: z.string(),
+    });
+}
+const ANTHROPIC_EVENT_SCHEMAS = {
+    "agent.archived": resourceEventSchema("agent.archived", ANTHROPIC_AGENT_RESOURCE_SCHEMA),
+    "agent.created": resourceEventSchema("agent.created", ANTHROPIC_AGENT_RESOURCE_SCHEMA),
+    "agent.deleted": deletedEventSchema("agent.deleted"),
+    "agent.updated": resourceEventSchema("agent.updated", ANTHROPIC_AGENT_RESOURCE_SCHEMA),
+    "environment.archived": resourceEventSchema("environment.archived", ANTHROPIC_ENVIRONMENT_RESOURCE_SCHEMA),
+    "environment.created": resourceEventSchema("environment.created", ANTHROPIC_ENVIRONMENT_RESOURCE_SCHEMA),
+    "environment.deleted": deletedEventSchema("environment.deleted"),
+    "environment.updated": resourceEventSchema("environment.updated", ANTHROPIC_ENVIRONMENT_RESOURCE_SCHEMA),
+    "session.budget_reached": resourceEventSchema("session.budget_reached", ANTHROPIC_SESSION_RESOURCE_SCHEMA),
+    "session.deleted": deletedEventSchema("session.deleted"),
+    "session.outcome_evaluation_ended": resourceEventSchema("session.outcome_evaluation_ended", ANTHROPIC_SESSION_RESOURCE_SCHEMA),
+    "session.status_idled": sessionIdledEventSchema(),
+    "session.status_rescheduled": resourceEventSchema("session.status_rescheduled", ANTHROPIC_SESSION_RESOURCE_SCHEMA),
+    "session.status_run_started": resourceEventSchema("session.status_run_started", ANTHROPIC_SESSION_RESOURCE_SCHEMA),
+    "session.status_terminated": resourceEventSchema("session.status_terminated", ANTHROPIC_SESSION_RESOURCE_SCHEMA),
+    "session.thread_created": sessionThreadEventSchema("session.thread_created"),
+    "session.thread_idled": sessionThreadEventSchema("session.thread_idled"),
+    "session.thread_terminated": sessionThreadEventSchema("session.thread_terminated"),
+    "session.updated": resourceEventSchema("session.updated", ANTHROPIC_SESSION_RESOURCE_SCHEMA),
+};
+export const ANTHROPIC_AGENT_EVENT_SCHEMA = z.union([
+    ANTHROPIC_EVENT_SCHEMAS["agent.archived"],
+    ANTHROPIC_EVENT_SCHEMAS["agent.created"],
+    ANTHROPIC_EVENT_SCHEMAS["agent.deleted"],
+    ANTHROPIC_EVENT_SCHEMAS["agent.updated"],
+]);
+export const ANTHROPIC_ENVIRONMENT_EVENT_SCHEMA = z.union([
+    ANTHROPIC_EVENT_SCHEMAS["environment.archived"],
+    ANTHROPIC_EVENT_SCHEMAS["environment.created"],
+    ANTHROPIC_EVENT_SCHEMAS["environment.deleted"],
+    ANTHROPIC_EVENT_SCHEMAS["environment.updated"],
+]);
+export const ANTHROPIC_SESSION_EVENT_SCHEMA = z.union([
+    ANTHROPIC_EVENT_SCHEMAS["session.budget_reached"],
+    ANTHROPIC_EVENT_SCHEMAS["session.deleted"],
+    ANTHROPIC_EVENT_SCHEMAS["session.outcome_evaluation_ended"],
+    ANTHROPIC_EVENT_SCHEMAS["session.status_idled"],
+    ANTHROPIC_EVENT_SCHEMAS["session.status_rescheduled"],
+    ANTHROPIC_EVENT_SCHEMAS["session.status_run_started"],
+    ANTHROPIC_EVENT_SCHEMAS["session.status_terminated"],
+    ANTHROPIC_EVENT_SCHEMAS["session.thread_created"],
+    ANTHROPIC_EVENT_SCHEMAS["session.thread_idled"],
+    ANTHROPIC_EVENT_SCHEMAS["session.thread_terminated"],
+    ANTHROPIC_EVENT_SCHEMAS["session.updated"],
+]);
+export const ANTHROPIC_RUN_EVENT_SCHEMA = z.union([
+    ANTHROPIC_EVENT_SCHEMAS["session.status_idled"],
+    ANTHROPIC_EVENT_SCHEMAS["session.status_terminated"],
+]);
+export const ANTHROPIC_EVENT_SCHEMA = z.union([
+    ANTHROPIC_AGENT_EVENT_SCHEMA,
+    ANTHROPIC_ENVIRONMENT_EVENT_SCHEMA,
+    ANTHROPIC_SESSION_EVENT_SCHEMA,
+]);
+export const anthropicEventTypeMap = {
+    "agent.archived": "anthropic.agent.archived",
+    "agent.created": "anthropic.agent.created",
+    "agent.deleted": "anthropic.agent.deleted",
+    "agent.updated": "anthropic.agent.updated",
+    "environment.archived": "anthropic.environment.archived",
+    "environment.created": "anthropic.environment.created",
+    "environment.deleted": "anthropic.environment.deleted",
+    "environment.updated": "anthropic.environment.updated",
+    "session.budget_reached": "anthropic.session.budgetReached",
+    "session.deleted": "anthropic.session.deleted",
+    "session.outcome_evaluation_ended": "anthropic.session.outcomeEvaluationEnded",
+    "session.status_idled": "anthropic.session.idled",
+    "session.status_rescheduled": "anthropic.session.rescheduled",
+    "session.status_run_started": "anthropic.session.runStarted",
+    "session.status_terminated": "anthropic.session.terminated",
+    "session.thread_created": "anthropic.session.threadCreated",
+    "session.thread_idled": "anthropic.session.threadIdled",
+    "session.thread_terminated": "anthropic.session.threadTerminated",
+    "session.updated": "anthropic.session.updated",
+};
+export const ANTHROPIC_BROAD_EVENT_TYPES = {
+    agent: "anthropic.agent.event",
+    environment: "anthropic.environment.event",
+    session: "anthropic.session.event",
+};
+/**
+ * Binds one event schema to the shared Managed Agents trigger configuration.
+ *
+ * @param eventSchema - Family or semantic event schema.
+ */
+function triggerContract(eventSchema) {
+    return { configSchema: ANTHROPIC_TRIGGER_CONFIG_SCHEMA, eventSchema };
+}
+export const anthropicTriggerContracts = {
+    "anthropic.agent.archived": triggerContract(ANTHROPIC_EVENT_SCHEMAS["agent.archived"]),
+    "anthropic.agent.created": triggerContract(ANTHROPIC_EVENT_SCHEMAS["agent.created"]),
+    "anthropic.agent.deleted": triggerContract(ANTHROPIC_EVENT_SCHEMAS["agent.deleted"]),
+    "anthropic.agent.event": triggerContract(ANTHROPIC_AGENT_EVENT_SCHEMA),
+    "anthropic.agent.updated": triggerContract(ANTHROPIC_EVENT_SCHEMAS["agent.updated"]),
+    "anthropic.environment.archived": triggerContract(ANTHROPIC_EVENT_SCHEMAS["environment.archived"]),
+    "anthropic.environment.created": triggerContract(ANTHROPIC_EVENT_SCHEMAS["environment.created"]),
+    "anthropic.environment.deleted": triggerContract(ANTHROPIC_EVENT_SCHEMAS["environment.deleted"]),
+    "anthropic.environment.event": triggerContract(ANTHROPIC_ENVIRONMENT_EVENT_SCHEMA),
+    "anthropic.environment.updated": triggerContract(ANTHROPIC_EVENT_SCHEMAS["environment.updated"]),
+    "anthropic.session.budgetReached": triggerContract(ANTHROPIC_EVENT_SCHEMAS["session.budget_reached"]),
+    "anthropic.session.deleted": triggerContract(ANTHROPIC_EVENT_SCHEMAS["session.deleted"]),
+    "anthropic.session.event": triggerContract(ANTHROPIC_SESSION_EVENT_SCHEMA),
+    "anthropic.session.idled": triggerContract(ANTHROPIC_EVENT_SCHEMAS["session.status_idled"]),
+    "anthropic.session.outcomeEvaluationEnded": triggerContract(ANTHROPIC_EVENT_SCHEMAS["session.outcome_evaluation_ended"]),
+    "anthropic.session.rescheduled": triggerContract(ANTHROPIC_EVENT_SCHEMAS["session.status_rescheduled"]),
+    "anthropic.session.runStarted": triggerContract(ANTHROPIC_EVENT_SCHEMAS["session.status_run_started"]),
+    "anthropic.session.terminated": triggerContract(ANTHROPIC_EVENT_SCHEMAS["session.status_terminated"]),
+    "anthropic.session.threadCreated": triggerContract(ANTHROPIC_EVENT_SCHEMAS["session.thread_created"]),
+    "anthropic.session.threadIdled": triggerContract(ANTHROPIC_EVENT_SCHEMAS["session.thread_idled"]),
+    "anthropic.session.threadTerminated": triggerContract(ANTHROPIC_EVENT_SCHEMAS["session.thread_terminated"]),
+    "anthropic.session.updated": triggerContract(ANTHROPIC_EVENT_SCHEMAS["session.updated"]),
+};
+/**
+ * Returns the broad and semantic event types for one verified delivery.
+ *
+ * @param type - Provider webhook event type.
+ */
+export function getAnthropicEventTypes(type) {
+    return [
+        type.startsWith("agent.")
+            ? ANTHROPIC_BROAD_EVENT_TYPES.agent
+            : type.startsWith("environment.")
+                ? ANTHROPIC_BROAD_EVENT_TYPES.environment
+                : ANTHROPIC_BROAD_EVENT_TYPES.session,
+        anthropicEventTypeMap[type],
+    ];
+}
+/**
+ * Converts Anthropic provider response keys to the public camelCase contract.
+ *
+ * @param value - Provider response value.
+ */
+export function normalizeAnthropicValue(value) {
+    if (Array.isArray(value))
+        return value.map(normalizeAnthropicValue);
+    if (!isPlainObject(value))
+        return value;
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => {
+        const publicKey = key.replace(/_([a-z0-9])/g, (_match, character) => character.toUpperCase());
+        return [
+            publicKey,
+            ["input", "inputSchema", "metadata"].includes(publicKey)
+                ? item
+                : normalizeAnthropicValue(item),
+        ];
+    }));
+}

package/dist/automate/index.d.ts

@@ -249,8 +249,8 @@ export declare const AUTOMATE_EXECUTION_EVENT_SCHEMA: z.ZodObject<{
         id: z.ZodString;
         settledAt: z.ZodNullable<z.ZodDate>;
         status: z.ZodEnum<{
-            failed: "failed";
             running: "running";
+            failed: "failed";
             settled: "settled";
         }>;
     }, z.core.$strip>;
@@ -385,9 +385,9 @@ export declare const AUTOMATE_ACTION_ATTEMPT_EVENT_SCHEMA: z.ZodObject<{
         retryAt: z.ZodNullable<z.ZodDate>;
         startedAt: z.ZodDate;
         status: z.ZodEnum<{
+            running: "running";
             succeeded: "succeeded";
             failed: "failed";
-            running: "running";
             retrying: "retrying";
             indeterminate: "indeterminate";
         }>;
@@ -860,9 +860,9 @@ export declare const automateTriggerContracts: {
                 retryAt: z.ZodNullable<z.ZodDate>;
                 startedAt: z.ZodDate;
                 status: z.ZodEnum<{
+                    running: "running";
                     succeeded: "succeeded";
                     failed: "failed";
-                    running: "running";
                     retrying: "retrying";
                     indeterminate: "indeterminate";
                 }>;
@@ -1167,8 +1167,8 @@ export declare const automateTriggerContracts: {
                 id: z.ZodString;
                 settledAt: z.ZodNullable<z.ZodDate>;
                 status: z.ZodEnum<{
-                    failed: "failed";
                     running: "running";
+                    failed: "failed";
                     settled: "settled";
                 }>;
             }, z.core.$strip>;

package/dist/close/events.d.ts

@@ -120,8 +120,8 @@ export declare const closeTriggerContracts: {
                     External: "External";
                 }>>;
                 status: z.ZodOptional<z.ZodEnum<{
-                    failed: "failed";
                     created: "created";
+                    failed: "failed";
                     completed: "completed";
                     timeout: "timeout";
                     busy: "busy";
@@ -193,8 +193,8 @@ export declare const closeTriggerContracts: {
                     External: "External";
                 }>>;
                 status: z.ZodOptional<z.ZodEnum<{
-                    failed: "failed";
                     created: "created";
+                    failed: "failed";
                     completed: "completed";
                     timeout: "timeout";
                     busy: "busy";

package/dist/close/schemas.d.ts

@@ -836,8 +836,8 @@ export declare const CLOSE_CALL_SCHEMA: z.ZodObject<{
         External: "External";
     }>;
     status: z.ZodEnum<{
-        failed: "failed";
         created: "created";
+        failed: "failed";
         completed: "completed";
         timeout: "timeout";
         busy: "busy";
@@ -1066,8 +1066,8 @@ export declare const CLOSE_ACTIVITY_SCHEMA: z.ZodDiscriminatedUnion<[z.ZodObject
         External: "External";
     }>;
     status: z.ZodEnum<{
-        failed: "failed";
         created: "created";
+        failed: "failed";
         completed: "completed";
         timeout: "timeout";
         busy: "busy";

package/dist/gmail/schemas.d.ts

@@ -842,8 +842,8 @@ export declare const LABEL_SCHEMA: z.ZodObject<{
     threadsTotal: z.ZodOptional<z.ZodNumber>;
     threadsUnread: z.ZodOptional<z.ZodNumber>;
     type: z.ZodOptional<z.ZodEnum<{
-        user: "user";
         system: "system";
+        user: "user";
     }>>;
 }, z.core.$strip>;
 export declare const PROFILE_SCHEMA: z.ZodObject<{

package/dist/google-drive/index.d.ts

@@ -40,8 +40,8 @@ export declare const GOOGLE_DRIVE_PROVIDER_EVENT_TYPES: {
 export type GoogleDriveProviderEventType = (typeof GOOGLE_DRIVE_PROVIDER_EVENT_TYPES)[GoogleDriveTriggerType];
 export declare const GOOGLE_DRIVE_EVENT_SCHEMA: z.ZodObject<{
     action: z.ZodEnum<{
-        cancelled: "cancelled";
         created: "created";
+        cancelled: "cancelled";
         completed: "completed";
         deleted: "deleted";
         moved: "moved";
@@ -954,8 +954,8 @@ export declare const googleDriveTriggerContracts: {
         }, z.core.$strip>;
         eventSchema: z.ZodObject<{
             action: z.ZodEnum<{
-                cancelled: "cancelled";
                 created: "created";
+                cancelled: "cancelled";
                 completed: "completed";
                 deleted: "deleted";
                 moved: "moved";
@@ -1038,7 +1038,7 @@ export declare function toGoogleDriveTriggerType(providerEventType: string): Goo
  * @param eventType - Stable internal semantic event type.
  */
 export declare function parseGoogleDriveTriggerType(eventType: GoogleDriveTriggerType): {
-    action: "cancelled" | "created" | "completed" | "deleted" | "moved" | "contentChanged" | "edited" | "reopened" | "renamed" | "reset" | "resolved" | "responded" | "reviewersChanged" | "trashed" | "untrashed";
+    action: "created" | "cancelled" | "completed" | "deleted" | "moved" | "contentChanged" | "edited" | "reopened" | "renamed" | "reset" | "resolved" | "responded" | "reviewersChanged" | "trashed" | "untrashed";
     resourceType: "file" | "reply" | "comment" | "accessProposal" | "approval" | "permission";
 };
 export {};

package/dist/linear/schemas.d.ts

@@ -4392,7 +4392,9 @@ export declare const LINEAR_ISSUE_RELATION_SCHEMA: z.ZodObject<{
 }, z.core.$strip>;
 export declare const LINEAR_PROVIDER_PROJECT_SCHEMA: z.ZodObject<{
     id: z.ZodString;
-    startedAt: z.ZodNullable<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>]>>;
+    description: z.ZodString;
+    name: z.ZodString;
+    scope: z.ZodNumber;
     status: z.ZodObject<{
         color: z.ZodString;
         description: z.ZodNullable<z.ZodString>;
@@ -4401,12 +4403,12 @@ export declare const LINEAR_PROVIDER_PROJECT_SCHEMA: z.ZodObject<{
         type: z.ZodString;
     }, z.core.$strip>;
     createdAt: z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>]>;
-    description: z.ZodString;
-    name: z.ZodString;
+    archivedAt: z.ZodNullable<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>]>>;
+    updatedAt: z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>]>;
+    startedAt: z.ZodNullable<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>]>>;
     completedAt: z.ZodNullable<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>]>>;
     url: z.ZodString;
     priority: z.ZodNumber;
-    updatedAt: z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>]>;
     state: z.ZodString;
     color: z.ZodString;
     content: z.ZodNullable<z.ZodString>;
@@ -4428,9 +4430,7 @@ export declare const LINEAR_PROVIDER_PROJECT_SCHEMA: z.ZodObject<{
         id: z.ZodString;
         name: z.ZodString;
     }, z.core.$strip>>;
-    scope: z.ZodNumber;
     progress: z.ZodNumber;
-    archivedAt: z.ZodNullable<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>]>>;
     canceledAt: z.ZodNullable<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>]>>;
     priorityLabel: z.ZodString;
     slugId: z.ZodString;
@@ -4470,10 +4470,12 @@ export declare const LINEAR_PROVIDER_PROJECT_SCHEMA: z.ZodObject<{
 export declare const LINEAR_PROVIDER_ISSUE_SCHEMA: z.ZodObject<{
     number: z.ZodNumber;
     id: z.ZodString;
-    startedAt: z.ZodNullable<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>]>>;
-    createdAt: z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>]>;
-    title: z.ZodString;
     description: z.ZodNullable<z.ZodString>;
+    title: z.ZodString;
+    createdAt: z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>]>;
+    archivedAt: z.ZodNullable<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>]>>;
+    updatedAt: z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>]>;
+    startedAt: z.ZodNullable<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>]>>;
     project: z.ZodNullable<z.ZodObject<{
         id: z.ZodString;
         name: z.ZodString;
@@ -4483,7 +4485,6 @@ export declare const LINEAR_PROVIDER_ISSUE_SCHEMA: z.ZodObject<{
     completedAt: z.ZodNullable<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>]>>;
     url: z.ZodString;
     priority: z.ZodNumber;
-    updatedAt: z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>]>;
     state: z.ZodObject<{
         color: z.ZodString;
         id: z.ZodString;
@@ -4520,7 +4521,6 @@ export declare const LINEAR_PROVIDER_ISSUE_SCHEMA: z.ZodObject<{
         name: z.ZodString;
     }, z.core.$strip>>;
     trashed: z.ZodNullable<z.ZodBoolean>;
-    archivedAt: z.ZodNullable<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>]>>;
     identifier: z.ZodString;
     canceledAt: z.ZodNullable<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>]>>;
     estimate: z.ZodNullable<z.ZodNumber>;