nolo-cli 0.1.44 → 0.1.46

package/agent-runtime/hostAdapter.ts

@@ -1,81 +0,0 @@
-import type {
-  AgentRuntimeChatMessage,
-  AgentRuntimeHost,
-  AgentRuntimeResult,
-  AgentRuntimeToolPolicy,
-} from "./types";
-
-export type AgentRuntimeAgentConfig = {
-  key: string;
-  name?: string;
-  prompt?: string;
-  model?: string;
-  provider?: string;
-  apiSource?: string;
-  cliProvider?: string;
-  customProviderUrl?: string;
-  apiKey?: string;
-  apiKeyHeader?: string;
-  apiKeyFromAgentKey?: string;
-  useServerProxy?: boolean;
-  toolNames?: string[];
-  temperature?: number;
-  top_p?: number;
-  frequency_penalty?: number;
-  presence_penalty?: number;
-  max_tokens?: number;
-  reasoning_effort?: string;
-  runtimeBinding?: Record<string, unknown>;
-  runtimeToolPolicy?: AgentRuntimeToolPolicy;
-  delegation?: Record<string, unknown>;
-  rawRecord?: Record<string, unknown>;
-};
-
-export type AgentRuntimeProvider = {
-  model: string;
-  complete(
-    messages: AgentRuntimeChatMessage[],
-    options?: { timeoutMs?: number }
-  ): Promise<AgentRuntimeResult>;
-};
-
-export type AgentRuntimeToolCallInput = {
-  id: string;
-  name: string;
-  arguments: string;
-  userInput?: string;
-};
-
-export type AgentRuntimeToolResult = {
-  content: string;
-  metadata?: Record<string, unknown>;
-};
-
-export type AgentRuntimeSaveTurnInput = {
-  agentKey: string;
-  messages: AgentRuntimeChatMessage[];
-  result: AgentRuntimeResult;
-  runtimeContext?: Record<string, any> | null;
-  continueDialogId?: string;
-  spaceId?: string;
-  category?: string;
-  inheritedFromDialogKey?: string;
-  parentDialogId?: string;
-};
-
-export type AgentRuntimeHostAdapter = {
-  host: AgentRuntimeHost;
-  capabilities: string[];
-  loadAgentConfig(agentRef: string): Promise<AgentRuntimeAgentConfig | null>;
-  loadDialogHistory(dialogId: string): Promise<AgentRuntimeChatMessage[]>;
-  saveTurn(input: AgentRuntimeSaveTurnInput): Promise<{ dialogId: string }>;
-  resolveProvider(agentConfig: AgentRuntimeAgentConfig): Promise<AgentRuntimeProvider>;
-  executeTool(call: AgentRuntimeToolCallInput): Promise<AgentRuntimeToolResult>;
-};
-
-export function createRuntimeHostDescriptor(adapter: AgentRuntimeHostAdapter) {
-  return {
-    host: adapter.host,
-    capabilities: [...adapter.capabilities],
-  };
-}

package/agent-runtime/hybridRecordStore.ts

