feat: implement auto-dependency resolution for resource pushing

- Added functionality to automatically resolve and apply missing dependencies when pushing squads and assistants, enhancing the deployment process.
- Introduced new methods to ensure the existence of tools, structured outputs, and assistants, streamlining the resource management workflow.
- Updated the README to document the new auto-dependency resolution feature and its usage, providing clear guidance for users on selective pushes.

Author: vtkovapi

README.md

@@ -161,6 +161,38 @@ npm run push:dev assistants resources/assistants/booking.md
 
 **Note:** Partial pushes skip deletion checks. Run full `npm run push:dev` to sync deletions.
 
+#### Auto-Dependency Resolution
+
+Partial push is ideal for promoting specific squads or assistants to staging/prod without pushing everything. The engine automatically detects and creates missing dependencies:
+
+```bash
+# Push a single squad to staging — tools, structured outputs, and
+# assistants are created automatically if they don't exist yet
+npm run push:stg resources/squads/everblue-voice-squad-20374c37.yml
+
+# Push assistants to prod — missing tools and structured outputs
+# are auto-applied first so references resolve correctly
+npm run push:prod assistants
+```
+
+The dependency chain resolves recursively:
+
+```
+Squad push
+  └─ missing assistants? → auto-create them first
+       └─ missing tools / structured outputs? → auto-create those first
+            └─ then create the assistant
+  └─ all references resolved → create the squad ✓
+
+Assistant push
+  └─ missing tools / structured outputs? → auto-create them first
+  └─ all references resolved → create the assistant ✓
+```
+
+If a dependency already exists on the platform (UUID in the state file) but its nested dependencies don't, those are still auto-created and the parent resource is updated to reference them.
+
+This means you can work on everything in dev, then selectively push a single squad or assistant to staging or prod — no need for a full `push` that touches every resource.
+
 ---
 
 ## Project Structure

src/push.ts

@@ -2,7 +2,7 @@ import { vapiRequest, VapiApiError } from "./api.ts";
 import { VAPI_ENV, VAPI_BASE_URL, FORCE_DELETE, APPLY_FILTER, removeExcludedKeys } from "./config.ts";
 import { loadState, saveState } from "./state.ts";
 import { loadResources, loadSingleResource, FOLDER_MAP } from "./resources.ts";
-import { resolveReferences, resolveAssistantIds } from "./resolver.ts";
+import { resolveReferences, resolveAssistantIds, extractReferencedIds } from "./resolver.ts";
 import { credentialForwardMap, deepReplaceValues } from "./credentials.ts";
 import { deleteOrphanedResources } from "./delete.ts";
 import type { ResourceFile, StateFile, ResourceType, LoadedResources } from "./types.ts";
@@ -382,6 +382,121 @@ function filterResourcesByPaths<T>(
   return resources.filter(r => matchingIds.has(r.resourceId));
 }
 
