veryfront 0.1.435 → 0.1.437

package/src/deps/esm.sh/@types/{react@19.2.3 → react@19.2.14}/global.d.ts

@@ -18,6 +18,7 @@ interface KeyboardEvent extends Event {}
 interface MouseEvent extends Event {}
 interface TouchEvent extends Event {}
 interface PointerEvent extends Event {}
+interface SubmitEvent extends Event {}
 interface ToggleEvent extends Event {}
 interface TransitionEvent extends Event {}
 interface UIEvent extends Event {}

package/src/deps/esm.sh/@types/{react@19.2.3 → react@19.2.14}/index.d.ts

@@ -16,6 +16,7 @@ type NativeKeyboardEvent = KeyboardEvent;
 type NativeMouseEvent = MouseEvent;
 type NativeTouchEvent = TouchEvent;
 type NativePointerEvent = PointerEvent;
+type NativeSubmitEvent = SubmitEvent;
 type NativeToggleEvent = ToggleEvent;
 type NativeTransitionEvent = TransitionEvent;
 type NativeUIEvent = UIEvent;
@@ -225,12 +226,20 @@ declare namespace React {
 
     type ComponentState = any;
 
+    interface DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_KEY_TYPES {}
+
     /**
      * A value which uniquely identifies a node among items in an array.
      *
      * @see {@link https://react.dev/learn/rendering-lists#keeping-list-items-in-order-with-key React Docs}
      */
-    type Key = string | number | bigint;
+    type Key =
+        | string
+        | number
+        | bigint
+        | DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_KEY_TYPES[
+            keyof DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_KEY_TYPES
+        ];
 
     /**
      * @internal The props any component can receive.
@@ -1884,7 +1893,7 @@ declare namespace React {
      *
      * @param callback A synchronous, void callback that will execute as a single, complete React commit.
      *
-     * @see https://reactjs.org/blog/2019/02/06/react-v16.8.0.html#testing-hooks
+     * @see {@link https://reactjs.org/blog/2019/02/06/react-v16.8.0.html#testing-hooks}
      */
     // NOTES
     // - the order of these signatures matters - typescript will check the signatures in source order.
@@ -1926,7 +1935,31 @@ declare namespace React {
         reducer: (state: State, action: Action) => State,
     ): [State, (action: Action) => void];
 
-    export type Usable<T> = PromiseLike<T> | Context<T>;
+    interface UntrackedReactPromise<T> extends PromiseLike<T> {
+        status?: void;
+    }
+
+    export interface PendingReactPromise<T> extends PromiseLike<T> {
+        status: "pending";
+    }
+
+    export interface FulfilledReactPromise<T> extends PromiseLike<T> {
+        status: "fulfilled";
+        value: T;
+    }
+
+    export interface RejectedReactPromise<T> extends PromiseLike<T> {
+        status: "rejected";
+        reason: unknown;
+    }
+
+    export type ReactPromise<T> =
+        | UntrackedReactPromise<T>
+        | PendingReactPromise<T>
+        | FulfilledReactPromise<T>
+        | RejectedReactPromise<T>;
+
+    export type Usable<T> = ReactPromise<T> | Context<T>;
 
     export function use<T>(usable: Usable<T>): T;
 
@@ -2041,15 +2074,28 @@ declare namespace React {
         target: EventTarget & Target;
     }
 
+    /**
+     * @deprecated FormEvent doesn't actually exist.
+     *             You probably meant to use {@link ChangeEvent}, {@link InputEvent}, {@link SubmitEvent}, or just {@link SyntheticEvent} instead
+     *             depending on the event type.
+     */
     interface FormEvent<T = Element> extends SyntheticEvent<T> {
     }
 
     interface InvalidEvent<T = Element> extends SyntheticEvent<T> {
-        target: EventTarget & T;
     }
 
-    interface ChangeEvent<T = Element> extends SyntheticEvent<T> {
-        target: EventTarget & T;
+    /**
+     * change events bubble in React so their target is generally unknown.
+     * Only for form elements we know their target type because form events can't
+     * be nested.
+     * This type exists purely to narrow `target` for form elements. It doesn't
+     * reflect a DOM event. Change events are just fired as standard {@link SyntheticEvent}.
+     */
+    interface ChangeEvent<CurrentTarget = Element, Target = Element> extends SyntheticEvent<CurrentTarget> {
+        // TODO: This is wrong for change event handlers on arbitrary. Should
+        // be EventTarget & Target, but kept for backward compatibility until React 20.
+        target: EventTarget & CurrentTarget;
     }
 
     interface InputEvent<T = Element> extends SyntheticEvent<T, NativeInputEvent> {
@@ -2119,6 +2165,13 @@ declare namespace React {
         shiftKey: boolean;
     }
 
+    interface SubmitEvent<T = Element> extends SyntheticEvent<T, NativeSubmitEvent> {
+        // `submitter` is available in react@canary
+        // submitter: HTMLElement | null;
+        // SubmitEvents are always targetted at HTMLFormElements.
+        target: EventTarget & HTMLFormElement;
+    }
+
     interface TouchEvent<T = Element> extends UIEvent<T, NativeTouchEvent> {
         altKey: boolean;
         changedTouches: TouchList;
@@ -2174,11 +2227,19 @@ declare namespace React {
     type CompositionEventHandler<T = Element> = EventHandler<CompositionEvent<T>>;
     type DragEventHandler<T = Element> = EventHandler<DragEvent<T>>;
     type FocusEventHandler<T = Element> = EventHandler<FocusEvent<T>>;
+    /**
+     * @deprecated FormEventHandler doesn't actually exist.
+     *             You probably meant to use {@link ChangeEventHandler}, {@link InputEventHandler}, {@link SubmitEventHandler}, or just {@link EventHandler} instead
+     *             depending on the event type.
+     */
     type FormEventHandler<T = Element> = EventHandler<FormEvent<T>>;
-    type ChangeEventHandler<T = Element> = EventHandler<ChangeEvent<T>>;
+    type ChangeEventHandler<CurrentTarget = Element, Target = Element> = EventHandler<
+        ChangeEvent<CurrentTarget, Target>
+    >;
     type InputEventHandler<T = Element> = EventHandler<InputEvent<T>>;
     type KeyboardEventHandler<T = Element> = EventHandler<KeyboardEvent<T>>;
     type MouseEventHandler<T = Element> = EventHandler<MouseEvent<T>>;
+    type SubmitEventHandler<T = Element> = EventHandler<SubmitEvent<T>>;
     type TouchEventHandler<T = Element> = EventHandler<TouchEvent<T>>;
     type PointerEventHandler<T = Element> = EventHandler<PointerEvent<T>>;
     type UIEventHandler<T = Element> = EventHandler<UIEvent<T>>;
@@ -2232,19 +2293,19 @@ declare namespace React {
         onBlur?: FocusEventHandler<T> | undefined;
         onBlurCapture?: FocusEventHandler<T> | undefined;
 
-        // Form Events
-        onChange?: FormEventHandler<T> | undefined;
-        onChangeCapture?: FormEventHandler<T> | undefined;
+        // form related Events
+        onChange?: ChangeEventHandler<T> | undefined;
+        onChangeCapture?: ChangeEventHandler<T> | undefined;
         onBeforeInput?: InputEventHandler<T> | undefined;
-        onBeforeInputCapture?: FormEventHandler<T> | undefined;
-        onInput?: FormEventHandler<T> | undefined;
-        onInputCapture?: FormEventHandler<T> | undefined;
-        onReset?: FormEventHandler<T> | undefined;
-        onResetCapture?: FormEventHandler<T> | undefined;
-        onSubmit?: FormEventHandler<T> | undefined;
-        onSubmitCapture?: FormEventHandler<T> | undefined;
-        onInvalid?: FormEventHandler<T> | undefined;
-        onInvalidCapture?: FormEventHandler<T> | undefined;
+        onBeforeInputCapture?: InputEventHandler<T> | undefined;
+        onInput?: InputEventHandler<T> | undefined;
+        onInputCapture?: InputEventHandler<T> | undefined;
+        onReset?: ReactEventHandler<T> | undefined;
+        onResetCapture?: ReactEventHandler<T> | undefined;
+        onSubmit?: SubmitEventHandler<T> | undefined;
+        onSubmitCapture?: SubmitEventHandler<T> | undefined;
+        onInvalid?: ReactEventHandler<T> | undefined;
+        onInvalidCapture?: ReactEventHandler<T> | undefined;
 
         // Image Events
         onLoad?: ReactEventHandler<T> | undefined;
@@ -2788,7 +2849,7 @@ declare namespace React {
 
         // Living Standard
         /**
-         * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/inert
+         * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/inert}
          */
         inert?: boolean | undefined;
         /**
@@ -3251,7 +3312,9 @@ declare namespace React {
         value?: string | readonly string[] | number | undefined;
         width?: number | string | undefined;
 
-        onChange?: ChangeEventHandler<T> | undefined;
+        // No other element dispatching change events can be nested in a <input>
+        // so we know the target will be a HTMLInputElement.
+        onChange?: ChangeEventHandler<T, HTMLInputElement> | undefined;
     }
 
     interface KeygenHTMLAttributes<T> extends HTMLAttributes<T> {
@@ -3416,7 +3479,9 @@ declare namespace React {
         required?: boolean | undefined;
         size?: number | undefined;
         value?: string | readonly string[] | number | undefined;
-        onChange?: ChangeEventHandler<T> | undefined;
+        // No other element dispatching change events can be nested in a <select>
+        // so we know the target will be a HTMLSelectElement.
+        onChange?: ChangeEventHandler<T, HTMLSelectElement> | undefined;
     }
 
     interface SourceHTMLAttributes<T> extends HTMLAttributes<T> {
@@ -3468,7 +3533,9 @@ declare namespace React {
         value?: string | readonly string[] | number | undefined;
         wrap?: string | undefined;
 
-        onChange?: ChangeEventHandler<T> | undefined;
+        // No other element dispatching change events can be nested in a <textarea>
+        // so we know the target will be a HTMLTextAreaElement.
+        onChange?: ChangeEventHandler<T, HTMLTextAreaElement> | undefined;
     }
 
     interface TdHTMLAttributes<T> extends HTMLAttributes<T> {
@@ -3540,6 +3607,9 @@ declare namespace React {
         method?: string | undefined;
         min?: number | string | undefined;
         name?: string | undefined;
+        nonce?: string | undefined;
+        part?: string | undefined;
+        slot?: string | undefined;
         style?: CSSProperties | undefined;
         target?: string | undefined;
         type?: string | undefined;
@@ -4057,7 +4127,6 @@ declare namespace React {
          * Captures which component contained the exception, and its ancestors.
          */
         componentStack?: string | null;
-        digest?: string | null;
     }
 
     // Keep in sync with JSX namespace in ./jsx-runtime.d.ts and ./jsx-dev-runtime.d.ts

package/src/deps/esm.sh/react-dom@19.2.4/client.d.ts

@@ -4,7 +4,7 @@
 
 // See https://github.com/facebook/react/blob/main/packages/react-dom/client.js to see how the exports are declared,
 
-import React = require("https://esm.sh/@types/react@19.2.3/index.d.ts");
+import React = require("https://esm.sh/@types/react@19.2.14/index.d.ts");
 
 export {};
 

package/src/src/agent/index.ts

@@ -766,6 +766,14 @@ export {
   type RuntimeProjectSkillLoaderLogger,
   type RuntimeProjectSkillLoaderOptions,
 } from "./runtime-project-skill-loader.js";
+export {
+  getRuntimeProjectInstructions,
+  getRuntimeProjectSkillCatalog,
+  loadRuntimeBuiltinSkillCatalog,
+  type RuntimeProjectInstructionsOptions,
+  type RuntimeProjectSkillCatalogOptions,
+  type RuntimeProjectSteeringLookup,
+} from "./runtime-project-skill-catalog.js";
 export {
   buildRuntimeLoadedSkillResponse,
   buildRuntimeSkillDefinition,
@@ -1161,12 +1169,19 @@ export {
 } from "./chat-handler.js";
 export {
   AgentRuntime,
+  getProviderToolProfile,
+  type ProviderToolCompatOptions,
+  type ProviderToolCompatProvider,
+  type ProviderToolProfile,
   RunAlreadyExistsError,
   RunCancelledError,
   RunNotActiveError,
   RunResumeSessionManager,
   type RunResumeSessionManagerOptions,
   type RunSessionStatus,
+  sanitizeProviderToolSchema,
+  selectProviderCompatibleToolNames,
+  selectProviderCompatibleTools,
   type SubmitResumeValueOutcome,
   WaitConflictError,
   WaitNotPendingError,

package/src/src/agent/runtime/index.ts

@@ -74,6 +74,15 @@ export {
   parseToolArgs,
 } from "./tool-helpers.js";
 export type { ParsedToolArgs, ToolConfigEntry } from "./tool-helpers.js";
+export {
+  getProviderToolProfile,
+  type ProviderToolCompatOptions,
+  type ProviderToolCompatProvider,
+  type ProviderToolProfile,
+  sanitizeProviderToolSchema,
+  selectProviderCompatibleToolNames,
+  selectProviderCompatibleTools,
+} from "./provider-tool-compat.js";
 export { accumulateUsage, getMaxSteps, normalizeInput } from "./input-utils.js";
 export { createStreamState, processStream } from "./chat-stream-handler.js";
 export type {

package/src/src/agent/runtime/model-tool-converter.ts

@@ -18,6 +18,10 @@ import {
   createAnthropicWebFetchToolSet,
   createAnthropicWebSearchToolSet,
 } from "./provider-native-tools.js";
+import {
+  sanitizeProviderToolSchema,
+  selectProviderCompatibleTools,
+} from "./provider-tool-compat.js";
 
 export interface ConvertToolsToRuntimeToolsOptions {
   model?: string;
@@ -63,14 +67,19 @@ export function convertToolsToRuntimeTools(
   options?: ConvertToolsToRuntimeToolsOptions,
 ): RuntimeToolSet | undefined {
   const toolSet: RuntimeToolSet = {};
+  const compatibleTools = selectProviderCompatibleTools(tools, {
+    model: options?.model,
+  });
 
-  for (const def of tools) {
+  for (const def of compatibleTools) {
     addRuntimeTool(
       toolSet,
       def.name,
       createRuntimeTool({
         description: def.description,
-        inputSchema: createRuntimeJsonSchema(def.parameters),
+        inputSchema: createRuntimeJsonSchema(
+          sanitizeProviderToolSchema(def.parameters, { model: options?.model }),
+        ),
       }),
     );
   }

package/src/src/agent/runtime/provider-tool-compat.ts

@@ -0,0 +1,254 @@
+import type { ToolDefinition } from "../../tool/index.js";
+import type { JsonSchema } from "../../tool/schema/index.js";
+
+export type ProviderToolCompatProvider =
+  | "anthropic"
+  | "google"
+  | "moonshot"
+  | "openai"
+  | "unknown";
+
+export interface ProviderToolProfile {
+  provider: ProviderToolCompatProvider;
+  maxTools?: number;
+  sanitizeSchema: boolean;
+}
+
+export interface ProviderToolCompatOptions {
+  model?: string;
+  requiredToolNames?: readonly string[];
+}
+
+const OPENAI_MAX_TOOLS = 128;
+const GOOGLE_UNSUPPORTED_SCHEMA_KEYS = new Set([
+  "$id",
+  "$ref",
+  "$schema",
+  "additionalProperties",
+  "allOf",
+  "default",
+  "exclusiveMaximum",
+  "exclusiveMinimum",
+  "oneOf",
+  "prefixItems",
+]);
+
+function normalizeModel(model?: string): string {
+  return model?.trim().toLowerCase() ?? "";
+}
+
+export function getProviderToolProfile(model?: string): ProviderToolProfile {
+  const normalized = normalizeModel(model);
+  const parts = normalized.split("/").filter(Boolean);
+  const provider = parts[0] === "veryfront-cloud" ? parts[1] : parts[0];
+
+  if (provider === "openai") {
+    return { provider: "openai", maxTools: OPENAI_MAX_TOOLS, sanitizeSchema: false };
+  }
+
+  if (provider === "google" || provider === "google-ai-studio") {
+    return { provider: "google", sanitizeSchema: true };
+  }
+
+  if (provider === "anthropic") {
+    return { provider: "anthropic", sanitizeSchema: false };
+  }
+
+  if (provider === "moonshot") {
+    return { provider: "moonshot", sanitizeSchema: false };
+  }
+
+  return { provider: "unknown", sanitizeSchema: false };
+}
+
+function uniqueInOrder(values: readonly string[]): string[] {
+  const seen = new Set<string>();
+  const result: string[] = [];
+
+  for (const value of values) {
+    if (seen.has(value)) continue;
+    seen.add(value);
+    result.push(value);
+  }
+
+  return result;
+}
+
+export function selectProviderCompatibleToolNames(
+  toolNames: readonly string[],
+  options: ProviderToolCompatOptions = {},
+): string[] {
+  const profile = getProviderToolProfile(options.model);
+  const orderedToolNames = uniqueInOrder(toolNames);
+
+  if (profile.maxTools === undefined || orderedToolNames.length <= profile.maxTools) {
+    return orderedToolNames;
+  }
+
+  const available = new Set(orderedToolNames);
+  const requiredToolNames = uniqueInOrder(options.requiredToolNames ?? [])
+    .filter((toolName) => available.has(toolName));
+  const selected = [...requiredToolNames];
+  const selectedSet = new Set(selected);
+
+  for (const toolName of orderedToolNames) {
+    if (selected.length >= profile.maxTools) break;
+    if (selectedSet.has(toolName)) continue;
+    selected.push(toolName);
+    selectedSet.add(toolName);
+  }
+
+  return selected.slice(0, profile.maxTools);
+}
+
+export function selectProviderCompatibleTools(
+  tools: readonly ToolDefinition[],
+  options: ProviderToolCompatOptions = {},
+): ToolDefinition[] {
+  const toolsByName = new Map<string, ToolDefinition>();
+  for (const tool of tools) {
+    if (!toolsByName.has(tool.name)) toolsByName.set(tool.name, tool);
+  }
+
+  const selectedToolNames = selectProviderCompatibleToolNames(
+    [...toolsByName.keys()],
+    options,
+  );
+
+  return selectedToolNames
+    .map((toolName) => toolsByName.get(toolName))
+    .filter((tool): tool is ToolDefinition => tool !== undefined);
+}
+
+function isPlainRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function getLiteralType(value: unknown): JsonSchema["type"] | undefined {
+  switch (typeof value) {
+    case "string":
+      return "string";
+    case "number":
+      return Number.isInteger(value) ? "integer" : "number";
+    case "boolean":
+      return "boolean";
+    default:
+      return value === null ? "null" : undefined;
+  }
+}
+
+function getEnumValuesFromAnyOf(anyOf: unknown): unknown[] | undefined {
+  if (!Array.isArray(anyOf)) return undefined;
+
+  const values: unknown[] = [];
+  for (const option of anyOf) {
+    if (!isPlainRecord(option)) return undefined;
+    if ("const" in option) {
+      values.push(option.const);
+      continue;
+    }
+    if (Array.isArray(option.enum) && option.enum.length > 0) {
+      values.push(...option.enum);
+      continue;
+    }
+    return undefined;
+  }
+
+  return values.length > 0 ? uniqueUnknownValues(values) : undefined;
+}
+
+function uniqueUnknownValues(values: unknown[]): unknown[] {
+  const result: unknown[] = [];
+  for (const value of values) {
+    if (result.some((existing) => Object.is(existing, value))) continue;
+    result.push(value);
+  }
+  return result;
+}
+
+function getSharedLiteralType(values: readonly unknown[]): JsonSchema["type"] | undefined {
+  const literalTypes = values.map((value) => getLiteralType(value));
+  const firstType = literalTypes[0];
+
+  if (!firstType || literalTypes.some((literalType) => literalType !== firstType)) {
+    return undefined;
+  }
+
+  return firstType;
+}
+
+function getGoogleCompatibleSchemaType(type: unknown): unknown {
+  if (!Array.isArray(type)) return type;
+
+  const nonNullTypes = type.filter((value) => value !== "null");
+  return nonNullTypes.length === 1 ? nonNullTypes[0] : undefined;
+}
+
+function sanitizeGoogleSchemaValue(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return value.map((item) => sanitizeGoogleSchemaValue(item));
+  }
+
+  if (!isPlainRecord(value)) {
+    return value;
+  }
+
+  const sanitized: Record<string, unknown> = {};
+  const enumFromAnyOf = getEnumValuesFromAnyOf(value.anyOf);
+  const constValue = value.const;
+
+  for (const [key, child] of Object.entries(value)) {
+    if (key === "const" || key === "anyOf" || GOOGLE_UNSUPPORTED_SCHEMA_KEYS.has(key)) {
+      continue;
+    }
+
+    if (key === "type") {
+      const compatibleType = getGoogleCompatibleSchemaType(child);
+      if (compatibleType !== undefined) sanitized.type = compatibleType;
+      continue;
+    }
+
+    if (key === "properties" && isPlainRecord(child)) {
+      sanitized.properties = Object.fromEntries(
+        Object.entries(child).map(([propertyName, propertySchema]) => [
+          propertyName,
+          sanitizeGoogleSchemaValue(propertySchema),
+        ]),
+      );
+      continue;
+    }
+
+    if (key === "items") {
+      sanitized.items = sanitizeGoogleSchemaValue(child);
+      continue;
+    }
+
+    sanitized[key] = sanitizeGoogleSchemaValue(child);
+  }
+
+  if (enumFromAnyOf) {
+    sanitized.enum = enumFromAnyOf;
+    if (!sanitized.type) {
+      const sharedType = getSharedLiteralType(enumFromAnyOf);
+      if (sharedType) sanitized.type = sharedType;
+    }
+  } else if ("const" in value) {
+    sanitized.enum = [constValue];
+    if (!sanitized.type) {
+      const literalType = getLiteralType(constValue);
+      if (literalType) sanitized.type = literalType;
+    }
+  }
+
+  return sanitized;
+}
+
+export function sanitizeProviderToolSchema(
+  schema: JsonSchema,
+  options: Pick<ProviderToolCompatOptions, "model"> = {},
+): JsonSchema {
+  const profile = getProviderToolProfile(options.model);
+  if (!profile.sanitizeSchema) return schema;
+
+  return sanitizeGoogleSchemaValue(schema) as JsonSchema;
+}