@inkeep/agents-manage-mcp 0.0.0-chat-to-edit-20251119155821 → 0.0.0-chat-to-edit-20251119164038

package/openapi.json

@@ -3636,6 +3636,40 @@
           }
         }
       },
+      "ConversationWithFormattedMessagesResponse": {
+        "type": "object",
+        "properties": {
+          "data": {
+            "type": "object",
+            "properties": {
+              "messages": {
+                "type": "array",
+                "items": {
+                  "nullable": true
+                }
+              },
+              "formatted": {
+                "type": "object",
+                "properties": {
+                  "llmContext": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "llmContext"
+                ]
+              }
+            },
+            "required": [
+              "messages",
+              "formatted"
+            ]
+          }
+        },
+        "required": [
+          "data"
+        ]
+      },
       "CredentialReference": {
         "type": "object",
         "properties": {
@@ -4946,6 +4980,9 @@
           "version": {
             "type": "string"
           },
+          "expiresAt": {
+            "type": "string"
+          },
           "relationshipId": {
             "type": "string"
           }
@@ -12330,6 +12367,142 @@
         }
       }
     },
+    "/tenants/{tenantId}/projects/{projectId}/conversations/{id}": {
+      "get": {
+        "summary": "Get Conversation",
+        "operationId": "get-conversation",
+        "tags": [
+          "Conversations"
+        ],
+        "parameters": [
+          {
+            "schema": {
+              "$ref": "#/components/schemas/TenantIdPathParam"
+            },
+            "required": true,
+            "description": "Tenant identifier",
+            "name": "tenantId",
+            "in": "path"
+          },
+          {
+            "schema": {
+              "$ref": "#/components/schemas/ProjectIdPathParam"
+            },
+            "required": true,
+            "description": "Project identifier",
+            "name": "projectId",
+            "in": "path"
+          },
+          {
+            "schema": {
+              "type": "string",
+              "minLength": 1,
+              "maxLength": 255,
+              "pattern": "^[a-zA-Z0-9\\-_.]+$",
+              "description": "Resource identifier",
+              "example": "resource_789"
+            },
+            "required": true,
+            "description": "Resource identifier",
+            "name": "id",
+            "in": "path"
+          },
+          {
+            "schema": {
+              "type": "number",
+              "minimum": 1,
+              "maximum": 200,
+              "default": 20
+            },
+            "required": false,
+            "name": "limit",
+            "in": "query"
+          },
+          {
+            "schema": {
+              "type": "boolean",
+              "nullable": true,
+              "default": false
+            },
+            "required": false,
+            "name": "includeInternal",
+            "in": "query"
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Conversation found with formatted messages for LLM use",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ConversationWithFormattedMessagesResponse"
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "Bad Request",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/BadRequest"
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "Unauthorized",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/Unauthorized"
+                }
+              }
+            }
+          },
+          "403": {
+            "description": "Forbidden",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/Forbidden"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Not Found",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/NotFound"
+                }
+              }
+            }
+          },
+          "422": {
+            "description": "Unprocessable Entity",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/UnprocessableEntity"
+                }
+              }
+            }
+          },
+          "500": {
+            "description": "Internal Server Error",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/InternalServerError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
     "/tenants/{tenantId}/projects/{projectId}/credentials": {
       "get": {
         "summary": "List Credentials",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inkeep/agents-manage-mcp",
-  "version": "0.0.0-chat-to-edit-20251119155821",
+  "version": "0.0.0-chat-to-edit-20251119164038",
   "author": "Speakeasy",
   "type": "module",
   "sideEffects": false,

package/src/funcs/conversationsGetConversation.ts

@@ -0,0 +1,201 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { InkeepAgentsCore } from '../core.js';
+import { encodeFormQuery, encodeSimple } from '../lib/encodings.js';
+import * as M from '../lib/matchers.js';
+import { compactMap } from '../lib/primitives.js';
+import { safeParse } from '../lib/schemas.js';
+import { RequestOptions } from '../lib/sdks.js';
+import { pathToFunc } from '../lib/url.js';
+import { APIError } from '../models/errors/apierror.js';
+import {
+  ConnectionError,
+  InvalidRequestError,
+  RequestAbortedError,
+  RequestTimeoutError,
+  UnexpectedClientError,
+} from '../models/errors/httpclienterrors.js';
+import { SDKValidationError } from '../models/errors/sdkvalidationerror.js';
+import {
+  GetConversationRequest,
+  GetConversationRequest$zodSchema,
+  GetConversationResponse,
+  GetConversationResponse$zodSchema,
+} from '../models/getconversationop.js';
+import { APICall, APIPromise } from '../types/async.js';
+import { Result } from '../types/fp.js';
+
+export enum GetConversationAcceptEnum {
+  applicationJsonAccept = 'application/json',
+  applicationProblemPlusJsonAccept = 'application/problem+json',
+}
+
+/**
+ * Get Conversation
+ */
+export function conversationsGetConversation(
+  client$: InkeepAgentsCore,
+  request: GetConversationRequest,
+  options?: RequestOptions
+): APIPromise<
+  Result<
+    GetConversationResponse,
+    | APIError
+    | SDKValidationError
+    | UnexpectedClientError
+    | InvalidRequestError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | ConnectionError
+  >
+> {
+  return new APIPromise($do(client$, request, options));
+}
+
+async function $do(
+  client$: InkeepAgentsCore,
+  request: GetConversationRequest,
+  options?: RequestOptions & {
+    acceptHeaderOverride?: GetConversationAcceptEnum;
+  }
+): Promise<
+  [
+    Result<
+      GetConversationResponse,
+      | APIError
+      | SDKValidationError
+      | UnexpectedClientError
+      | InvalidRequestError
+      | RequestAbortedError
+      | RequestTimeoutError
+      | ConnectionError
+    >,
+    APICall,
+  ]
+> {
+  const parsed$ = safeParse(
+    request,
+    (value$) => GetConversationRequest$zodSchema.parse(value$),
+    'Input validation failed'
+  );
+  if (!parsed$.ok) {
+    return [parsed$, { status: 'invalid' }];
+  }
+  const payload$ = parsed$.value;
+  const body$ = null;
+
+  const pathParams$ = {
+    id: encodeSimple('id', payload$.id, {
+      explode: false,
+      charEncoding: 'percent',
+    }),
+    projectId: encodeSimple('projectId', payload$.projectId, {
+      explode: false,
+      charEncoding: 'percent',
+    }),
+    tenantId: encodeSimple('tenantId', payload$.tenantId, {
+      explode: false,
+      charEncoding: 'percent',
+    }),
+  };
+  const path$ = pathToFunc('/tenants/{tenantId}/projects/{projectId}/conversations/{id}')(
+    pathParams$
+  );
+  const query$ = encodeFormQuery({
+    includeInternal: payload$.includeInternal,
+    limit: payload$.limit,
+  });
+
+  const headers$ = new Headers(
+    compactMap({
+      Accept: options?.acceptHeaderOverride || 'application/json;q=1, application/problem+json;q=0',
+    })
+  );
+
+  const context = {
+    options: client$._options,
+    baseURL: options?.serverURL ?? client$._baseURL ?? '',
+    operationID: 'get-conversation',
+    oAuth2Scopes: null,
+    resolvedSecurity: null,
+    securitySource: null,
+    retryConfig: options?.retries || client$._options.retryConfig || { strategy: 'none' },
+    retryCodes: options?.retryCodes || ['429', '500', '502', '503', '504'],
+  };
+
+  const requestRes = client$._createRequest(
+    context,
+    {
+      method: 'GET',
+      baseURL: options?.serverURL,
+      path: path$,
+      headers: headers$,
+      query: query$,
+      body: body$,
+      userAgent: client$._options.userAgent,
+      timeoutMs: options?.timeoutMs || client$._options.timeoutMs || -1,
+    },
+    options
+  );
+  if (!requestRes.ok) {
+    return [requestRes, { status: 'invalid' }];
+  }
+  const req$ = requestRes.value;
+
+  const doResult = await client$._do(req$, {
+    context,
+    errorCodes: [],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: 'request-error', request: req$ }];
+  }
+  const response = doResult.value;
+  const responseFields$ = {
+    HttpMeta: { Response: response, Request: req$ },
+  };
+
+  const [result$] = await M.match<
+    GetConversationResponse,
+    | APIError
+    | SDKValidationError
+    | UnexpectedClientError
+    | InvalidRequestError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | ConnectionError
+  >(
+    M.json(200, GetConversationResponse$zodSchema, {
+      key: 'ConversationWithFormattedMessagesResponse',
+    }),
+    M.json(400, GetConversationResponse$zodSchema, {
+      ctype: 'application/problem+json',
+      key: 'BadRequest',
+    }),
+    M.json(401, GetConversationResponse$zodSchema, {
+      ctype: 'application/problem+json',
+      key: 'Unauthorized',
+    }),
+    M.json(403, GetConversationResponse$zodSchema, {
+      ctype: 'application/problem+json',
+      key: 'Forbidden',
+    }),
+    M.json(404, GetConversationResponse$zodSchema, {
+      ctype: 'application/problem+json',
+      key: 'NotFound',
+    }),
+    M.json(422, GetConversationResponse$zodSchema, {
+      ctype: 'application/problem+json',
+      key: 'UnprocessableEntity',
+    }),
+    M.json(500, GetConversationResponse$zodSchema, {
+      ctype: 'application/problem+json',
+      key: 'InternalServerError',
+    })
+  )(response, req$, { extraFields: responseFields$ });
+
+  return [result$, { status: 'complete', request: req$, response }];
+}

package/src/hooks/auth-hook.ts

@@ -0,0 +1,32 @@
+import type { BeforeRequestContext, BeforeRequestHook } from './types.js';
+
+/**
+ * AuthHook adds bypass authentication to all SDK requests.
+ * This hook injects the Authorization header from SDK options into every outgoing request.
+ */
+export class AuthHook implements BeforeRequestHook {
+  async beforeRequest(_hookCtx: BeforeRequestContext, request: Request): Promise<Request> {
+    // Inject bypass secret if configured, regardless of environment
+    const bypassSecret = process.env['INKEEP_AGENTS_MANAGE_API_BYPASS_SECRET'];
+
+    if (bypassSecret) {
+      // Log that we're injecting auth (console.log since this is in the MCP package without a logger)
+      if (process.env['LOG_LEVEL'] === 'debug' || process.env['LOG_LEVEL'] === 'trace') {
+        console.log('[AuthHook] Injecting bypass auth for request:', {
+          method: request.method,
+          url: request.url,
+        });
+      }
+
+      const newRequest = new Request(request, {
+        headers: {
+          ...Object.fromEntries(request.headers.entries()),
+          Authorization: `Bearer ${bypassSecret}`,
+        },
+      });
+      return newRequest;
+    }
+
+    return request;
+  }
+}

package/src/hooks/registration.ts

@@ -1,3 +1,4 @@
+import { AuthHook } from './auth-hook.js';
 import type { Hooks } from './types.js';
 
 /*
@@ -6,9 +7,7 @@ import type { Hooks } from './types.js';
  * in this file or in separate files in the hooks folder.
  */
 
-// @ts-expect-error remove this line when you add your first hook and hooks is used
 export function initHooks(hooks: Hooks) {
-  // Add hooks by calling hooks.register{ClientInit/BeforeCreateRequest/BeforeRequest/AfterSuccess/AfterError}Hook
-  // with an instance of a hook that implements that specific Hook interface
-  // Hooks are registered per SDK instance, and are valid for the lifetime of the SDK instance
+  // Register the authentication hook to inject bypass secret into all requests
+  hooks.registerBeforeRequestHook(new AuthHook());
 }

package/src/lib/config.ts

@@ -59,7 +59,7 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: 'typescript',
   openapiDocVersion: '1.0.0',
-  sdkVersion: '0.0.11',
+  sdkVersion: '0.0.12',
   genVersion: '2.755.9',
-  userAgent: 'speakeasy-sdk/mcp-typescript 0.0.11 2.755.9 1.0.0 @inkeep/agents-manage-mcp',
+  userAgent: 'speakeasy-sdk/mcp-typescript 0.0.12 2.755.9 1.0.0 @inkeep/agents-manage-mcp',
 } as const;

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

@@ -19,7 +19,7 @@ const routes = buildRouteMap({
 export const app = buildApplication(routes, {
   name: 'mcp',
   versionInfo: {
-    currentVersion: '0.0.11',
+    currentVersion: '0.0.12',
   },
 });
 

package/src/mcp-server/server.ts

@@ -42,6 +42,7 @@ import { tool$contextConfigDeleteContextConfig } from './tools/contextConfigDele
 import { tool$contextConfigGetContextConfigById } from './tools/contextConfigGetContextConfigById.js';
 import { tool$contextConfigListContextConfigs } from './tools/contextConfigListContextConfigs.js';
 import { tool$contextConfigUpdateContextConfig } from './tools/contextConfigUpdateContextConfig.js';
+import { tool$conversationsGetConversation } from './tools/conversationsGetConversation.js';
 import { tool$credentialCreateCredential } from './tools/credentialCreateCredential.js';
 import { tool$credentialDeleteCredential } from './tools/credentialDeleteCredential.js';
 import { tool$credentialGetCredentialById } from './tools/credentialGetCredentialById.js';
@@ -129,7 +130,7 @@ export function createMCPServer(deps: {
 }) {
   const server = new McpServer({
     name: 'InkeepAgents',
-    version: '0.0.11',
+    version: '0.0.12',
   });
 
   const getClient =
@@ -217,6 +218,7 @@ export function createMCPServer(deps: {
   tool(tool$contextConfigGetContextConfigById);
   tool(tool$contextConfigUpdateContextConfig);
   tool(tool$contextConfigDeleteContextConfig);
+  tool(tool$conversationsGetConversation);
   tool(tool$credentialListCredentials);
   tool(tool$credentialCreateCredential);
   tool(tool$credentialGetCredentialById);

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

@@ -0,0 +1,40 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { conversationsGetConversation } from '../../funcs/conversationsGetConversation.js';
+import { GetConversationRequest$zodSchema } from '../../models/getconversationop.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+  request: GetConversationRequest$zodSchema,
+};
+
+export const tool$conversationsGetConversation: ToolDefinition<typeof args> = {
+  name: 'conversations-get-conversation',
+  description: `Get Conversation`,
+  annotations: {
+    title: '',
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false,
+    readOnlyHint: true,
+  },
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await conversationsGetConversation(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/conversationwithformattedmessagesresponse.ts

@@ -0,0 +1,37 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from 'zod';
+
+export type Formatted = { llmContext: string };
+
+export const Formatted$zodSchema: z.ZodType<Formatted, z.ZodTypeDef, unknown> = z.object({
+  llmContext: z.string(),
+});
+
+export type ConversationWithFormattedMessagesResponseData = {
+  messages: Array<any | null>;
+  formatted: Formatted;
+};
+
+export const ConversationWithFormattedMessagesResponseData$zodSchema: z.ZodType<
+  ConversationWithFormattedMessagesResponseData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  formatted: z.lazy(() => Formatted$zodSchema),
+  messages: z.array(z.any().nullable()),
+});
+
+export type ConversationWithFormattedMessagesResponse = {
+  data: ConversationWithFormattedMessagesResponseData;
+};
+
+export const ConversationWithFormattedMessagesResponse$zodSchema: z.ZodType<
+  ConversationWithFormattedMessagesResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  data: z.lazy(() => ConversationWithFormattedMessagesResponseData$zodSchema),
+});

package/src/models/getconversationop.ts

@@ -0,0 +1,66 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from 'zod';
+import { BadRequest, BadRequest$zodSchema } from './badrequest.js';
+import {
+  ConversationWithFormattedMessagesResponse,
+  ConversationWithFormattedMessagesResponse$zodSchema,
+} from './conversationwithformattedmessagesresponse.js';
+import { Forbidden, Forbidden$zodSchema } from './forbidden.js';
+import { InternalServerError, InternalServerError$zodSchema } from './internalservererror.js';
+import { NotFound, NotFound$zodSchema } from './notfound.js';
+import { Unauthorized, Unauthorized$zodSchema } from './unauthorized.js';
+import { UnprocessableEntity, UnprocessableEntity$zodSchema } from './unprocessableentity.js';
+
+export type GetConversationRequest = {
+  tenantId: string;
+  projectId: string;
+  id: string;
+  limit?: number | undefined;
+  includeInternal?: boolean | null | undefined;
+};
+
+export const GetConversationRequest$zodSchema: z.ZodType<
+  GetConversationRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string().describe('Resource identifier'),
+  includeInternal: z.boolean().default(false).nullable(),
+  limit: z.number().default(20),
+  projectId: z.string().describe('Project identifier'),
+  tenantId: z.string().describe('Tenant identifier'),
+});
+
+export type GetConversationResponse = {
+  ContentType: string;
+  StatusCode: number;
+  RawResponse: Response;
+  ConversationWithFormattedMessagesResponse?: ConversationWithFormattedMessagesResponse | undefined;
+  BadRequest?: BadRequest | undefined;
+  Unauthorized?: Unauthorized | undefined;
+  Forbidden?: Forbidden | undefined;
+  NotFound?: NotFound | undefined;
+  UnprocessableEntity?: UnprocessableEntity | undefined;
+  InternalServerError?: InternalServerError | undefined;
+};
+
+export const GetConversationResponse$zodSchema: z.ZodType<
+  GetConversationResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  BadRequest: BadRequest$zodSchema.optional(),
+  ContentType: z.string(),
+  ConversationWithFormattedMessagesResponse:
+    ConversationWithFormattedMessagesResponse$zodSchema.optional(),
+  Forbidden: Forbidden$zodSchema.optional(),
+  InternalServerError: InternalServerError$zodSchema.optional(),
+  NotFound: NotFound$zodSchema.optional(),
+  RawResponse: z.instanceof(Response),
+  StatusCode: z.number().int(),
+  Unauthorized: Unauthorized$zodSchema.optional(),
+  UnprocessableEntity: UnprocessableEntity$zodSchema.optional(),
+});

package/src/models/mcptool.ts

@@ -98,6 +98,7 @@ export type McpTool = {
   availableTools?: Array<AvailableTool> | undefined;
   status?: Status | undefined;
   version?: string | undefined;
+  expiresAt?: string | undefined;
   relationshipId?: string | undefined;
 };
 
@@ -108,6 +109,7 @@ export const McpTool$zodSchema: z.ZodType<McpTool, z.ZodTypeDef, unknown> = z.ob
   createdAt: z.string().optional(),
   credentialReferenceId: z.string().nullable().optional(),
   description: z.string().nullable().optional(),
+  expiresAt: z.string().optional(),
   headers: z.any().nullable().optional(),
   id: z.string(),
   imageUrl: z.string().optional(),