@gleanwork/api-client 0.9.1 → 0.10.1

package/src/__tests__/collections.test.ts

@@ -277,8 +277,8 @@ test("Collections Createcollection", async () => {
                   nativeAppUrl: "slack://foo/bar",
                   snippets: [
                     {
-                      snippet: "snippet",
                       mimeType: "mimeType",
+                      snippet: "snippet",
                     },
                   ],
                 },
@@ -946,8 +946,8 @@ test("Collections Editcollection", async () => {
                   nativeAppUrl: "slack://foo/bar",
                   snippets: [
                     {
-                      snippet: "snippet",
                       mimeType: "mimeType",
+                      snippet: "snippet",
                     },
                   ],
                 },

package/src/__tests__/search.test.ts

@@ -211,8 +211,8 @@ test("Search Recommendations", async () => {
                   nativeAppUrl: "slack://foo/bar",
                   snippets: [
                     {
-                      snippet: "snippet",
                       mimeType: "mimeType",
+                      snippet: "snippet",
                     },
                   ],
                 },

package/src/__tests__/summarize.test.ts

@@ -17,8 +17,14 @@ test("Summarize Summarize", async () => {
 
   const result = await glean.client.documents.summarize({
     documentSpecs: [
-      {},
-      {},
+      {
+        ugcType: "SHORTCUTS",
+        ugcId: "<id>",
+      },
+      {
+        ugcType: "CHATS",
+        ugcId: "<id>",
+      },
     ],
   });
   expect(result).toBeDefined();

package/src/funcs/clientCollectionsCreate.ts

@@ -21,6 +21,7 @@ import {
 } from "../models/errors/httpclienterrors.js";
 import * as errors from "../models/errors/index.js";
 import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import * as operations from "../models/operations/index.js";
 import { APICall, APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
 
@@ -36,7 +37,7 @@ export function clientCollectionsCreate(
   options?: RequestOptions,
 ): APIPromise<
   Result<
-    components.CreateCollectionResponse,
+    operations.CreatecollectionResponse,
     | errors.CollectionError
     | GleanError
     | SDKValidationError
@@ -61,7 +62,7 @@ async function $do(
 ): Promise<
   [
     Result<
-      components.CreateCollectionResponse,
+      operations.CreatecollectionResponse,
       | errors.CollectionError
       | GleanError
       | SDKValidationError
@@ -140,7 +141,7 @@ async function $do(
   };
 
   const [result] = await M.match<
-    components.CreateCollectionResponse,
+    operations.CreatecollectionResponse,
     | errors.CollectionError
     | GleanError
     | SDKValidationError
@@ -150,7 +151,7 @@ async function $do(
     | RequestTimeoutError
     | ConnectionError
   >(
-    M.json(200, components.CreateCollectionResponse$inboundSchema),
+    M.json(200, operations.CreatecollectionResponse$inboundSchema),
     M.jsonErr(422, errors.CollectionError$inboundSchema),
     M.fail([400, 401, 429, "4XX"]),
     M.fail("5XX"),

package/src/lib/config.ts

@@ -64,8 +64,8 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "0.9.0",
-  sdkVersion: "0.9.1",
+  sdkVersion: "0.10.1",
   genVersion: "2.610.0",
   userAgent:
-    "speakeasy-sdk/typescript 0.9.1 2.610.0 0.9.0 @gleanwork/api-client",
+    "speakeasy-sdk/typescript 0.10.1 2.610.0 0.9.0 @gleanwork/api-client",
 } as const;

package/src/models/components/agentconfig.ts

@@ -7,6 +7,12 @@ import { safeParse } from "../../lib/schemas.js";
 import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  ToolSets,
+  ToolSets$inboundSchema,
+  ToolSets$Outbound,
+  ToolSets$outboundSchema,
+} from "./toolsets.js";
 
 /**
  * Name of the agent.
@@ -15,6 +21,8 @@ export const AgentEnum = {
   Default: "DEFAULT",
   Gpt: "GPT",
   Universal: "UNIVERSAL",
+  Fast: "FAST",
+  Advanced: "ADVANCED",
 } as const;
 /**
  * Name of the agent.
@@ -41,6 +49,10 @@ export type AgentConfig = {
    * Name of the agent.
    */
   agent?: AgentEnum | undefined;
+  /**
+   * The types of tools that the agent is allowed to use. Only works with FAST and ADVANCED `agent` values
+   */
+  toolSets?: ToolSets | undefined;
   /**
    * Top level modes to run GleanChat in.
    */
@@ -93,12 +105,14 @@ export const AgentConfig$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   agent: AgentEnum$inboundSchema.optional(),
+  toolSets: ToolSets$inboundSchema.optional(),
   mode: Mode$inboundSchema.optional(),
 });
 
 /** @internal */
 export type AgentConfig$Outbound = {
   agent?: string | undefined;
+  toolSets?: ToolSets$Outbound | undefined;
   mode?: string | undefined;
 };
 
@@ -109,6 +123,7 @@ export const AgentConfig$outboundSchema: z.ZodType<
   AgentConfig
 > = z.object({
   agent: AgentEnum$outboundSchema.optional(),
+  toolSets: ToolSets$outboundSchema.optional(),
   mode: Mode$outboundSchema.optional(),
 });
 

package/src/models/components/chat.ts

@@ -18,12 +18,24 @@ import {
   IconConfig$Outbound,
   IconConfig$outboundSchema,
 } from "./iconconfig.js";
+import {
+  ObjectPermissions,
+  ObjectPermissions$inboundSchema,
+  ObjectPermissions$Outbound,
+  ObjectPermissions$outboundSchema,
+} from "./objectpermissions.js";
 import {
   Person,
   Person$inboundSchema,
   Person$Outbound,
   Person$outboundSchema,
 } from "./person.js";
+import {
+  UserRoleSpecification,
+  UserRoleSpecification$inboundSchema,
+  UserRoleSpecification$Outbound,
+  UserRoleSpecification$outboundSchema,
+} from "./userrolespecification.js";
 
 /**
  * A historical representation of a series of chat messages a user had with Glean Assistant.
@@ -58,10 +70,15 @@ export type Chat = {
    * Defines how to render an icon
    */
   icon?: IconConfig | undefined;
+  permissions?: ObjectPermissions | undefined;
   /**
    * The chat messages within a Chat.
    */
   messages?: Array<ChatMessage> | undefined;
+  /**
+   * A list of roles for this Chat.
+   */
+  roles?: Array<UserRoleSpecification> | undefined;
 };
 
 /** @internal */
@@ -75,7 +92,9 @@ export const Chat$inboundSchema: z.ZodType<Chat, z.ZodTypeDef, unknown> = z
     applicationId: z.string().optional(),
     applicationName: z.string().optional(),
     icon: IconConfig$inboundSchema.optional(),
+    permissions: ObjectPermissions$inboundSchema.optional(),
     messages: z.array(ChatMessage$inboundSchema).optional(),
+    roles: z.array(UserRoleSpecification$inboundSchema).optional(),
   });
 
 /** @internal */
@@ -88,7 +107,9 @@ export type Chat$Outbound = {
   applicationId?: string | undefined;
   applicationName?: string | undefined;
   icon?: IconConfig$Outbound | undefined;
+  permissions?: ObjectPermissions$Outbound | undefined;
   messages?: Array<ChatMessage$Outbound> | undefined;
+  roles?: Array<UserRoleSpecification$Outbound> | undefined;
 };
 
 /** @internal */
@@ -102,7 +123,9 @@ export const Chat$outboundSchema: z.ZodType<Chat$Outbound, z.ZodTypeDef, Chat> =
     applicationId: z.string().optional(),
     applicationName: z.string().optional(),
     icon: IconConfig$outboundSchema.optional(),
+    permissions: ObjectPermissions$outboundSchema.optional(),
     messages: z.array(ChatMessage$outboundSchema).optional(),
+    roles: z.array(UserRoleSpecification$outboundSchema).optional(),
   });
 
 /**

package/src/models/components/chatmessage.ts

@@ -44,6 +44,7 @@ export const MessageType = {
   Error: "ERROR",
   Heading: "HEADING",
   Warning: "WARNING",
+  ServerTool: "SERVER_TOOL",
 } as const;
 /**
  * Semantically groups content of a certain type. It can be used for purposes such as differential UI treatment. USER authored messages should be of type CONTENT and do not need `messageType` specified.
@@ -140,7 +141,7 @@ export const ChatMessage$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   agentConfig: AgentConfig$inboundSchema.optional(),
-  author: Author$inboundSchema.default("GLEAN_AI"),
+  author: Author$inboundSchema.default("USER"),
   citations: z.array(ChatMessageCitation$inboundSchema).optional(),
   uploadedFileIds: z.array(z.string()).optional(),
   fragments: z.array(ChatMessageFragment$inboundSchema).optional(),
@@ -172,7 +173,7 @@ export const ChatMessage$outboundSchema: z.ZodType<
   ChatMessage
 > = z.object({
   agentConfig: AgentConfig$outboundSchema.optional(),
-  author: Author$outboundSchema.default("GLEAN_AI"),
+  author: Author$outboundSchema.default("USER"),
   citations: z.array(ChatMessageCitation$outboundSchema).optional(),
   uploadedFileIds: z.array(z.string()).optional(),
   fragments: z.array(ChatMessageFragment$outboundSchema).optional(),

package/src/models/components/chatmessagefragment.ts

@@ -38,7 +38,7 @@ import {
 } from "./toolinfo.js";
 
 /**
- * Represents a part of a ChatMessage that originates from a single action/tool. It is designed to support rich data formats beyond simple text, allowing for a more dynamic and interactive chat experience. Each fragment can include various types of content, such as text, search queries, action information, and more. Also, each ChatMessageFragment should only have one of structuredResults, querySuggestion, writeAction, followupAction, or file.
+ * Represents a part of a ChatMessage that originates from a single action/tool. It is designed to support rich data formats beyond simple text, allowing for a more dynamic and interactive chat experience. Each fragment can include various types of content, such as text, search queries, action information, and more. Also, each ChatMessageFragment should only have one of structuredResults, querySuggestion, writeAction, followupAction, agentRecommendation or file.
  */
 export type ChatMessageFragment = {
   /**

package/src/models/components/chatsuggestion.ts

@@ -0,0 +1,72 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type ChatSuggestion = {
+  /**
+   * The actionable chat query to run when the user selects this suggestion.
+   */
+  query?: string | undefined;
+  /**
+   * Targeted Glean Chat feature for the suggestion.
+   */
+  feature?: string | undefined;
+};
+
+/** @internal */
+export const ChatSuggestion$inboundSchema: z.ZodType<
+  ChatSuggestion,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  query: z.string().optional(),
+  feature: z.string().optional(),
+});
+
+/** @internal */
+export type ChatSuggestion$Outbound = {
+  query?: string | undefined;
+  feature?: string | undefined;
+};
+
+/** @internal */
+export const ChatSuggestion$outboundSchema: z.ZodType<
+  ChatSuggestion$Outbound,
+  z.ZodTypeDef,
+  ChatSuggestion
+> = z.object({
+  query: z.string().optional(),
+  feature: z.string().optional(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ChatSuggestion$ {
+  /** @deprecated use `ChatSuggestion$inboundSchema` instead. */
+  export const inboundSchema = ChatSuggestion$inboundSchema;
+  /** @deprecated use `ChatSuggestion$outboundSchema` instead. */
+  export const outboundSchema = ChatSuggestion$outboundSchema;
+  /** @deprecated use `ChatSuggestion$Outbound` instead. */
+  export type Outbound = ChatSuggestion$Outbound;
+}
+
+export function chatSuggestionToJSON(chatSuggestion: ChatSuggestion): string {
+  return JSON.stringify(ChatSuggestion$outboundSchema.parse(chatSuggestion));
+}
+
+export function chatSuggestionFromJSON(
+  jsonString: string,
+): SafeParseResult<ChatSuggestion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ChatSuggestion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ChatSuggestion' from JSON`,
+  );
+}

package/src/models/components/clustertypeenum.ts

@@ -18,6 +18,8 @@ export const ClusterTypeEnum = {
   ThreadRoot: "THREAD_ROOT",
   Prefix: "PREFIX",
   Suffix: "SUFFIX",
+  AuthorPrefix: "AUTHOR_PREFIX",
+  AuthorSuffix: "AUTHOR_SUFFIX",
 } as const;
 /**
  * The reason for inclusion of clusteredResults.

package/src/models/components/customdatasourceconfig.ts

@@ -47,6 +47,7 @@ export const DatasourceCategory = {
   ExternalShortcut: "EXTERNAL_SHORTCUT",
   Entity: "ENTITY",
   Calendar: "CALENDAR",
+  Agents: "AGENTS",
 } as const;
 /**
  * The type of this datasource. It is an important signal for relevance and must be specified and cannot be UNCATEGORIZED. Please refer to [this](https://developers.glean.com/docs/indexing_api_datasource_category/) for more details.

package/src/models/components/digest.ts

@@ -0,0 +1,89 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  DigestSection,
+  DigestSection$inboundSchema,
+  DigestSection$Outbound,
+  DigestSection$outboundSchema,
+} from "./digestsection.js";
+
+export type Digest = {
+  /**
+   * Identifier for the podcast file generated from this digest content.
+   */
+  podcastFileId?: string | undefined;
+  /**
+   * Duration of the podcast file in seconds.
+   */
+  podcastDuration?: number | undefined;
+  /**
+   * The date this digest covers, in YYYY-MM-DD format. Represents the specific day for which the digest content and updates were compiled. This can be empty if the digest is not yet available.
+   */
+  digestDate?: string | undefined;
+  /**
+   * Array of digest sections from which the podcast was created.
+   */
+  sections?: Array<DigestSection> | undefined;
+};
+
+/** @internal */
+export const Digest$inboundSchema: z.ZodType<Digest, z.ZodTypeDef, unknown> = z
+  .object({
+    podcastFileId: z.string().optional(),
+    podcastDuration: z.number().optional(),
+    digestDate: z.string().optional(),
+    sections: z.array(DigestSection$inboundSchema).optional(),
+  });
+
+/** @internal */
+export type Digest$Outbound = {
+  podcastFileId?: string | undefined;
+  podcastDuration?: number | undefined;
+  digestDate?: string | undefined;
+  sections?: Array<DigestSection$Outbound> | undefined;
+};
+
+/** @internal */
+export const Digest$outboundSchema: z.ZodType<
+  Digest$Outbound,
+  z.ZodTypeDef,
+  Digest
+> = z.object({
+  podcastFileId: z.string().optional(),
+  podcastDuration: z.number().optional(),
+  digestDate: z.string().optional(),
+  sections: z.array(DigestSection$outboundSchema).optional(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Digest$ {
+  /** @deprecated use `Digest$inboundSchema` instead. */
+  export const inboundSchema = Digest$inboundSchema;
+  /** @deprecated use `Digest$outboundSchema` instead. */
+  export const outboundSchema = Digest$outboundSchema;
+  /** @deprecated use `Digest$Outbound` instead. */
+  export type Outbound = Digest$Outbound;
+}
+
+export function digestToJSON(digest: Digest): string {
+  return JSON.stringify(Digest$outboundSchema.parse(digest));
+}
+
+export function digestFromJSON(
+  jsonString: string,
+): SafeParseResult<Digest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Digest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Digest' from JSON`,
+  );
+}

package/src/models/components/digestsection.ts

@@ -0,0 +1,118 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  DigestUpdate,
+  DigestUpdate$inboundSchema,
+  DigestUpdate$Outbound,
+  DigestUpdate$outboundSchema,
+} from "./digestupdate.js";
+import {
+  SectionType,
+  SectionType$inboundSchema,
+  SectionType$outboundSchema,
+} from "./sectiontype.js";
+
+export type DigestSection = {
+  /**
+   * Unique identifier for the digest section.
+   */
+  id: string;
+  /**
+   * Type of the section. This defines how the section should be interpreted and rendered in the digest.
+   */
+  type: SectionType;
+  /**
+   * Human-readable name for the digest section.
+   */
+  displayName?: string | undefined;
+  /**
+   * Name of the channel (applicable for CHANNEL type sections). Used to display in the frontend.
+   */
+  channelName?: string | undefined;
+  /**
+   * Instance identifier for the channel or workspace. Used for constructing channel URLs to display in the frontend.
+   */
+  instanceId?: string | undefined;
+  /**
+   * Optional URL for the digest section. Should be populated only if the section is a CHANNEL type section.
+   */
+  url?: string | undefined;
+  /**
+   * List of updates within this digest section.
+   */
+  updates: Array<DigestUpdate>;
+};
+
+/** @internal */
+export const DigestSection$inboundSchema: z.ZodType<
+  DigestSection,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  type: SectionType$inboundSchema,
+  displayName: z.string().optional(),
+  channelName: z.string().optional(),
+  instanceId: z.string().optional(),
+  url: z.string().optional(),
+  updates: z.array(DigestUpdate$inboundSchema),
+});
+
+/** @internal */
+export type DigestSection$Outbound = {
+  id: string;
+  type: string;
+  displayName?: string | undefined;
+  channelName?: string | undefined;
+  instanceId?: string | undefined;
+  url?: string | undefined;
+  updates: Array<DigestUpdate$Outbound>;
+};
+
+/** @internal */
+export const DigestSection$outboundSchema: z.ZodType<
+  DigestSection$Outbound,
+  z.ZodTypeDef,
+  DigestSection
+> = z.object({
+  id: z.string(),
+  type: SectionType$outboundSchema,
+  displayName: z.string().optional(),
+  channelName: z.string().optional(),
+  instanceId: z.string().optional(),
+  url: z.string().optional(),
+  updates: z.array(DigestUpdate$outboundSchema),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace DigestSection$ {
+  /** @deprecated use `DigestSection$inboundSchema` instead. */
+  export const inboundSchema = DigestSection$inboundSchema;
+  /** @deprecated use `DigestSection$outboundSchema` instead. */
+  export const outboundSchema = DigestSection$outboundSchema;
+  /** @deprecated use `DigestSection$Outbound` instead. */
+  export type Outbound = DigestSection$Outbound;
+}
+
+export function digestSectionToJSON(digestSection: DigestSection): string {
+  return JSON.stringify(DigestSection$outboundSchema.parse(digestSection));
+}
+
+export function digestSectionFromJSON(
+  jsonString: string,
+): SafeParseResult<DigestSection, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DigestSection$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DigestSection' from JSON`,
+  );
+}

