@meetkai/mka1 0.54.48 → 0.54.49

package/src/mcp-server/tools/flagsEnvironmentsGenerateEvaluationKey.ts

@@ -0,0 +1,39 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { flagsEnvironmentsGenerateEvaluationKey } from "../../funcs/flagsEnvironmentsGenerateEvaluationKey.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.GenerateFeatureFlagEvaluationKeyRequest$inboundSchema,
+};
+
+export const tool$flagsEnvironmentsGenerateEvaluationKey: ToolDefinition<
+  typeof args
+> = {
+  name: "flags-environments-generate-evaluation-key",
+  description: `Generate or replace an environment evaluation key
+
+Returns the new plaintext key once. Only its SHA-256 digest is stored; generating another key immediately replaces the previous credential on this replica.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await flagsEnvironmentsGenerateEvaluationKey(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value.result;
+
+    return formatResult(value, apiCall);
+  },
+};

package/src/mcp-server/tools/flagsEnvironmentsList.ts

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { flagsEnvironmentsList } from "../../funcs/flagsEnvironmentsList.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.ListFeatureFlagEnvironmentsRequest$inboundSchema,
+};
+
+export const tool$flagsEnvironmentsList: ToolDefinition<typeof args> = {
+  name: "flags-environments-list",
+  description: `List environments`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await flagsEnvironmentsList(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

package/src/mcp-server/tools/flagsEnvironmentsRevokeEvaluationKey.ts

@@ -0,0 +1,37 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { flagsEnvironmentsRevokeEvaluationKey } from "../../funcs/flagsEnvironmentsRevokeEvaluationKey.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.RevokeFeatureFlagEvaluationKeyRequest$inboundSchema,
+};
+
+export const tool$flagsEnvironmentsRevokeEvaluationKey: ToolDefinition<
+  typeof args
+> = {
+  name: "flags-environments-revoke-evaluation-key",
+  description: `Revoke an environment evaluation key
+
+Revocation is idempotent while the environment exists.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await flagsEnvironmentsRevokeEvaluationKey(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    return formatResult(void 0, apiCall);
+  },
+};