@@ -1,170 +0,0 @@
-export type HybridRecordKvDb = {
-  get(key: string): Promise<any>;
-  put(key: string, value: any): Promise<unknown>;
-  batch(ops: Array<{ type: "put"; key: string; value: any }>): Promise<unknown>;
-  iterator(options: { gte: string; lte?: string; lt?: string; reverse?: boolean; limit?: number }): AsyncIterable<[string, any]>;
-};
-
-export type HybridRecordStore = {
-  read(dbKey: string, options?: { preferredServerOrigin?: string | null; remote?: boolean }): Promise<any>;
-  write(dbKey: string, record: any): Promise<any>;
-  batch(ops: Array<{ type: "put"; key: string; value: any }>): Promise<unknown>;
-  iterator(options: { gte: string; lte?: string; lt?: string; reverse?: boolean; limit?: number }): AsyncIterable<[string, any]>;
-};
-
-type HybridRecordStoreDeps = {
-  db: HybridRecordKvDb;
-  defaultServer: string;
-  fallbackServers?: string[];
-  authToken?: string;
-  fetchImpl?: typeof fetch;
-};
-
-function normalizeHybridServer(value: string) {
-  return value.trim().replace(/\/+$/, "");
-}
-
-function resolveHybridServers(
-  defaultServer: string,
-  preferredServerOrigin?: string | null,
-  fallbackServers: string[] = []
-) {
-  const raw = [
-    preferredServerOrigin || "",
-    defaultServer,
-    ...fallbackServers,
-  ].filter((value) => value.trim().length > 0);
-  return [...new Set(raw.map(normalizeHybridServer))];
-}
-
-function normalizeHybridRecord(dbKey: string, record: any, serverOrigin?: string | null) {
-  if (!record || typeof record !== "object") return null;
-  return {
-    ...record,
-    dbKey: typeof record.dbKey === "string" && record.dbKey ? record.dbKey : dbKey,
-    ...(serverOrigin ? { serverOrigin } : {}),
-  };
-}
-
-function getHybridRecordTimestamp(record: any): number {
-  if (!record || typeof record !== "object") return 0;
-  const candidates = [
-    record.updatedAt,
-    record.updated_at,
-    record.createdAt,
-    record.created,
-    record?.meta?.createdAt,
-  ];
-  for (const candidate of candidates) {
-    if (typeof candidate === "number" && Number.isFinite(candidate) && candidate > 0) return candidate;
-    if (typeof candidate === "string" && candidate.trim()) {
-      const parsed = Date.parse(candidate);
-      if (Number.isFinite(parsed) && parsed > 0) return parsed;
-    }
-  }
-  return 0;
-}
-
-function isHybridTombstoneRecord(record: any): boolean {
-  if (!record || typeof record !== "object") return false;
-  if (typeof record.deletedAt === "string") return record.deletedAt.trim().length > 0;
-  return Boolean(record.deletedAt);
-}
-
-function shouldReplaceWithHybridRecord(nextRecord: any, currentRecord: any): boolean {
-  const nextTs = getHybridRecordTimestamp(nextRecord);
-  const currentTs = getHybridRecordTimestamp(currentRecord);
-  if (nextTs !== currentTs) return nextTs > currentTs;
-  return isHybridTombstoneRecord(nextRecord) && !isHybridTombstoneRecord(currentRecord);
-}
-
-function isHybridNotFoundError(error: unknown) {
-  const message = error instanceof Error ? error.message : String(error);
-  return /not found|notfound|leveldb: not found|key not found/i.test(message);
-}
-
-async function readHybridLocalRecord(db: HybridRecordKvDb, dbKey: string) {
-  try {
-    return await db.get(dbKey);
-  } catch (error) {
-    if (!isHybridNotFoundError(error)) throw error;
-    return null;
-  }
-}
-
-async function fetchHybridRemoteRecord(args: {
-  dbKey: string;
-  server: string;
-  authToken?: string;
-  fetchImpl: typeof fetch;
-}) {
-  const response = await args.fetchImpl(
-    `${args.server}/api/v1/db/read/${encodeURIComponent(args.dbKey)}`,
-    {
-      headers: {
-        "Content-Type": "application/json",
-        ...(args.authToken ? { Authorization: `Bearer ${args.authToken}` } : {}),
-      },
-    }
-  );
-  if (!response.ok) return null;
-  const payload = await response.json().catch(() => null);
-  return normalizeHybridRecord(args.dbKey, payload?.data ?? payload, args.server);
-}
-
-export function shouldCacheHybridRemoteRecord(remoteRecord: any, localRecord: any) {
-  if (!remoteRecord || typeof remoteRecord !== "object") return false;
-  if (!localRecord || typeof localRecord !== "object") return true;
-  return shouldReplaceWithHybridRecord(remoteRecord, localRecord);
-}
-
-export function createHybridRecordStore(
-  deps: HybridRecordStoreDeps
-): HybridRecordStore {
-  const fetchImpl = deps.fetchImpl ?? fetch;
-
-  return {
-    read: async (dbKey, options) => {
-      const localRecord = await readHybridLocalRecord(deps.db, dbKey);
-      const normalizedLocalRecord = normalizeHybridRecord(dbKey, localRecord);
-      if (normalizedLocalRecord && options?.remote !== true) return normalizedLocalRecord;
-      if (options?.remote === false) return null;
-
-      for (const server of resolveHybridServers(
-        deps.defaultServer,
-        options?.preferredServerOrigin,
-        deps.fallbackServers
-      )) {
-        let remoteRecord = null;
-        try {
-          remoteRecord = await fetchHybridRemoteRecord({
-            dbKey,
-            server,
-            authToken: deps.authToken,
-            fetchImpl,
-          });
-        } catch {
-          continue;
-        }
-        if (!remoteRecord) continue;
-        if (shouldCacheHybridRemoteRecord(remoteRecord, localRecord)) {
-          await deps.db.put(dbKey, remoteRecord);
-          return remoteRecord;
-        }
-        return normalizedLocalRecord ?? remoteRecord;
-      }
-
-      return normalizedLocalRecord ?? null;
-    },
-    write: async (dbKey, record) => {
-      const nextRecord = normalizeHybridRecord(dbKey, record) ?? { dbKey };
-      await deps.db.put(dbKey, nextRecord);
-      return nextRecord;
-    },
-    batch: async (ops) => deps.db.batch(ops.map((op) => ({
-      ...op,
-      value: normalizeHybridRecord(op.key, op.value) ?? { dbKey: op.key },
-    }))),
-    iterator: (options) => deps.db.iterator(options),
-  };
-}

