newo 3.7.3 → 3.7.5

package/dist/sandbox/chat.js

@@ -7,7 +7,7 @@ import { listIntegrations, listConnectors, createSandboxPersona, createActor, se
 const SANDBOX_INTEGRATION_IDN = 'sandbox';
 const DEFAULT_TIMEZONE = 'America/Los_Angeles';
 const POLL_INTERVAL_MS = 1000; // 1 second
-const MAX_POLL_ATTEMPTS = 60; // Max 60 seconds wait
+const DEFAULT_TIMEOUT_MS = 60_000; // Default max wait for agent response
 /**
  * Generate a random external ID for chat session
  */
@@ -22,39 +22,67 @@ function generatePersonaName() {
     return `newo-cli-${guid}`;
 }
 /**
- * Find a sandbox connector from the customer's connectors list
+ * List running connectors of an integration (default: sandbox).
+ * Used by `newo sandbox --list-connectors` and connector selection.
  */
-export async function findSandboxConnector(client, verbose = false) {
-    if (verbose)
-        console.log('🔍 Searching for sandbox integration...');
-    // First, get all integrations to find the sandbox integration
+export async function listRunningSandboxConnectors(client, integrationIdn = SANDBOX_INTEGRATION_IDN) {
     const integrations = await listIntegrations(client);
-    const sandboxIntegration = integrations.find(i => i.idn === SANDBOX_INTEGRATION_IDN);
-    if (!sandboxIntegration) {
+    const integration = integrations.find(i => i.idn === integrationIdn);
+    if (!integration) {
+        throw new Error(`Integration '${integrationIdn}' not found. Available integrations: ${integrations.map(i => i.idn).join(', ') || '(none)'}`);
+    }
+    const connectors = await listConnectors(client, integration.id);
+    return connectors.filter(c => c.status === 'running');
+}
+/**
+ * Find a sandbox connector from the customer's connectors list.
+ *
+ * Without options, preserves legacy behavior: first running connector of the
+ * 'sandbox' integration. With options.connectorIdn, selects that exact
+ * connector and throws a descriptive error (listing available connectors)
+ * when it is not found or not running.
+ */
+export async function findSandboxConnector(client, verbose = false, options = {}) {
+    const integrationIdn = options.integrationIdn || SANDBOX_INTEGRATION_IDN;
+    if (verbose)
+        console.log(`🔍 Searching for ${integrationIdn} integration...`);
+    let runningConnectors;
+    try {
+        runningConnectors = await listRunningSandboxConnectors(client, integrationIdn);
+    }
+    catch (error) {
+        if (options.connectorIdn)
+            throw error;
         if (verbose)
-            console.log('❌ Sandbox integration not found');
+            console.log(`❌ ${error instanceof Error ? error.message : String(error)}`);
         return null;
     }
-    if (verbose)
-        console.log(`✓ Found sandbox integration: ${sandboxIntegration.id}`);
-    // Now get connectors for the sandbox integration
-    if (verbose)
-        console.log('🔍 Searching for sandbox connectors...');
-    const connectors = await listConnectors(client, sandboxIntegration.id);
-    const sandboxConnectors = connectors.filter(c => c.status === 'running');
-    if (sandboxConnectors.length === 0) {
+    if (runningConnectors.length === 0) {
+        if (options.connectorIdn) {
+            throw new Error(`No running connectors found in integration '${integrationIdn}'`);
+        }
         if (verbose)
-            console.log('❌ No running sandbox connectors found');
+            console.log(`❌ No running ${integrationIdn} connectors found`);
         return null;
     }
+    if (options.connectorIdn) {
+        const match = runningConnectors.find(c => c.connector_idn === options.connectorIdn);
+        if (!match) {
+            const available = runningConnectors.map(c => c.connector_idn).join(', ');
+            throw new Error(`Connector '${options.connectorIdn}' not found among running connectors of integration '${integrationIdn}'. Available: ${available}`);
+        }
+        if (verbose)
+            console.log(`✓ Using connector: ${match.connector_idn}`);
+        return match;
+    }
     if (verbose) {
-        console.log(`✓ Found ${sandboxConnectors.length} running sandbox connector(s)`);
-        const firstConnector = sandboxConnectors[0];
+        console.log(`✓ Found ${runningConnectors.length} running ${integrationIdn} connector(s)`);
+        const firstConnector = runningConnectors[0];
         if (firstConnector) {
             console.log(`  Using: ${firstConnector.connector_idn}`);
         }
     }
-    return sandboxConnectors[0] || null;
+    return runningConnectors[0] || null;
 }
 /**
  * Create a new sandbox chat session
@@ -77,7 +105,7 @@ export async function createChatSession(client, connector, verbose = false) {
     const actorResponse = await createActor(client, personaResponse.id, {
         name: personaName,
         external_id: externalId,
-        integration_idn: SANDBOX_INTEGRATION_IDN,
+        integration_idn: connector.integration_idn || SANDBOX_INTEGRATION_IDN,
         connector_idn: connector.connector_idn,
         time_zone_identifier: DEFAULT_TIMEZONE
     });
@@ -97,8 +125,10 @@ export async function createChatSession(client, connector, verbose = false) {
  * Returns the timestamp when message was sent (for filtering responses)
  */
 export async function sendMessage(client, session, text, verbose = false) {
-    if (verbose)
-        console.log(`💬 Sending message: "${text}"`);
+    if (verbose) {
+        const preview = text.length > 200 ? `${text.slice(0, 200)}… (${text.length} chars)` : text;
+        console.log(`💬 Sending message: "${preview}"`);
+    }
     const sentAt = new Date();
     await sendChatMessage(client, session.user_actor_id, {
         text,
@@ -108,21 +138,33 @@ export async function sendMessage(client, session, text, verbose = false) {
         console.log('✓ Message sent');
     return sentAt;
 }
+/**
+ * Parse an act datetime that may lack timezone info (assume UTC)
+ */
+function parseActDatetimeMs(datetime) {
+    let d = datetime;
+    if (!d.endsWith('Z') && !d.includes('+') && !d.includes('-', 10)) {
+        d = d + 'Z';
+    }
+    return new Date(d).getTime();
+}
 /**
  * Poll for new conversation acts (messages and debug info)
  * Continues polling until we get an agent response, not just any new message
  */
-export async function pollForResponse(client, session, messageSentAt = null, verbose = false) {
+export async function pollForResponse(client, session, messageSentAt = null, verbose = false, timeoutMs = DEFAULT_TIMEOUT_MS) {
     let attempts = 0;
     let agentPersonaId = session.agent_persona_id;
+    let userAct = null;
+    const maxPollAttempts = Math.max(1, Math.ceil(timeoutMs / POLL_INTERVAL_MS));
     if (verbose)
-        console.log('⏳ Waiting for agent response...');
+        console.log(`⏳ Waiting for agent response (timeout: ${Math.round(timeoutMs / 1000)}s)...`);
     // Add small delay before first poll to allow message to be processed
     await new Promise(resolve => setTimeout(resolve, 500));
-    while (attempts < MAX_POLL_ATTEMPTS) {
+    while (attempts < maxPollAttempts) {
         try {
             if (verbose && attempts % 5 === 0) {
-                console.log(`  [Poll attempt ${attempts + 1}/${MAX_POLL_ATTEMPTS}] Checking for messages...`);
+                console.log(`  [Poll attempt ${attempts + 1}/${maxPollAttempts}] Checking for messages...`);
             }
             // Use Chat History API instead of acts API (doesn't require account_id)
             const response = await getChatHistory(client, {
@@ -172,6 +214,17 @@ export async function pollForResponse(client, session, messageSentAt = null, ver
                             console.log(`✓ Extracted agent_persona_id: ${agentPersonaId}`);
                     }
                 }
+                // Track the user act of our sent message (newest non-agent act at/after sentAt).
+                // Its external_event_id is the correlation key for `newo logs --event-id`.
+                for (const act of convertedActs) {
+                    if (act.is_agent)
+                        continue;
+                    if (messageSentAt && parseActDatetimeMs(act.datetime) - messageSentAt.getTime() <= -100)
+                        continue;
+                    if (!userAct || parseActDatetimeMs(act.datetime) >= parseActDatetimeMs(userAct.datetime)) {
+                        userAct = act;
+                    }
+                }
                 // Filter for agent messages that came AFTER our message was sent
                 const agentMessages = convertedActs.filter(act => {
                     if (!act.is_agent)
@@ -208,7 +261,7 @@ export async function pollForResponse(client, session, messageSentAt = null, ver
                     // Return ONLY the single newest agent message (first one, since API returns newest first)
                     const latestAgentMessage = agentMessages[0];
                     if (latestAgentMessage) {
-                        return { acts: [latestAgentMessage], agentPersonaId };
+                        return { acts: [latestAgentMessage], agentPersonaId, userAct };
                     }
                 }
                 else if (verbose && attempts % 10 === 0) {
@@ -227,7 +280,7 @@ export async function pollForResponse(client, session, messageSentAt = null, ver
     }
     if (verbose)
         console.log('⏱️  Timeout waiting for response');
-    return { acts: [], agentPersonaId };
+    return { acts: [], agentPersonaId, userAct };
 }
 /**
  * Extract agent messages from acts

package/dist/sync/remote-skill.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Remote skill resolution by IDN path (project/agent/flow/skill).
+ *
+ * Used by `newo get-skill` and `newo update-skill` to address a single skill
+ * on the platform without requiring a pulled local workspace.
+ */
+import type { AxiosInstance } from 'axios';
+import type { ProjectMeta, Agent, Flow, Skill } from '../types.js';
+export interface RemoteSkillPath {
+    projectIdn: string;
+    agentIdn: string;
+    flowIdn: string;
+    skillIdn: string;
+}
+export interface ResolvedRemoteSkill {
+    project: ProjectMeta;
+    agent: Agent;
+    flow: Flow;
+    skill: Skill;
+}
+/**
+ * Resolve a skill on the platform by its IDN path.
+ * Throws descriptive errors listing available IDNs at the failing level.
+ */
+export declare function resolveRemoteSkill(client: AxiosInstance, path: RemoteSkillPath): Promise<ResolvedRemoteSkill>;
+/**
+ * Parse a `--model provider_idn/model_idn` flag value
+ */
+export declare function parseModelFlag(value: string): {
+    provider_idn: string;
+    model_idn: string;
+};
+//# sourceMappingURL=remote-skill.d.ts.map

package/dist/sync/remote-skill.js

@@ -0,0 +1,52 @@
+import { listProjects, listAgents, listFlowSkills, getSkill } from '../api.js';
+/**
+ * Resolve a skill on the platform by its IDN path.
+ * Throws descriptive errors listing available IDNs at the failing level.
+ */
+export async function resolveRemoteSkill(client, path) {
+    const projects = await listProjects(client);
+    const project = projects.find(p => p.idn === path.projectIdn);
+    if (!project) {
+        throw new Error(`Project '${path.projectIdn}' not found. Available projects: ${projects.map(p => p.idn).join(', ') || '(none)'}`);
+    }
+    const agents = await listAgents(client, project.id);
+    const agent = agents.find(a => a.idn === path.agentIdn);
+    if (!agent) {
+        throw new Error(`Agent '${path.agentIdn}' not found in project '${path.projectIdn}'. Available agents: ${agents.map(a => a.idn).join(', ') || '(none)'}`);
+    }
+    const flows = agent.flows || [];
+    const flow = flows.find(f => f.idn === path.flowIdn);
+    if (!flow) {
+        throw new Error(`Flow '${path.flowIdn}' not found in agent '${path.agentIdn}'. Available flows: ${flows.map(f => f.idn).join(', ') || '(none)'}`);
+    }
+    const skills = await listFlowSkills(client, flow.id);
+    const skillStub = skills.find(s => s.idn === path.skillIdn);
+    if (!skillStub) {
+        throw new Error(`Skill '${path.skillIdn}' not found in flow '${path.flowIdn}'. Available skills: ${skills.map(s => s.idn).join(', ') || '(none)'}`);
+    }
+    // The flow-skills list endpoint already returns full skills including
+    // prompt_script (pull relies on this). Only fall back to the by-id
+    // endpoint when prompt_script is absent — and tolerate a 404 there,
+    // since /api/v1/designer/skills/{id} is not available on all accounts.
+    let skill = skillStub;
+    if (skill.prompt_script === undefined || skill.prompt_script === null) {
+        try {
+            skill = await getSkill(client, skillStub.id);
+        }
+        catch {
+            skill = skillStub;
+        }
+    }
+    return { project, agent, flow, skill };
+}
+/**
+ * Parse a `--model provider_idn/model_idn` flag value
+ */
+export function parseModelFlag(value) {
+    const parts = value.split('/');
+    if (parts.length !== 2 || !parts[0] || !parts[1]) {
+        throw new Error(`Invalid --model value '${value}'. Expected format: <provider_idn>/<model_idn> (e.g. openai/gpt4o)`);
+    }
+    return { provider_idn: parts[0], model_idn: parts[1] };
+}
+//# sourceMappingURL=remote-skill.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newo",
-  "version": "3.7.3",
+  "version": "3.7.5",
   "description": "NEWO CLI: Professional command-line tool with modular architecture for NEWO AI Agent development. Features account migration, integration management, webhook automation, AKB knowledge base, project attributes, sandbox testing, IDN-based file management, real-time progress tracking, intelligent sync operations, and comprehensive multi-customer support.",
   "type": "module",
   "bin": {

package/src/cli/commands/get-skill.ts

@@ -0,0 +1,84 @@
+/**
+ * Get Skill Command Handler - Inspect a skill's live state on the platform
+ *
+ * Usage:
+ *   newo get-skill <skill-idn> --project <idn> --agent <idn> --flow <idn> [--json]
+ *
+ * Shows the skill as it currently lives on the platform (model, runner_type,
+ * parameters, prompt_script) without requiring a pulled local workspace.
+ */
+import { requireSingleCustomer } from '../customer-selection.js';
+import { makeClient } from '../../api.js';
+import { getValidAccessToken } from '../../auth.js';
+import { resolveRemoteSkill } from '../../sync/remote-skill.js';
+import type { MultiCustomerConfig, CliArgs } from '../../types.js';
+
+const USAGE = 'Usage: newo get-skill <skill-idn> --project <project-idn> --agent <agent-idn> --flow <flow-idn> [--json] [--customer <idn>]';
+
+export async function handleGetSkillCommand(
+  customerConfig: MultiCustomerConfig,
+  args: CliArgs,
+  verbose: boolean = false
+): Promise<void> {
+  const skillIdn = args._[1] as string | undefined;
+  const projectIdn = args.project as string | undefined;
+  const agentIdn = args.agent as string | undefined;
+  const flowIdn = args.flow as string | undefined;
+  const asJson = Boolean(args.json);
+
+  if (!skillIdn || !projectIdn || !agentIdn || !flowIdn) {
+    console.error('Error: skill IDN, --project, --agent and --flow are required');
+    console.error(USAGE);
+    process.exit(1);
+  }
+
+  const selectedCustomer = requireSingleCustomer(customerConfig, args.customer as string | undefined);
+
+  if (asJson) {
+    process.env.NEWO_QUIET_MODE = 'true'; // keep stdout machine-readable for piping
+  }
+
+  const token = await getValidAccessToken(selectedCustomer);
+  const client = await makeClient(verbose, token);
+
+  if (verbose) console.log(`🔍 Resolving skill ${projectIdn}/${agentIdn}/${flowIdn}/${skillIdn}...`);
+
+  const { project, agent, flow, skill } = await resolveRemoteSkill(client, {
+    projectIdn,
+    agentIdn,
+    flowIdn,
+    skillIdn
+  });
+
+  if (asJson) {
+    console.log(JSON.stringify({
+      project_idn: project.idn,
+      agent_idn: agent.idn,
+      flow_idn: flow.idn,
+      id: skill.id,
+      idn: skill.idn,
+      title: skill.title,
+      runner_type: skill.runner_type,
+      model: skill.model,
+      parameters: skill.parameters,
+      prompt_script: skill.prompt_script ?? null
+    }, null, 2));
+    return;
+  }
+
+  console.log(`📜 Skill: ${project.idn}/${agent.idn}/${flow.idn}/${skill.idn}`);
+  console.log(`   ID: ${skill.id}`);
+  console.log(`   Title: ${skill.title}`);
+  console.log(`   Runner type: ${skill.runner_type}`);
+  console.log(`   Model: ${skill.model.provider_idn}/${skill.model.model_idn}`);
+  if (skill.parameters.length > 0) {
+    console.log(`   Parameters:`);
+    for (const param of skill.parameters) {
+      console.log(`     ${param.name}${param.default_value !== undefined ? ` = ${JSON.stringify(param.default_value)}` : ''}`);
+    }
+  } else {
+    console.log(`   Parameters: (none)`);
+  }
+  console.log(`\n--- prompt_script (${(skill.prompt_script || '').length} chars) ---`);
+  console.log(skill.prompt_script || '(empty)');
+}

package/src/cli/commands/help.ts

@@ -17,6 +17,11 @@ Core Commands:
   newo conversations [--customer <idn>] [--all] # download user conversations -> conversations.yaml
   newo sandbox "<message>" [--customer <idn>]   # test agent in sandbox - single message mode
   newo sandbox --actor <id> "message"           # continue existing sandbox conversation
+  newo sandbox --list-connectors                # list running sandbox connectors (NEW v3.7.5)
+  newo sandbox "<msg>" --connector <idn>        # chat through a specific connector (NEW v3.7.5)
+  newo sandbox --file <path> | --stdin          # send long messages from file/stdin (NEW v3.7.5)
+  newo get-skill <idn> --project <p> --agent <a> --flow <f> [--json]   # inspect live skill on platform (NEW v3.7.5)
+  newo update-skill <idn> --project <p> --agent <a> --flow <f> [--model <prov>/<model>] [--script <file>] [--publish]  # point-edit skill (NEW v3.7.5)
   newo pull-attributes [--customer <idn>]       # download customer + project attributes
   newo list-customers                           # list available customers
   newo meta [--customer <idn>]                  # get project metadata (debug)
@@ -77,6 +82,8 @@ Analytics & Monitoring (NEW):
   newo logs --type <types>                                   # filter by type: system, operation, call (comma-separated)
   newo logs --flow <idn> --skill <idn>                       # filter by flow and/or skill
   newo logs --message <text>                                 # search in log messages
+  newo logs --name <ActionName>                              # filter by action name in data.name, e.g. Gen, GetMemory (NEW v3.7.5)
+  newo logs --event-id <uuid>                                # filter by external event ID (correlate with sandbox --json)
   newo logs --follow, -f                                     # tail mode - continuously poll for new logs
   newo logs --json                                           # output logs as JSON array
   newo logs --raw                                            # output each log as single JSON line (for piping)
@@ -95,6 +102,12 @@ Flags:
   --verbose, -v                # enable detailed logging and progress information
   --quiet, -q                  # minimal output for automation (sandbox only)
   --actor <id>                 # continue existing sandbox chat with actor/chat ID
+  --connector <idn>            # sandbox: select connector by connector_idn (default: first running)
+  --integration <idn>          # sandbox: integration to search connectors in (default: sandbox)
+  --file <path>                # sandbox: read message text from file
+  --stdin                      # sandbox: read message text from stdin
+  --timeout <seconds>          # sandbox: max wait for agent response (default: 60)
+  --json                       # sandbox: machine-readable output incl. external_event_id (user+agent turns)
   --confirm                    # confirm destructive operations without prompting
   --no-publish                 # skip automatic flow publishing during push operations
   --output, -o <file>          # output file path (for export command)
@@ -202,6 +215,22 @@ Usage Examples:
   newo sandbox "Test query" --verbose                            # With debug info
   newo sandbox "Test query" --quiet                              # For automation/scripts
 
+  # Sandbox connector selection + automation (NEW v3.7.5):
+  newo sandbox --list-connectors                                 # Show running sandbox connectors
+  newo sandbox "ping" --connector vibe_agent                     # Chat through specific connector
+  newo sandbox --file ./chunk1.txt --actor abc123... --json      # Long message from file, JSON output
+  cat msg.txt | newo sandbox --stdin --timeout 420 --json        # From stdin with 7-minute timeout
+  # --json output: {actor_id, persona_id, external_event_id, user_external_event_id,
+  #                 agent_external_event_id, response, elapsed_ms, timed_out, ...}
+  # Correlate a turn with its logs: newo logs --event-id <external_event_id> --json
+
+  # Live skill inspection / point edits (NEW v3.7.5):
+  newo get-skill structured_generation --project vibe --agent VibeAgent --flow VibeFlow            # View live state
+  newo get-skill structured_generation --project vibe --agent VibeAgent --flow VibeFlow --json     # As JSON
+  newo update-skill structured_generation --project vibe --agent VibeAgent --flow VibeFlow \\
+      --model openai/gpt54 --publish                             # Switch model and publish
+  newo update-skill my_skill --project p --agent a --flow f --script ./patched.nsl --publish       # Replace script
+
   # Analytics logs (NEW v3.5.0):
   newo logs                                                      # Last 1 hour of logs
   newo logs --hours 24                                           # Last 24 hours

package/src/cli/commands/logs.ts

@@ -14,7 +14,7 @@
  */
 
 import type { AxiosInstance } from 'axios';
-import type { MultiCustomerConfig, LogEntry, LogLevel, LogType, LogsQueryParams, CliArgs } from '../../types.js';
+import type { MultiCustomerConfig, LogEntry, LogLevel, LogType, LogsQueryParams, LogsResponse, CliArgs } from '../../types.js';
 import { makeClient, getLogs } from '../../api.js';
 import { getValidAccessToken } from '../../auth.js';
 import { requireSingleCustomer } from '../customer-selection.js';
@@ -33,6 +33,8 @@ const colors = {
   gray: '\x1b[90m'
 };
 
+type GetLogsFn = (client: AxiosInstance, params: LogsQueryParams) => Promise<LogsResponse>;
+
 function getLevelColor(level: LogLevel): string {
   switch (level) {
     case 'error': return colors.red;
@@ -106,7 +108,13 @@ export async function handleLogsCommand(
   // Select customer
   const selectedCustomer = requireSingleCustomer(customerConfig, args.customer as string | undefined);
 
-  console.log(`📊 Fetching logs for ${selectedCustomer.idn}...`);
+  // Keep stdout machine-readable when JSON output is requested (for piping to jq etc.)
+  const machineOutput = Boolean(args.json || args.raw);
+  if (machineOutput) {
+    process.env.NEWO_QUIET_MODE = 'true'; // suppress auth logging on stdout
+  } else {
+    console.log(`📊 Fetching logs for ${selectedCustomer.idn}...`);
+  }
 
   // Get access token and create client
   const token = await getValidAccessToken(selectedCustomer);
@@ -164,29 +172,84 @@ export async function handleLogsCommand(
   const follow = Boolean(args.follow || args.f);
   const asJson = Boolean(args.json);
   const raw = Boolean(args.raw);
+  // --name filters by data.name (e.g. action name like Gen or GetMemory).
+  // The API has no such query param, so it is applied client-side.
+  const nameFilter = args.name ? String(args.name) : null;
 
   if (follow) {
-    await tailLogs(client, params, asJson);
+    await tailLogs(client, params, asJson, nameFilter);
   } else {
-    await fetchAndDisplayLogs(client, params, asJson, raw);
+    await fetchAndDisplayLogs(client, params, asJson, raw, nameFilter);
   }
 }
 
-async function fetchAndDisplayLogs(
+function filterByName(logs: readonly LogEntry[], nameFilter: string | null): LogEntry[] {
+  if (!nameFilter) return [...logs];
+  return logs.filter(log => log.data['name'] === nameFilter);
+}
+
+export async function collectLogsForDisplay(
+  client: AxiosInstance,
+  params: LogsQueryParams,
+  nameFilter: string | null = null,
+  getLogsFn: GetLogsFn = getLogs
+): Promise<LogEntry[]> {
+  if (!nameFilter) {
+    const response = await getLogsFn(client, params);
+    return [...response.items];
+  }
+
+  const pageSize = Number.isFinite(params.per) && params.per && params.per > 0 ? params.per : 50;
+  let page = Number.isFinite(params.page) && params.page && params.page > 0 ? params.page : 1;
+  const logs: LogEntry[] = [];
+
+  while (true) {
+    const response = await getLogsFn(client, {
+      ...params,
+      page,
+      per: pageSize
+    });
+
+    logs.push(...filterByName(response.items, nameFilter));
+
+    if (response.items.length < pageSize) {
+      break;
+    }
+
+    page++;
+  }
+
+  return logs;
+}
+
+export async function fetchAndDisplayLogs(
   client: AxiosInstance,
   params: LogsQueryParams,
   asJson: boolean,
-  raw: boolean
+  raw: boolean,
+  nameFilter: string | null = null,
+  getLogsFn: GetLogsFn = getLogs
 ): Promise<void> {
   try {
-    const response = await getLogs(client, params);
-    const logs = response.items;
+    const logs = await collectLogsForDisplay(client, params, nameFilter, getLogsFn);
 
     if (asJson) {
       console.log(JSON.stringify(logs, null, 2));
       return;
     }
 
+    // --raw is a machine-readable JSONL contract: stdout must contain only
+    // one JSON object per log line, with no banners or empty-result text.
+    if (raw) {
+      const sortedLogs = [...logs].sort((a, b) =>
+        new Date(a.datetime).getTime() - new Date(b.datetime).getTime()
+      );
+      for (const log of sortedLogs) {
+        console.log(JSON.stringify(log));
+      }
+      return;
+    }
+
     if (logs.length === 0) {
       console.log('\nNo logs found for the specified criteria.');
       return;
@@ -203,11 +266,7 @@ async function fetchAndDisplayLogs(
     const useColors = process.stdout.isTTY !== false;
 
     for (const log of sortedLogs) {
-      if (raw) {
-        console.log(JSON.stringify(log));
-      } else {
-        console.log(formatLogEntry(log, useColors));
-      }
+      console.log(formatLogEntry(log, useColors));
     }
 
     console.log(`\n✅ Displayed ${logs.length} log entries`);
@@ -220,7 +279,8 @@ async function fetchAndDisplayLogs(
 async function tailLogs(
   client: AxiosInstance,
   params: LogsQueryParams,
-  asJson: boolean
+  asJson: boolean,
+  nameFilter: string | null = null
 ): Promise<void> {
   console.log('🔄 Watching for new logs (Ctrl+C to stop)...\n');
 
@@ -241,7 +301,7 @@ async function tailLogs(
       };
 
       const response = await getLogs(client, pollParams);
-      const logs = response.items;
+      const logs = filterByName(response.items, nameFilter);
 
       // Filter out already seen logs and sort by time
       const newLogs = logs
@@ -304,6 +364,7 @@ Filter Options:
   --flow <idn>          Filter by flow IDN
   --skill <idn>         Filter by skill IDN
   --message <text>      Search in log messages
+  --name <ActionName>   Filter by action name in data.name, e.g. Gen, GetMemory (client-side)
   --event-id <uuid>     Filter by external event ID
   --runtime-id <uuid>   Filter by runtime context ID
   --actor-id <uuid>     Filter by user actor ID
@@ -325,5 +386,12 @@ Examples:
   newo logs --type call --skill CreateActor    # Skill calls for CreateActor
   newo logs --flow CACreatorFlow --follow      # Tail logs for specific flow
   newo logs --json --per 100                   # Get 100 logs as JSON
+  newo logs --type call --name Gen --json      # Only Gen action calls
+
+Notes:
+  The model used for a turn is in data.source.model of the --json output —
+  do NOT infer it from actor/agent names.
+  external_event_id (newo sandbox --json) correlates a chat turn with its
+  logs: newo logs --event-id <id>
 `);
 }