veryfront 0.1.434 → 0.1.436

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

@@ -0,0 +1,239 @@
+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",
+  "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 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 === "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;
+}

package/src/src/agent/runtime-project-skill-catalog.ts

@@ -0,0 +1,238 @@
+import { basename } from "node:path";
+import {
+  DEFAULT_PROJECT_STEERING_PATHS,
+  type ProjectSteeringPaths,
+} from "./project-steering-mutation.js";
+import type {
+  RuntimeGetProjectFileOptions,
+  RuntimeProjectFile,
+  RuntimeProjectFileListItem,
+  RuntimeProjectFilesApiOptions,
+} from "./runtime-project-files-client.js";
+import {
+  listRuntimeBuiltinSkillReferences,
+  readRuntimeBuiltinDirectorySkill,
+  readRuntimeBuiltinFlatSkill,
+  readRuntimeBuiltinSkillEntries,
+} from "./runtime-builtin-skill-files.js";
+import {
+  buildRuntimeSkillDefinition,
+  type RuntimeSkillDefinition,
+  type RuntimeSkillMetadataLogger,
+} from "./runtime-skill-metadata.js";
+
+export type RuntimeProjectSteeringLookup = {
+  projectId: string;
+  authToken: string;
+  branchId?: string | null;
+};
+
+export type RuntimeProjectSkillCatalogOptions = {
+  getProjectFile: (options: RuntimeGetProjectFileOptions) => Promise<RuntimeProjectFile | null>;
+  getProjectFiles: (
+    options: RuntimeProjectFilesApiOptions,
+  ) => Promise<readonly RuntimeProjectFileListItem[] | null>;
+  builtinSkills: readonly RuntimeSkillDefinition[];
+  steeringPaths?: Pick<ProjectSteeringPaths, "skills">;
+  logger?: RuntimeSkillMetadataLogger;
+};
+
+export type RuntimeProjectInstructionsOptions = {
+  getProjectFile: (options: RuntimeGetProjectFileOptions) => Promise<RuntimeProjectFile | null>;
+  steeringPaths?: Pick<ProjectSteeringPaths, "instructions">;
+};
+
+function sortSkillsById(skills: Iterable<RuntimeSkillDefinition>): RuntimeSkillDefinition[] {
+  return [...skills].sort((a, b) => a.id.localeCompare(b.id));
+}
+
+function getSkillPaths(options: Pick<RuntimeProjectSkillCatalogOptions, "steeringPaths">) {
+  return options.steeringPaths?.skills ?? DEFAULT_PROJECT_STEERING_PATHS.skills;
+}
+
+function getInstructionPaths(options: RuntimeProjectInstructionsOptions) {
+  return options.steeringPaths?.instructions ?? DEFAULT_PROJECT_STEERING_PATHS.instructions;
+}
+
+export function loadRuntimeBuiltinSkillCatalog(input: {
+  skillsDir: string;
+  logger?: RuntimeSkillMetadataLogger;
+}): RuntimeSkillDefinition[] {
+  const entriesResult = readRuntimeBuiltinSkillEntries(input.skillsDir);
+  if (!entriesResult.ok) {
+    input.logger?.error?.("Failed to load built-in skills", {
+      error: entriesResult.errorMessage,
+      skillsDir: input.skillsDir,
+    });
+    return [];
+  }
+
+  return sortSkillsById(
+    entriesResult.entries.flatMap((entry) => {
+      if (entry.isFile() && entry.name.endsWith(".md")) {
+        const id = basename(entry.name, ".md");
+        const content = readRuntimeBuiltinFlatSkill(input.skillsDir, id);
+        if (content === null) {
+          return [];
+        }
+
+        const definition = buildRuntimeSkillDefinition({
+          id,
+          content,
+          logger: input.logger,
+        });
+
+        return definition ? [definition] : [];
+      }
+
+      if (entry.isDirectory()) {
+        const content = readRuntimeBuiltinDirectorySkill(input.skillsDir, entry.name);
+        if (content === null) {
+          return [];
+        }
+
+        const definition = buildRuntimeSkillDefinition({
+          id: entry.name,
+          content,
+          references: listRuntimeBuiltinSkillReferences(input.skillsDir, entry.name),
+          logger: input.logger,
+        });
+
+        return definition ? [definition] : [];
+      }
+
+      return [];
+    }),
+  );
+}
+
+export async function getRuntimeProjectInstructions(
+  input: RuntimeProjectSteeringLookup & RuntimeProjectInstructionsOptions,
+): Promise<string> {
+  for (const filePath of getInstructionPaths(input)) {
+    const file = await input.getProjectFile({
+      projectId: input.projectId,
+      authToken: input.authToken,
+      branchId: input.branchId,
+      path: filePath,
+    });
+
+    if (file?.content) {
+      return file.content;
+    }
+  }
+
+  return "";
+}
+
+export async function getRuntimeProjectSkillCatalog(
+  input: RuntimeProjectSteeringLookup & RuntimeProjectSkillCatalogOptions,
+): Promise<RuntimeSkillDefinition[]> {
+  const allFiles = await input.getProjectFiles({
+    projectId: input.projectId,
+    authToken: input.authToken,
+    branchId: input.branchId,
+  });
+  if (!allFiles || allFiles.length === 0) {
+    return [...input.builtinSkills];
+  }
+
+  const projectSkillsById = new Map<string, RuntimeSkillDefinition>();
+
+  for (const prefix of getSkillPaths(input)) {
+    const prefixWithSlash = `${prefix}/`;
+
+    const flatPaths = allFiles
+      .filter((file) => {
+        if (!file.path.startsWith(prefixWithSlash) || !file.path.endsWith(".md")) {
+          return false;
+        }
+
+        const relative = file.path.slice(prefixWithSlash.length);
+        return !relative.includes("/");
+      })
+      .map((file) => file.path);
+
+    const dirPaths = allFiles
+      .filter((file) => file.path.startsWith(prefixWithSlash) && file.path.endsWith("/SKILL.md"))
+      .map((file) => file.path);
+
+    const skillPaths = [...dirPaths.sort(), ...flatPaths.sort()];
+    if (skillPaths.length === 0) {
+      continue;
+    }
+
+    const skillFiles = await Promise.all(
+      skillPaths.map((path) =>
+        input.getProjectFile({
+          projectId: input.projectId,
+          authToken: input.authToken,
+          branchId: input.branchId,
+          path,
+        })
+      ),
+    );
+
+    for (const file of skillFiles) {
+      if (!file?.content) {
+        continue;
+      }
+
+      const isFlat = file.path.endsWith(".md") && !file.path.endsWith("/SKILL.md");
+      const id = getProjectSkillId(file.path, isFlat);
+      if (!id) {
+        continue;
+      }
+
+      const definition = buildRuntimeSkillDefinition({
+        id,
+        content: file.content,
+        references: getProjectSkillReferences({ allFiles, file, isFlat }),
+        logger: input.logger,
+      });
+
+      if (definition && !projectSkillsById.has(definition.id)) {
+        projectSkillsById.set(definition.id, definition);
+      }
+    }
+  }
+
+  if (projectSkillsById.size === 0) {
+    return [...input.builtinSkills];
+  }
+
+  const mergedSkillsById = new Map(input.builtinSkills.map((skill) => [skill.id, skill]));
+  for (const skill of projectSkillsById.values()) {
+    mergedSkillsById.set(skill.id, skill);
+  }
+
+  return sortSkillsById(mergedSkillsById.values());
+}
+
+function getProjectSkillId(path: string, isFlat: boolean): string | null {
+  const pathParts = path.split("/");
+  const fileName = pathParts.at(-1);
+  if (isFlat) {
+    return fileName ? basename(fileName, ".md") : null;
+  }
+
+  return pathParts.at(-2) ?? null;
+}
+
+function getProjectSkillReferences(input: {
+  allFiles: readonly RuntimeProjectFileListItem[];
+  file: RuntimeProjectFile;
+  isFlat: boolean;
+}): string[] {
+  if (input.isFlat) {
+    return [];
+  }
+
+  const skillRootPrefix = input.file.path.replace(/SKILL\.md$/, "");
+  const refsPrefix = `${skillRootPrefix}references/`;
+
+  return input.allFiles
+    .filter((file) => file.path.startsWith(refsPrefix))
+    .map((file) => file.path.slice(skillRootPrefix.length))
+    .sort();
+}