package/src/mcp-server/tools/flagsEnvironmentsUpdate.ts

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { flagsEnvironmentsUpdate } from "../../funcs/flagsEnvironmentsUpdate.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.UpdateFeatureFlagEnvironmentRequest$inboundSchema,
+};
+
+export const tool$flagsEnvironmentsUpdate: ToolDefinition<typeof args> = {
+  name: "flags-environments-update",
+  description: `Rename an environment`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await flagsEnvironmentsUpdate(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

package/src/mcp-server/tools/flagsGet.ts

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { flagsGet } from "../../funcs/flagsGet.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.GetFeatureFlagRequest$inboundSchema,
+};
+
+export const tool$flagsGet: ToolDefinition<typeof args> = {
+  name: "flags-get",
+  description: `Get a flag`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await flagsGet(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

package/src/mcp-server/tools/flagsList.ts

@@ -0,0 +1,37 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { flagsList } from "../../funcs/flagsList.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.ListFeatureFlagsRequest$inboundSchema,
+};
+
+export const tool$flagsList: ToolDefinition<typeof args> = {
+  name: "flags-list",
+  description: `List flags
+
+Every flag with a per-environment digest of its state.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await flagsList(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

package/src/mcp-server/tools/flagsSetEnvironmentState.ts

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { flagsSetEnvironmentState } from "../../funcs/flagsSetEnvironmentState.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.SetFeatureFlagEnvironmentStateRequest$inboundSchema,
+};
+
+export const tool$flagsSetEnvironmentState: ToolDefinition<typeof args> = {
+  name: "flags-set-environment-state",
+  description: `Replace a flag's settings in one environment`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await flagsSetEnvironmentState(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value.result;
+
+    return formatResult(value, apiCall);
+  },
+};

package/src/mcp-server/tools/flagsUnarchive.ts

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { flagsUnarchive } from "../../funcs/flagsUnarchive.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.UnarchiveFeatureFlagRequest$inboundSchema,
+};
+
+export const tool$flagsUnarchive: ToolDefinition<typeof args> = {
+  name: "flags-unarchive",
+  description: `Restore an archived flag`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await flagsUnarchive(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

package/src/mcp-server/tools/flagsUpdate.ts

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { flagsUpdate } from "../../funcs/flagsUpdate.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.UpdateFeatureFlagRequest$inboundSchema,
+};
+
+export const tool$flagsUpdate: ToolDefinition<typeof args> = {
+  name: "flags-update",
+  description: `Update a flag's name, description, or default value`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await flagsUpdate(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

package/src/models/components/featureflagauditentry.ts

@@ -0,0 +1,136 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type FeatureFlagAuditEntry = {
+  action: string;
+  actor: string;
+  actorApiKeyId: string;
+  actorOrgId: string;
+  actorTeamId: string;
+  actorUserId: string;
+  actorUserType: string;
+  /**
+   * Any JSON value; its shape is constrained by the flag's value_type.
+   */
+  after?: any | undefined;
+  /**
+   * Any JSON value; its shape is constrained by the flag's value_type.
+   */
+  before?: any | undefined;
+  entityKey: string;
+  entityType: string;
+  id: number;
+  occurredAt: Date;
+  requestId: string;
+};
+
+/** @internal */
+export const FeatureFlagAuditEntry$inboundSchema: z.ZodType<
+  FeatureFlagAuditEntry,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  action: z.string(),
+  actor: z.string(),
+  actor_api_key_id: z.string(),
+  actor_org_id: z.string(),
+  actor_team_id: z.string(),
+  actor_user_id: z.string(),
+  actor_user_type: z.string(),
+  after: z.any().optional(),
+  before: z.any().optional(),
+  entity_key: z.string(),
+  entity_type: z.string(),
+  id: z.number().int(),
+  occurred_at: z.string().datetime({ offset: true }).transform(v =>
+    new Date(v)
+  ),
+  request_id: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "actor_api_key_id": "actorApiKeyId",
+    "actor_org_id": "actorOrgId",
+    "actor_team_id": "actorTeamId",
+    "actor_user_id": "actorUserId",
+    "actor_user_type": "actorUserType",
+    "entity_key": "entityKey",
+    "entity_type": "entityType",
+    "occurred_at": "occurredAt",
+    "request_id": "requestId",
+  });
+});
+/** @internal */
+export type FeatureFlagAuditEntry$Outbound = {
+  action: string;
+  actor: string;
+  actor_api_key_id: string;
+  actor_org_id: string;
+  actor_team_id: string;
+  actor_user_id: string;
+  actor_user_type: string;
+  after?: any | undefined;
+  before?: any | undefined;
+  entity_key: string;
+  entity_type: string;
+  id: number;
+  occurred_at: string;
+  request_id: string;
+};
+
+/** @internal */
+export const FeatureFlagAuditEntry$outboundSchema: z.ZodType<
+  FeatureFlagAuditEntry$Outbound,
+  z.ZodTypeDef,
+  FeatureFlagAuditEntry
+> = z.object({
+  action: z.string(),
+  actor: z.string(),
+  actorApiKeyId: z.string(),
+  actorOrgId: z.string(),
+  actorTeamId: z.string(),
+  actorUserId: z.string(),
+  actorUserType: z.string(),
+  after: z.any().optional(),
+  before: z.any().optional(),
+  entityKey: z.string(),
+  entityType: z.string(),
+  id: z.number().int(),
+  occurredAt: z.date().transform(v => v.toISOString()),
+  requestId: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    actorApiKeyId: "actor_api_key_id",
+    actorOrgId: "actor_org_id",
+    actorTeamId: "actor_team_id",
+    actorUserId: "actor_user_id",
+    actorUserType: "actor_user_type",
+    entityKey: "entity_key",
+    entityType: "entity_type",
+    occurredAt: "occurred_at",
+    requestId: "request_id",
+  });
+});
+
+export function featureFlagAuditEntryToJSON(
+  featureFlagAuditEntry: FeatureFlagAuditEntry,
+): string {
+  return JSON.stringify(
+    FeatureFlagAuditEntry$outboundSchema.parse(featureFlagAuditEntry),
+  );
+}
+export function featureFlagAuditEntryFromJSON(
+  jsonString: string,
+): SafeParseResult<FeatureFlagAuditEntry, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FeatureFlagAuditEntry$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FeatureFlagAuditEntry' from JSON`,
+  );
+}

package/src/models/components/featureflagauditpage.ts

@@ -0,0 +1,73 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  FeatureFlagAuditEntry,
+  FeatureFlagAuditEntry$inboundSchema,
+  FeatureFlagAuditEntry$Outbound,
+  FeatureFlagAuditEntry$outboundSchema,
+} from "./featureflagauditentry.js";
+
+export type FeatureFlagAuditPage = {
+  entries: Array<FeatureFlagAuditEntry>;
+  /**
+   * Pass as `before` to read the next page. Null when the log is exhausted, including when this page happened to be exactly full.
+   */
+  nextBefore: number | null;
+};
+
+/** @internal */
+export const FeatureFlagAuditPage$inboundSchema: z.ZodType<
+  FeatureFlagAuditPage,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  entries: z.array(FeatureFlagAuditEntry$inboundSchema),
+  next_before: z.nullable(z.number().int()),
+}).transform((v) => {
+  return remap$(v, {
+    "next_before": "nextBefore",
+  });
+});
+/** @internal */
+export type FeatureFlagAuditPage$Outbound = {
+  entries: Array<FeatureFlagAuditEntry$Outbound>;
+  next_before: number | null;
+};
+
+/** @internal */
+export const FeatureFlagAuditPage$outboundSchema: z.ZodType<
+  FeatureFlagAuditPage$Outbound,
+  z.ZodTypeDef,
+  FeatureFlagAuditPage
+> = z.object({
+  entries: z.array(FeatureFlagAuditEntry$outboundSchema),
+  nextBefore: z.nullable(z.number().int()),
+}).transform((v) => {
+  return remap$(v, {
+    nextBefore: "next_before",
+  });
+});
+
+export function featureFlagAuditPageToJSON(
+  featureFlagAuditPage: FeatureFlagAuditPage,
+): string {
+  return JSON.stringify(
+    FeatureFlagAuditPage$outboundSchema.parse(featureFlagAuditPage),
+  );
+}
+export function featureFlagAuditPageFromJSON(
+  jsonString: string,
+): SafeParseResult<FeatureFlagAuditPage, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FeatureFlagAuditPage$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FeatureFlagAuditPage' from JSON`,
+  );
+}