+// ─────────────────────────────────────────────────────────────────────────────
+// Auto-Dependency Resolution
+// When pushing a resource with missing dependencies, auto-apply them first
+// Chain: squads → assistants → tools + structuredOutputs
+// ─────────────────────────────────────────────────────────────────────────────
+
+interface DependencyContext {
+  allTools: ResourceFile<Record<string, unknown>>[];
+  allStructuredOutputs: ResourceFile<Record<string, unknown>>[];
+  allAssistants: ResourceFile<Record<string, unknown>>[];
+  state: StateFile;
+  applied: Record<ResourceType, number>;
+  autoApplied: Set<string>;
+  autoAppliedTools: ResourceFile<Record<string, unknown>>[];
+  autoAppliedStructuredOutputs: ResourceFile<Record<string, unknown>>[];
+}
+
+async function ensureToolExists(toolId: string, ctx: DependencyContext): Promise<void> {
+  if (UUID_REGEX.test(toolId) || ctx.state.tools[toolId] || ctx.autoApplied.has(`tools:${toolId}`)) return;
+
+  const tool = ctx.allTools.find(t => t.resourceId === toolId);
+  if (!tool) return;
+
+  console.log(`  📦 Auto-applying dependency → tool: ${toolId}`);
+  try {
+    const uuid = await applyTool(tool, ctx.state);
+    ctx.state.tools[tool.resourceId] = uuid;
+    ctx.applied.tools++;
+    ctx.autoApplied.add(`tools:${toolId}`);
+    ctx.autoAppliedTools.push(tool);
+  } catch (error) {
+    console.error(formatApiError(toolId, error));
+    throw error;
+  }
+}
+
+async function ensureStructuredOutputExists(outputId: string, ctx: DependencyContext): Promise<void> {
+  if (UUID_REGEX.test(outputId) || ctx.state.structuredOutputs[outputId] || ctx.autoApplied.has(`structuredOutputs:${outputId}`)) return;
+
+  const output = ctx.allStructuredOutputs.find(o => o.resourceId === outputId);
+  if (!output) return;
+
+  console.log(`  📦 Auto-applying dependency → structured output: ${outputId}`);
+  try {
+    const uuid = await applyStructuredOutput(output, ctx.state);
+    ctx.state.structuredOutputs[output.resourceId] = uuid;
+    ctx.applied.structuredOutputs++;
+    ctx.autoApplied.add(`structuredOutputs:${outputId}`);
+    ctx.autoAppliedStructuredOutputs.push(output);
+  } catch (error) {
+    console.error(formatApiError(outputId, error));
+    throw error;
+  }
+}
+
+async function ensureAssistantDepsExist(assistantId: string, ctx: DependencyContext): Promise<boolean> {
+  if (UUID_REGEX.test(assistantId)) return false;
+
+  const assistant = ctx.allAssistants.find(a => a.resourceId === assistantId);
+  if (!assistant) return false;
+
+  const refs = extractReferencedIds(assistant.data as Record<string, unknown>);
+  let depsCreated = false;
+
+  for (const toolId of refs.tools) {
+    if (!UUID_REGEX.test(toolId) && !ctx.state.tools[toolId]) {
+      await ensureToolExists(toolId, ctx);
+      if (ctx.state.tools[toolId]) depsCreated = true;
+    }
+  }
+  for (const outputId of refs.structuredOutputs) {
+    if (!UUID_REGEX.test(outputId) && !ctx.state.structuredOutputs[outputId]) {
+      await ensureStructuredOutputExists(outputId, ctx);
+      if (ctx.state.structuredOutputs[outputId]) depsCreated = true;
+    }
+  }
+
+  return depsCreated;
+}
+
+async function ensureAssistantExists(assistantId: string, ctx: DependencyContext): Promise<void> {
+  if (UUID_REGEX.test(assistantId)) return;
+
+  // Always resolve tool/SO deps, even if the assistant already exists in state
+  const depsCreated = await ensureAssistantDepsExist(assistantId, ctx);
+
+  // Assistant already on platform — update it if we just created missing deps
+  if (ctx.state.assistants[assistantId]) {
+    if (depsCreated) {
+      const assistant = ctx.allAssistants.find(a => a.resourceId === assistantId);
+      if (assistant) {
+        console.log(`  🔄 Updating assistant with new dependencies: ${assistantId}`);
+        await applyAssistant(assistant, ctx.state);
+      }
+    }
+    return;
+  }
+
+  if (ctx.autoApplied.has(`assistants:${assistantId}`)) return;
+
+  const assistant = ctx.allAssistants.find(a => a.resourceId === assistantId);
+  if (!assistant) return;
+
+  console.log(`  📦 Auto-applying dependency → assistant: ${assistantId}`);
+  try {
+    const uuid = await applyAssistant(assistant, ctx.state);
+    ctx.state.assistants[assistant.resourceId] = uuid;
+    ctx.applied.assistants++;
+    ctx.autoApplied.add(`assistants:${assistantId}`);
+  } catch (error) {
+    console.error(formatApiError(assistantId, error));
+    throw error;
+  }
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Main Apply Engine
 // ─────────────────────────────────────────────────────────────────────────────
@@ -488,6 +603,16 @@ async function main(): Promise<void> {
     ? filterResourcesByPaths(allSimulationSuites, "simulationSuites") 
     : [];
 
+  // Auto-dependency resolution context
+  const autoApplied = new Set<string>();
+  const autoAppliedTools: ResourceFile<Record<string, unknown>>[] = [];
+  const autoAppliedStructuredOutputs: ResourceFile<Record<string, unknown>>[] = [];
+  const depCtx: DependencyContext = {
+    allTools, allStructuredOutputs, allAssistants,
+    state, applied, autoApplied,
+    autoAppliedTools, autoAppliedStructuredOutputs,
+  };
+
   // Determine which types to check for orphaned deletions
   // Full apply: check all types. Partial apply: only check the filtered type(s).
   let typesToDelete: ResourceType[] | undefined;
@@ -562,7 +687,18 @@ async function main(): Promise<void> {
 
   if (assistants.length > 0) {
     console.log("\n🤖 Applying assistants...\n");
+    // Auto-resolve missing tool & structured output dependencies
+    for (const assistant of assistants) {
+      const refs = extractReferencedIds(assistant.data as Record<string, unknown>);
+      for (const toolId of refs.tools) {
+        await ensureToolExists(toolId, depCtx);
+      }
+      for (const outputId of refs.structuredOutputs) {
+        await ensureStructuredOutputExists(outputId, depCtx);
+      }
+    }
     for (const assistant of assistants) {
+      if (autoApplied.has(`assistants:${assistant.resourceId}`)) continue;
       try {
         const uuid = await applyAssistant(assistant, state);
         state.assistants[assistant.resourceId] = uuid;
@@ -576,6 +712,13 @@ async function main(): Promise<void> {
 
   if (squads.length > 0) {
     console.log("\n👥 Applying squads...\n");
+    // Auto-resolve missing assistant dependencies (recursively resolves tools/SOs)
+    for (const squad of squads) {
+      const refs = extractReferencedIds(squad.data as Record<string, unknown>);
+      for (const assistantId of refs.assistants) {
+        await ensureAssistantExists(assistantId, depCtx);
+      }
+    }
     for (const squad of squads) {
       try {
         const uuid = await applySquad(squad, state);
@@ -644,15 +787,17 @@ async function main(): Promise<void> {
     }
   }
 
-  // Second pass: Link resources to assistants (only for tools/structuredOutputs being applied)
-  if (tools.length > 0) {
+  // Second pass: Link resources to assistants (include auto-applied deps)
+  const allAppliedTools = [...tools, ...autoAppliedTools];
+  if (allAppliedTools.length > 0) {
     console.log("\n🔗 Linking tools to assistant destinations...\n");
-    await updateToolAssistantRefs(tools, state);
+    await updateToolAssistantRefs(allAppliedTools, state);
   }
 
-  if (structuredOutputs.length > 0) {
+  const allAppliedOutputs = [...structuredOutputs, ...autoAppliedStructuredOutputs];
+  if (allAppliedOutputs.length > 0) {
     console.log("\n🔗 Linking structured outputs to assistants...\n");
-    await updateStructuredOutputAssistantRefs(structuredOutputs, state);
+    await updateStructuredOutputAssistantRefs(allAppliedOutputs, state);
   }
 
   // Save updated state