package/src/src/agent/runtime-project-skill-loader.ts

@@ -0,0 +1,217 @@
+import {
+  DEFAULT_PROJECT_STEERING_PATHS,
+  type ProjectSteeringPaths,
+} from "./project-steering-mutation.js";
+import type {
+  RuntimeGetProjectFileOptions,
+  RuntimeProjectFile,
+  RuntimeProjectFileListItem,
+  RuntimeProjectFilesApiOptions,
+} from "./runtime-project-files-client.js";
+import { normalizeRuntimeSkillReferencePath } from "./runtime-skill-metadata.js";
+
+export type RuntimeProjectSkillContext = {
+  projectId?: string | null;
+  authToken: string;
+  branchId?: string | null;
+};
+
+export type RuntimeLoadedProjectSkill = {
+  instructions: string;
+  references: string[];
+};
+
+export type RuntimeProjectSkillLoaderLogger = {
+  warn?: (message: string, metadata?: Record<string, unknown>) => void;
+};
+
+export type RuntimeProjectSkillLoaderOptions = {
+  getProjectFile: (options: RuntimeGetProjectFileOptions) => Promise<RuntimeProjectFile | null>;
+  getProjectFiles: (
+    options: RuntimeProjectFilesApiOptions,
+  ) => Promise<RuntimeProjectFileListItem[]>;
+  steeringPaths?: Pick<ProjectSteeringPaths, "skills">;
+  isAccessDeniedError?: (error: unknown) => boolean;
+  logger?: RuntimeProjectSkillLoaderLogger;
+};
+
+export type RuntimeProjectSkillLoader = {
+  listProjectSkillReferences: (
+    context: RuntimeProjectSkillContext,
+    skillId: string,
+  ) => Promise<string[]>;
+  loadProjectSkill: (
+    context: RuntimeProjectSkillContext,
+    skillId: string,
+  ) => Promise<RuntimeLoadedProjectSkill | null>;
+  loadProjectSkillReference: (
+    context: RuntimeProjectSkillContext,
+    skillId: string,
+    normalizedFile: string,
+  ) => Promise<string | null>;
+};
+
+function getSkillPaths(options: RuntimeProjectSkillLoaderOptions): readonly string[] {
+  return options.steeringPaths?.skills ?? DEFAULT_PROJECT_STEERING_PATHS.skills;
+}
+
+function isAccessDeniedError(
+  error: unknown,
+  options: RuntimeProjectSkillLoaderOptions,
+): boolean {
+  return options.isAccessDeniedError?.(error) ?? false;
+}
+
+async function listProjectSkillReferences(input: {
+  options: RuntimeProjectSkillLoaderOptions;
+  context: RuntimeProjectSkillContext;
+  skillId: string;
+}): Promise<string[]> {
+  const projectId = input.context.projectId;
+  if (!projectId) {
+    return [];
+  }
+
+  const allFiles = await input.options.getProjectFiles({
+    projectId,
+    authToken: input.context.authToken,
+    branchId: input.context.branchId,
+  });
+  const references = new Set<string>();
+
+  for (const skillsPath of getSkillPaths(input.options)) {
+    const skillPrefix = `${skillsPath}/${input.skillId}/`;
+    const refsPrefix = `${skillPrefix}references/`;
+
+    for (const file of allFiles) {
+      if (!file.path.startsWith(refsPrefix)) {
+        continue;
+      }
+
+      const relativePath = file.path.slice(skillPrefix.length);
+      if (!relativePath.includes("/")) {
+        continue;
+      }
+
+      const normalizedReference = normalizeRuntimeSkillReferencePath(relativePath);
+      if (normalizedReference) {
+        references.add(normalizedReference);
+      }
+    }
+  }
+
+  return [...references].sort();
+}
+
+async function loadProjectSkill(input: {
+  options: RuntimeProjectSkillLoaderOptions;
+  context: RuntimeProjectSkillContext;
+  skillId: string;
+}): Promise<RuntimeLoadedProjectSkill | null> {
+  const projectId = input.context.projectId;
+  if (!projectId) {
+    return null;
+  }
+
+  try {
+    for (const skillsPath of getSkillPaths(input.options)) {
+      const directorySkill = await input.options.getProjectFile({
+        projectId,
+        authToken: input.context.authToken,
+        branchId: input.context.branchId,
+        path: `${skillsPath}/${input.skillId}/SKILL.md`,
+      });
+
+      if (directorySkill?.content) {
+        return {
+          instructions: directorySkill.content,
+          references: await listProjectSkillReferences(input),
+        };
+      }
+
+      const flatSkill = await input.options.getProjectFile({
+        projectId,
+        authToken: input.context.authToken,
+        branchId: input.context.branchId,
+        path: `${skillsPath}/${input.skillId}.md`,
+      });
+
+      if (flatSkill?.content) {
+        return {
+          instructions: flatSkill.content,
+          references: [],
+        };
+      }
+    }
+  } catch (error) {
+    if (isAccessDeniedError(error, input.options)) {
+      input.options.logger?.warn?.(
+        "Falling back to builtin skill after project skill lookup was denied",
+        {
+          projectId,
+          branchId: input.context.branchId ?? null,
+          skillId: input.skillId,
+        },
+      );
+      return null;
+    }
+
+    throw error;
+  }
+
+  return null;
+}
+
+async function loadProjectSkillReference(input: {
+  options: RuntimeProjectSkillLoaderOptions;
+  context: RuntimeProjectSkillContext;
+  skillId: string;
+  normalizedFile: string;
+}): Promise<string | null> {
+  const projectId = input.context.projectId;
+  if (!projectId) {
+    return null;
+  }
+
+  try {
+    for (const skillsPath of getSkillPaths(input.options)) {
+      const projectFile = await input.options.getProjectFile({
+        projectId,
+        authToken: input.context.authToken,
+        branchId: input.context.branchId,
+        path: `${skillsPath}/${input.skillId}/${input.normalizedFile}`,
+      });
+      if (projectFile?.content) {
+        return projectFile.content;
+      }
+    }
+  } catch (error) {
+    if (!isAccessDeniedError(error, input.options)) {
+      throw error;
+    }
+
+    input.options.logger?.warn?.(
+      "Falling back to builtin skill reference after project skill lookup was denied",
+      {
+        projectId,
+        branchId: input.context.branchId ?? null,
+        skillId: input.skillId,
+        file: input.normalizedFile,
+      },
+    );
+  }
+
+  return null;
+}
+
+export function createRuntimeProjectSkillLoader(
+  options: RuntimeProjectSkillLoaderOptions,
+): RuntimeProjectSkillLoader {
+  return {
+    listProjectSkillReferences: (context, skillId) =>
+      listProjectSkillReferences({ options, context, skillId }),
+    loadProjectSkill: (context, skillId) => loadProjectSkill({ options, context, skillId }),
+    loadProjectSkillReference: (context, skillId, normalizedFile) =>
+      loadProjectSkillReference({ options, context, skillId, normalizedFile }),
+  };
+}

package/src/src/utils/version-constant.ts

@@ -1,3 +1,3 @@
 // Keep in sync with deno.json version.
 // scripts/release.ts updates this constant during releases.
-export const VERSION = "0.1.434";
+export const VERSION = "0.1.436";