package/agent-runtime/index.ts

@@ -1,184 +0,0 @@
-export const AGENT_RUNTIME_PACKAGE_ID = "agent-runtime";
-
-export { createRuntimeHostDescriptor } from "./hostAdapter";
-export { runLocalAgentTurn } from "./localLoop";
-export {
-  pickAgentRuntimeInferenceOptions,
-} from "./agentConfigOptions";
-export {
-  buildOpenAiCompatibleChatCompletionRequest,
-  parseOpenAiCompatibleChatCompletionResponse,
-} from "./openAiCompatibleProvider";
-export { resolveOpenAiCompatibleProviderConfig } from "./openAiCompatibleProviderConfig";
-export {
-  buildProviderAuthHeaders,
-  buildProviderExecutionPlan,
-  resolveAgentProviderMode,
-  resolveAgentRuntimeLocation,
-  resolveProviderTransportDecision,
-} from "./providerResolution";
-export {
-  buildPlatformChatCompletionRequest,
-  canUsePlatformChatProvider,
-  hasDirectOpenAiCompatibleProvider,
-  parsePlatformChatCompletionData,
-  parsePlatformChatCompletionResponse,
-  resolvePlatformChatProviderConfig,
-  shouldUsePlatformChatProvider,
-} from "./platformChatProvider";
-export { resolveAgentRuntimeDecision } from "./runtimeDecision";
-export { buildAgentRuntimeDecisionInput } from "./runtimeFacts";
-export {
-  buildAgentRuntimeAgentLookupKeys,
-  shouldFetchAgentRuntimeRecordRemotely,
-} from "./agentRecordKeys";
-export {
-  DEFAULT_AGENT_THREAD_MAX_CONCURRENT,
-  decideAgentThreadAdmission,
-  normalizeAgentThreadMaxConcurrent,
-  resolveAgentThreadMaxConcurrent,
-} from "./agentThreadAdmission";
-export {
-  AGENT_THREAD_ACTIVE_STATUSES,
-  AGENT_THREAD_INDEX_PREFIX,
-  AGENT_THREAD_KINDS,
-  AGENT_THREAD_PRESENTATION_INTENTS,
-  AGENT_THREAD_RECORD_PREFIX,
-  AGENT_THREAD_STATUSES,
-  AGENT_THREAD_TERMINAL_STATUSES,
-  buildAgentThreadByAgentStatusIndexKey,
-  buildAgentThreadByAgentStatusRange,
-  buildAgentThreadKey,
-  buildAgentThreadUserRange,
-  buildChildAgentThreadRelations,
-  getAgentThreadListSection,
-  getAgentThreadRootId,
-  isAgentThreadActiveStatus,
-  isAgentThreadTerminalStatus,
-  isFutureAgentThread,
-} from "./agentThread";
-export { resolveAgentRuntimeConfigFromRecord } from "./agentRecordConfig";
-export { dialogMessageRecordToAgentRuntimeMessage } from "./dialogMessageRecord";
-export { buildAgentRuntimeDialogWritePlan } from "./dialogWritePlan";
-export {
-  createHybridRecordStore,
-  shouldCacheHybridRemoteRecord,
-} from "./hybridRecordStore";
-export {
-  executeLocalToolWithPolicy,
-  resolveLocalToolPolicy,
-} from "./localToolPolicy";
-export {
-  evaluateShellCommandPolicy,
-  isDestructiveShellCommand,
-} from "./shellCommandPolicy";
-export {
-  mergeAgentRuntimeToolPolicies,
-  normalizeAgentRuntimeToolPolicy,
-  resolveCurrentRunRuntimeToolPolicy,
-  resolveRequestedRuntimeToolNames,
-  resolveEffectiveRuntimeToolPolicy,
-  resolveLocalRuntimeEnvFromPolicy,
-  resolveLocalWorkspaceExecutorOptionsFromPolicy,
-} from "./runtimeToolPolicy";
-export {
-  DEFAULT_PRIVATE_NOLO_WORKSPACE_TOOLS,
-  inferOwnerIdFromRuntimeAgentKey,
-  isPublicRuntimeAgentRef,
-  redactAgentRecordForWorkspaceTool,
-  resolveRuntimeToolSurfaceForAgent,
-  resolveRuntimeToolSurface,
-} from "./runtimeToolSurface";
-export {
-  buildLocalWorkspaceOpenAiTools,
-  buildLocalWorkspacePolicyToolNames,
-  buildLocalWorkspaceToolset,
-  createLocalWorkspaceToolExecutors,
-} from "./localWorkspaceTools";
-export {
-  buildNoloWorkspaceCommandArgs,
-  buildNoloWorkspaceCliToolExecutors,
-  buildNoloWorkspaceOpenAiTools,
-  buildNoloTableQueryRequest,
-  clampNoloPositiveInteger,
-  filterNoloWorkspaceToolNames,
-  getNoloComparableUpdatedAt,
-  getNoloDialogIdFromKey,
-  getNoloSpaceContentKeys,
-  isNoloWorkspaceToolName,
-  noloPositiveIntegerString,
-  noloStringArg,
-  normalizeNoloDocReadArgs,
-  normalizeNoloSpaceInput,
-  NOLO_WORKSPACE_TOOL_NAMES,
-  NOLO_WORKSPACE_TOOL_PROMPT,
-  parseNoloWorkspaceToolArguments,
-  resolveNoloDialogInput,
-  runNoloWorkspaceCliTool,
-} from "./noloWorkspaceTools";
-export type {
-  NoloWorkspaceToolName,
-} from "./noloWorkspaceTools";
-export type {
-  AgentRuntimeAgentConfig,
-  AgentRuntimeHostAdapter,
-  AgentRuntimeProvider,
-  AgentRuntimeSaveTurnInput,
-  AgentRuntimeToolCallInput,
-  AgentRuntimeToolResult,
-} from "./hostAdapter";
-export type {
-  LocalAgentTurnInput,
-  LocalAgentTurnResult,
-} from "./localLoop";
-export type {
-  HybridRecordKvDb,
-  HybridRecordStore,
-} from "./hybridRecordStore";
-export type {
-  LocalToolPolicyDecision,
-} from "./localToolPolicy";
-export type {
-  OpenAiCompatibleProviderConfig,
-} from "./openAiCompatibleProvider";
-export type {
-  PlatformChatProviderConfig,
-} from "./platformChatProvider";
-export type {
-  RuntimeToolSurfaceHost,
-  RuntimeToolSurfaceForAgentInput,
-  RuntimeToolSurfaceInput,
-  RuntimeToolSurfaceResult,
-  RuntimeToolSurfaceVisibility,
-} from "./runtimeToolSurface";
-export type {
-  AgentThreadAdmissionAgentConfig,
-  AgentThreadAdmissionConfig,
-  AgentThreadAdmissionDecision,
-} from "./agentThreadAdmission";
-export type {
-  AgentThread,
-  AgentThreadActiveStatus,
-  AgentThreadEvidence,
-  AgentThreadKind,
-  AgentThreadListSection,
-  AgentThreadPresentationIntent,
-  AgentThreadRuntimeCheckpoint,
-  AgentThreadSchedule,
-  AgentThreadStatus,
-  AgentThreadSubjectRef,
-  AgentThreadTerminalStatus,
-} from "./agentThread";
-export type {
-  AgentRuntimeChatMessage,
-  AgentRuntimeDecision,
-  AgentRuntimeDecisionInput,
-  AgentRuntimeHost,
-  AgentRuntimeMessageContent,
-  AgentRuntimeMode,
-  AgentRuntimeRequestedMode,
-  AgentRuntimeResult,
-  AgentRuntimeToolPolicy,
-  AgentRuntimeToolCall,
-  AgentRuntimeWorkspaceMode,
-} from "./types";

package/agent-runtime/localDialogRead.ts

@@ -1,23 +0,0 @@
-export type LocalDialogReadResult = {
-  meta: any;
-  msgs: any[];
-};
-
-export async function readDialogFromLocalDb(args: {
-  dialogKey: string;
-  dialogId: string;
-  limit: number;
-}): Promise<LocalDialogReadResult> {
-  const [{ default: serverDb, ensureServerDbOpen }, { fetchMessages }] = await Promise.all([
-    import("../database/server/db"),
-    import("../chat/messages/fetchMessages"),
-  ]);
-  await ensureServerDbOpen();
-  return {
-    meta: await serverDb.get(args.dialogKey),
-    msgs: await fetchMessages(serverDb, args.dialogId, {
-      limit: args.limit,
-      throwOnError: true,
-    }),
-  };
-}