package/src/models/components/featureflagcondition.ts

@@ -0,0 +1,67 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  FeatureFlagOperator,
+  FeatureFlagOperator$inboundSchema,
+  FeatureFlagOperator$outboundSchema,
+} from "./featureflagoperator.js";
+
+export type FeatureFlagCondition = {
+  operator: FeatureFlagOperator;
+  trait: string;
+  /**
+   * Any JSON value; its shape is constrained by the flag's value_type.
+   */
+  value?: any | undefined;
+};
+
+/** @internal */
+export const FeatureFlagCondition$inboundSchema: z.ZodType<
+  FeatureFlagCondition,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  operator: FeatureFlagOperator$inboundSchema,
+  trait: z.string(),
+  value: z.any().optional(),
+});
+/** @internal */
+export type FeatureFlagCondition$Outbound = {
+  operator: string;
+  trait: string;
+  value?: any | undefined;
+};
+
+/** @internal */
+export const FeatureFlagCondition$outboundSchema: z.ZodType<
+  FeatureFlagCondition$Outbound,
+  z.ZodTypeDef,
+  FeatureFlagCondition
+> = z.object({
+  operator: FeatureFlagOperator$outboundSchema,
+  trait: z.string(),
+  value: z.any().optional(),
+});
+
+export function featureFlagConditionToJSON(
+  featureFlagCondition: FeatureFlagCondition,
+): string {
+  return JSON.stringify(
+    FeatureFlagCondition$outboundSchema.parse(featureFlagCondition),
+  );
+}
+export function featureFlagConditionFromJSON(
+  jsonString: string,
+): SafeParseResult<FeatureFlagCondition, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FeatureFlagCondition$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FeatureFlagCondition' from JSON`,
+  );
+}

package/src/models/components/featureflagcreaterequest.ts

@@ -0,0 +1,86 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  FeatureFlagValueType,
+  FeatureFlagValueType$inboundSchema,
+  FeatureFlagValueType$outboundSchema,
+} from "./featureflagvaluetype.js";
+
+export type FeatureFlagCreateRequest = {
+  /**
+   * Any JSON value; its shape is constrained by the flag's value_type.
+   */
+  defaultValue?: any | undefined;
+  description?: string | undefined;
+  key: string;
+  name: string;
+  valueType: FeatureFlagValueType;
+};
+
+/** @internal */
+export const FeatureFlagCreateRequest$inboundSchema: z.ZodType<
+  FeatureFlagCreateRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  default_value: z.any().optional(),
+  description: z.string().optional(),
+  key: z.string(),
+  name: z.string(),
+  value_type: FeatureFlagValueType$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "default_value": "defaultValue",
+    "value_type": "valueType",
+  });
+});
+/** @internal */
+export type FeatureFlagCreateRequest$Outbound = {
+  default_value?: any | undefined;
+  description?: string | undefined;
+  key: string;
+  name: string;
+  value_type: string;
+};
+
+/** @internal */
+export const FeatureFlagCreateRequest$outboundSchema: z.ZodType<
+  FeatureFlagCreateRequest$Outbound,
+  z.ZodTypeDef,
+  FeatureFlagCreateRequest
+> = z.object({
+  defaultValue: z.any().optional(),
+  description: z.string().optional(),
+  key: z.string(),
+  name: z.string(),
+  valueType: FeatureFlagValueType$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    defaultValue: "default_value",
+    valueType: "value_type",
+  });
+});
+
+export function featureFlagCreateRequestToJSON(
+  featureFlagCreateRequest: FeatureFlagCreateRequest,
+): string {
+  return JSON.stringify(
+    FeatureFlagCreateRequest$outboundSchema.parse(featureFlagCreateRequest),
+  );
+}
+export function featureFlagCreateRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<FeatureFlagCreateRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FeatureFlagCreateRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FeatureFlagCreateRequest' from JSON`,
+  );
+}