package/src/models/components/digestupdate.ts

@@ -0,0 +1,98 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  UpdateType,
+  UpdateType$inboundSchema,
+  UpdateType$outboundSchema,
+} from "./updatetype.js";
+
+export type DigestUpdate = {
+  /**
+   * URL link to the content or document.
+   */
+  url?: string | undefined;
+  /**
+   * Title or headline of the update.
+   */
+  title?: string | undefined;
+  /**
+   * Name or identifier of the data source (e.g., slack, confluence, etc.).
+   */
+  datasource?: string | undefined;
+  /**
+   * Brief summary or description of the update content.
+   */
+  summary?: string | undefined;
+  /**
+   * Optional type classification for the update.
+   */
+  type?: UpdateType | undefined;
+};
+
+/** @internal */
+export const DigestUpdate$inboundSchema: z.ZodType<
+  DigestUpdate,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  url: z.string().optional(),
+  title: z.string().optional(),
+  datasource: z.string().optional(),
+  summary: z.string().optional(),
+  type: UpdateType$inboundSchema.optional(),
+});
+
+/** @internal */
+export type DigestUpdate$Outbound = {
+  url?: string | undefined;
+  title?: string | undefined;
+  datasource?: string | undefined;
+  summary?: string | undefined;
+  type?: string | undefined;
+};
+
+/** @internal */
+export const DigestUpdate$outboundSchema: z.ZodType<
+  DigestUpdate$Outbound,
+  z.ZodTypeDef,
+  DigestUpdate
+> = z.object({
+  url: z.string().optional(),
+  title: z.string().optional(),
+  datasource: z.string().optional(),
+  summary: z.string().optional(),
+  type: UpdateType$outboundSchema.optional(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace DigestUpdate$ {
+  /** @deprecated use `DigestUpdate$inboundSchema` instead. */
+  export const inboundSchema = DigestUpdate$inboundSchema;
+  /** @deprecated use `DigestUpdate$outboundSchema` instead. */
+  export const outboundSchema = DigestUpdate$outboundSchema;
+  /** @deprecated use `DigestUpdate$Outbound` instead. */
+  export type Outbound = DigestUpdate$Outbound;
+}
+
+export function digestUpdateToJSON(digestUpdate: DigestUpdate): string {
+  return JSON.stringify(DigestUpdate$outboundSchema.parse(digestUpdate));
+}
+
+export function digestUpdateFromJSON(
+  jsonString: string,
+): SafeParseResult<DigestUpdate, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DigestUpdate$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DigestUpdate' from JSON`,
+  );
+}