🚧 chore: merge latest dev build to main repo (#3844)

* agents - phase 1 (#30)

* chore: copy assistant files

* feat: frontend and data-provider

* feat: backend get endpoint test

* fix(MessageEndpointIcon): switched to AgentName and AgentAvatar

* fix: small fixes

* fix: agent endpoint config

* fix: show Agent Builder

* chore: install agentus

* chore: initial scaffolding for agents

* fix: updated Assistant logic to Agent Logic for some Agent components

* WIP first pass, demo of agent package

* WIP: initial backend infra for agents

* fix: agent list error

* wip: agents routing

* chore: Refactor useSSE hook to handle different data events

* wip: correctly emit events

* chore: Update @librechat/agentus npm dependency to version 1.0.9

* remove comment

* first pass: streaming agent text

* chore: Remove @librechat/agentus root-level workspace npm dependency

* feat: Agent Schema and Model

* fix: content handling fixes

* fix: content message save

* WIP: new content data

* fix: run step issue with tool calls

* chore: Update @librechat/agentus npm dependency to version 1.1.5

* feat: update controller and agent routes

* wip: initial backend tool and tool error handling support

* wip: tool chunks

* chore: Update @librechat/agentus npm dependency to version 1.1.7

* chore: update tool_call typing, add test conditions and logs

* fix: create agent

* fix: create agent

* first pass: render completed content parts

* fix: remove logging, fix step handler typing

* chore: Update @librechat/agentus npm dependency to version 1.1.9

* refactor: cleanup maps on unmount

* chore: Update BaseClient.js to safely count tokens for string, number, and boolean values

* fix: support subsequent messages with tool_calls

* chore: export order

* fix: select agent

* fix: tool call types and handling

* chore: switch to anthropic for testing

* fix: AgentSelect

* refactor: experimental: OpenAIClient to use array for intermediateReply

* fix(useSSE): revert old condition for streaming legacy client tokens

* fix: lint

* revert `agent_id` to `id`

* chore: update localization keys for agent-related components

* feat: zod schema handling for actions

* refactor(actions): if no params, no zodSchema

* chore: Update @librechat/agentus npm dependency to version 1.2.1

* feat: first pass, actions

* refactor: empty schema for actions without params

* feat: Update createRun function to accept additional options

* fix: message payload formatting; feat: add more client options

* fix: ToolCall component rendering when action has no args but has output

* refactor(ToolCall): allow non-stringy args

* WIP: first pass, correctly formatted tool_calls between providers

* refactor: Remove duplicate import of 'roles' module

* refactor: Exclude 'vite.config.ts' from TypeScript compilation

* refactor: fix agent related types
> - no need to use endpoint/model fields for identifying agent metadata
> - add `provider` distinction for agent-configured 'endpoint'
- no need for agent-endpoint map
- reduce complexity of tools as functions into tools as string[]
- fix types related to above changes
- reduce unnecessary variables for queries/mutations and corresponding react-query keys

* refactor: Add tools and tool_kwargs fields to agent schema

* refactor: Remove unused code and update dependencies

* refactor: Update updateAgentHandler to use req.body directly

* refactor: Update AgentSelect component to use localized hooks

* refactor: Update agent schema to include tools and provider fields

* refactor(AgentPanel): add scrollbar gutter, add provider field to form, fix agent schema required values

* refactor: Update AgentSwitcher component to use selectedAgentId instead of selectedAgent

* refactor: Update AgentPanel component to include alternateName import and defaultAgentFormValues

* refactor(SelectDropDown): allow setting value as option while still supporting legacy usage (string values only)

* refactor: SelectDropdown changes - Only necessary when the available values are objects with label/value fields and the selected value is expected to be a string.

* refactor: TypeError issues and handle provider as option

* feat: Add placeholder for provider selection in AgentPanel component

* refactor: Update agent schema to include author and provider fields

* fix: show expected 'create agent' placeholder when creating agent

* chore: fix localization strings, hide capabilities form for now

* chore: typing

* refactor: import order and use compact agents schema for now

* chore: typing

* refactor: Update AgentForm type to use AgentCapabilities

* fix agent form agent selection issues

* feat: responsive agent selection

* fix: Handle cancelled fetch in useSelectAgent hook

* fix: reset agent form on accordion close/open

* feat: Add agent_id to default conversation for agents endpoint

* feat: agents endpoint request handling

* refactor: reset conversation model on agent select

* refactor: add `additional_instructions` to conversation schema, organize other fields

* chore: casing

* chore: types

* refactor(loadAgentTools): explicitly pass agent_id, do not pass `model` to loadAgentTools for now, load action sets by agent_id

* WIP: initial draft of real agent client initialization

* WIP: first pass, anthropic agent requests

* feat: remember last selected agent

* feat: openai and azure connected

* fix: prioritize agent model for runs unless an explicit override model is passed from client

* feat: Agent Actions

* fix: save agent id to convo

* feat: model panel (#29)

* feat: model panel

* bring back comments

* fix: method still null

* fix: AgentPanel FormContext

* feat: add more parameters

* fix: style issues; refactor: Agent Controller

* fix: cherry-pick

* fix: Update AgentAvatar component to use AssistantIcon instead of BrainCircuit

* feat: OGDialog for delete agent; feat(assistant): update Agent types, introduced `model_parameters`

* feat: icon and general `model_parameters` update

* feat: use react-hook-form better

* fix: agent builder form reset issue when switching panels

* refactor: modularize agent builder form

---------

Co-authored-by: Danny Avila <danny@librechat.ai>

* fix: AgentPanel and ModelPanel type issues and use `useFormContext` and `watch` instead of `methods` directly and `useWatch`.

* fix: tool call issues due to invalid input (anthropic) of empty string

* fix: handle empty text in Part component

---------

Co-authored-by: Marco Beretta <81851188+berry-13@users.noreply.github.com>

* refactor: remove form ModelPanel and fixed nested ternary expressions in AgentConfig

* fix: Model Parameters not saved correctly

* refactor: remove console log

* feat: avatar upload and get for Agents (#36)

Co-authored-by: Marco Beretta <81851188+berry-13@users.noreply.github.com>

* chore: update to public package

* fix: typing, optional chaining

* fix: cursor not showing for content parts

* chore: conditionally enable agents

* ci: fix azure test

* ci: fix frontend tests, fix eslint api

* refactor: Remove unused errorContentPart variable

* continue of the agent message PR (#40)

* last fixes

* fix: agentMap

* pr merge test  (#41)

* fix: model icon not fetching correctly

* remove console logs

* feat: agent name

* refactor: pass documentsMap as a prop to allow re-render of assistant form

* refactor: pass documentsMap as a prop to allow re-render of assistant form

* chore: Bump version to 0.7.419

* fix: TypeError: Cannot read properties of undefined (reading 'id')

* refactor: update AgentSwitcher component to use ControlCombobox instead of Combobox

---------

Co-authored-by: Marco Beretta <81851188+berry-13@users.noreply.github.com>
This commit is contained in:
Danny Avila 2024-08-31 16:33:51 -04:00 committed by GitHub
parent 618be4bf2b
commit a0291ed155
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
141 changed files with 14473 additions and 5714 deletions

View file

@ -1,3 +1,4 @@
import { z } from 'zod';
import axios from 'axios';
import { URL } from 'url';
import crypto from 'crypto';
@ -12,6 +13,11 @@ export type ParametersSchema = {
required: string[];
};
export type OpenAPISchema = OpenAPIV3.SchemaObject &
ParametersSchema & {
items?: OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject;
};
export type ApiKeyCredentials = {
api_key: string;
custom_auth_header?: string;
@ -38,6 +44,70 @@ export function createURL(domain: string, path: string) {
return new URL(fullURL).toString();
}
const schemaTypeHandlers: Record<string, (schema: OpenAPISchema) => z.ZodTypeAny> = {
string: (schema) => {
if (schema.enum) {
return z.enum(schema.enum as [string, ...string[]]);
}
let stringSchema = z.string();
if (schema.minLength !== undefined) {
stringSchema = stringSchema.min(schema.minLength);
}
if (schema.maxLength !== undefined) {
stringSchema = stringSchema.max(schema.maxLength);
}
return stringSchema;
},
number: (schema) => {
let numberSchema = z.number();
if (schema.minimum !== undefined) {
numberSchema = numberSchema.min(schema.minimum);
}
if (schema.maximum !== undefined) {
numberSchema = numberSchema.max(schema.maximum);
}
return numberSchema;
},
integer: (schema) => (schemaTypeHandlers.number(schema) as z.ZodNumber).int(),
boolean: () => z.boolean(),
array: (schema) => {
if (schema.items) {
const zodSchema = openAPISchemaToZod(schema.items as OpenAPISchema);
if (zodSchema) {
return z.array(zodSchema);
}
return z.array(z.unknown());
}
return z.array(z.unknown());
},
object: (schema) => {
const shape: { [key: string]: z.ZodTypeAny } = {};
if (schema.properties) {
Object.entries(schema.properties).forEach(([key, value]) => {
const zodSchema = openAPISchemaToZod(value as OpenAPISchema);
shape[key] = zodSchema || z.unknown();
if (schema.required && schema.required.includes(key)) {
shape[key] = shape[key].describe(value.description || '');
} else {
shape[key] = shape[key].optional().describe(value.description || '');
}
});
}
return z.object(shape);
},
};
function openAPISchemaToZod(schema: OpenAPISchema): z.ZodTypeAny | undefined {
if (schema.type === 'object' && Object.keys(schema.properties || {}).length === 0) {
return undefined;
}
const handler = schemaTypeHandlers[schema.type as string] || (() => z.unknown());
return handler(schema);
}
export class FunctionSignature {
name: string;
description: string;
@ -46,11 +116,7 @@ export class FunctionSignature {
constructor(name: string, description: string, parameters: ParametersSchema) {
this.name = name;
this.description = description;
if (parameters.properties?.['requestBody']) {
this.parameters = parameters.properties?.['requestBody'] as ParametersSchema;
} else {
this.parameters = parameters;
}
this.parameters = parameters;
}
toObjectTool(): FunctionTool {
@ -219,14 +285,17 @@ function sanitizeOperationId(input: string) {
}
/** Function to convert OpenAPI spec to function signatures and request builders */
export function openapiToFunction(openapiSpec: OpenAPIV3.Document): {
export function openapiToFunction(
openapiSpec: OpenAPIV3.Document,
generateZodSchemas = false,
): {
functionSignatures: FunctionSignature[];
requestBuilders: Record<string, ActionRequest>;
zodSchemas?: Record<string, z.ZodTypeAny>;
} {
const functionSignatures: FunctionSignature[] = [];
const requestBuilders: Record<string, ActionRequest> = {};
// Base URL from OpenAPI spec servers
const zodSchemas: Record<string, z.ZodTypeAny> = {};
const baseUrl = openapiSpec.servers?.[0]?.url ?? '';
// Iterate over each path and method in the OpenAPI spec
@ -241,19 +310,11 @@ export function openapiToFunction(openapiSpec: OpenAPIV3.Document): {
const operationId = operationObj.operationId || sanitizeOperationId(defaultOperationId);
const description = operationObj.summary || operationObj.description || '';
const parametersSchema: ParametersSchema = { type: 'object', properties: {}, required: [] };
if (operationObj.requestBody) {
const requestBody = operationObj.requestBody as OpenAPIV3.RequestBodyObject;
const content = requestBody.content;
const contentType = Object.keys(content)[0];
const schema = content[contentType]?.schema;
const resolvedSchema = resolveRef(
schema as OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject,
openapiSpec.components,
);
parametersSchema.properties['requestBody'] = resolvedSchema;
}
const parametersSchema: OpenAPISchema = {
type: 'object',
properties: {},
required: [],
};
if (operationObj.parameters) {
for (const param of operationObj.parameters) {
@ -266,9 +327,24 @@ export function openapiToFunction(openapiSpec: OpenAPIV3.Document): {
if (paramObj.required) {
parametersSchema.required.push(paramObj.name);
}
if (paramObj.description && !('$$ref' in parametersSchema.properties[paramObj.name])) {
parametersSchema.properties[paramObj.name].description = paramObj.description;
}
}
}
if (operationObj.requestBody) {
const requestBody = operationObj.requestBody as OpenAPIV3.RequestBodyObject;
const content = requestBody.content;
const contentType = Object.keys(content)[0];
const schema = content[contentType]?.schema;
const resolvedSchema = resolveRef(
schema as OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject,
openapiSpec.components,
);
parametersSchema.properties = {
...parametersSchema.properties,
...resolvedSchema.properties,
};
if (resolvedSchema.required) {
parametersSchema.required.push(...resolvedSchema.required);
}
}
@ -285,10 +361,17 @@ export function openapiToFunction(openapiSpec: OpenAPIV3.Document): {
);
requestBuilders[operationId] = actionRequest;
if (generateZodSchemas && Object.keys(parametersSchema.properties).length > 0) {
const schema = openAPISchemaToZod(parametersSchema);
if (schema) {
zodSchemas[operationId] = schema;
}
}
}
}
return { functionSignatures, requestBuilders };
return { functionSignatures, requestBuilders, zodSchemas };
}
export type ValidationResult = {